PyObject* PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; char* compname; int fp; if (! PyArg_ParseTuple(args, "sssi", &mode, &rawmode, &compname, &fp)) return NULL; TRACE(("new tiff decoder %s\n", compname)); decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; if (! ImagingLibTiffInit(&decoder->state, fp)) { Py_DECREF(decoder); PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed"); return NULL; } decoder->decode = ImagingLibTiffDecode; return (PyObject*) decoder; }
PyObject* PyImaging_SgiRleDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int ystep = 1; int bpc = 1; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &bpc)) return NULL; decoder = PyImaging_DecoderNew(sizeof(SGISTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->pulls_fd = 1; decoder->decode = ImagingSgiRleDecode; decoder->state.ystep = ystep; ((SGISTATE*)decoder->state.context)->bpc = bpc; return (PyObject*) decoder; }
PyObject* PyImaging_RawDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int stride = 0; int ystep = 1; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep)) return NULL; decoder = PyImaging_DecoderNew(sizeof(RAWSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingRawDecode; decoder->state.ystep = ystep; ((RAWSTATE*)decoder->state.context)->stride = stride; return (PyObject*) decoder; }
JNIEXPORT jlong JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_start(JNIEnv *env, jobject pObj, jobject pBuf, jlong offset) { unpacker* uPtr = get_unpacker(env, pObj); // redirect our io to the default log file or whatever. uPtr->redirect_stdio(); void* buf = null; size_t buflen = 0; if (pBuf != null) { buf = env->GetDirectBufferAddress(pBuf); buflen = env->GetDirectBufferCapacity(pBuf); if (buflen == 0) buf = null; if (buf == null) { THROW_IOE(ERROR_INTERNAL); return 0; } if ((size_t)offset >= buflen) { buf = null; buflen = 0; } else { buf = (char*)buf + (size_t)offset; buflen -= (size_t)offset; } } uPtr->start(buf, buflen); if (uPtr->aborting()) { THROW_IOE(uPtr->get_abort_message()); return 0; } return ((jlong) uPtr->get_segments_remaining() << 32) + uPtr->get_files_remaining(); }
PyObject* PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int ystep = 1; int depth = 8; if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &depth)) return NULL; decoder = PyImaging_DecoderNew(0); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingTgaRleDecode; decoder->state.ystep = ystep; decoder->state.count = depth / 8; return (PyObject*) decoder; }
PyObject* PyImaging_ZipDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int interlaced = 0; if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &interlaced)) return NULL; decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingZipDecode; decoder->cleanup = ImagingZipDecodeCleanup; ((ZIPSTATE*)decoder->state.context)->interlaced = interlaced; return (PyObject*) decoder; }
PyObject* PyImaging_JpegDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; /* what we wan't from the decoder */ char* jpegmode; /* what's in the file */ int scale = 1; int draft = 0; if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode, &scale, &draft)) return NULL; if (!jpegmode) jpegmode = ""; decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingJpegDecode; decoder->cleanup = ImagingJpegDecodeCleanup; strncpy(((JPEGSTATE*)decoder->state.context)->rawmode, rawmode, 8); strncpy(((JPEGSTATE*)decoder->state.context)->jpegmode, jpegmode, 8); ((JPEGSTATE*)decoder->state.context)->scale = scale; ((JPEGSTATE*)decoder->state.context)->draft = draft; return (PyObject*) decoder; }
JNIEXPORT jlong JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_finish(JNIEnv *env, jobject pObj) { unpacker* uPtr = get_unpacker(env, pObj, false); if (uPtr == null) return 0; size_t consumed = uPtr->input_consumed(); free_unpacker(env, pObj, uPtr); return consumed; }
PyObject* PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; char* compname; int compression; int fp; if (! PyArg_ParseTuple(args, "sssi", &mode, &rawmode, &compname, &fp)) return NULL; TRACE(("new tiff decoder %s\n", compname)); /* UNDONE -- we can probably do almost any arbitrary compression here, * since we're effective passing in the whole file in one shot and * getting back the data row by row. V2 maybe */ if (strcasecmp(compname, "tiff_ccitt") == 0) { compression = COMPRESSION_CCITTRLE; } else if (strcasecmp(compname, "group3") == 0) { compression = COMPRESSION_CCITTFAX3; } else if (strcasecmp(compname, "group4") == 0) { compression = COMPRESSION_CCITTFAX4; } else if (strcasecmp(compname, "tiff_raw_16") == 0) { compression = COMPRESSION_CCITTRLEW; } else { PyErr_SetString(PyExc_ValueError, "unknown compession"); return NULL; } decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; if (! ImagingLibTiffInit(&decoder->state, compression, fp)) { Py_DECREF(decoder); PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed"); return NULL; } decoder->decode = ImagingLibTiffDecode; return (PyObject*) decoder; }
JNIEXPORT jboolean JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_setOption(JNIEnv *env, jobject pObj, jstring pProp, jstring pValue) { unpacker* uPtr = get_unpacker(env, pObj); const char* prop = env->GetStringUTFChars(pProp, JNI_FALSE); const char* value = env->GetStringUTFChars(pValue, JNI_FALSE); jboolean retval = uPtr->set_option(prop, value); env->ReleaseStringUTFChars(pProp, prop); env->ReleaseStringUTFChars(pValue, value); return retval; }
JNIEXPORT jstring JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_getOption(JNIEnv *env, jobject pObj, jstring pProp) { unpacker* uPtr = get_unpacker(env, pObj); const char* prop = env->GetStringUTFChars(pProp, JNI_FALSE); const char* value = uPtr->get_option(prop); env->ReleaseStringUTFChars(pProp, prop); if (value == null) return null; return env->NewStringUTF(value); }
PyObject* PyImaging_XbmDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; decoder = PyImaging_DecoderNew(0); if (decoder == NULL) return NULL; if (get_unpacker(decoder, "1", "1;R") < 0) return NULL; decoder->decode = ImagingXbmDecode; return (PyObject*) decoder; }
PyObject* PyImaging_PcdDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; decoder = PyImaging_DecoderNew(0); if (decoder == NULL) return NULL; /* Unpack from PhotoYCC to RGB */ if (get_unpacker(decoder, "RGB", "YCC;P") < 0) return NULL; decoder->decode = ImagingPcdDecode; return (PyObject*) decoder; }
// This is the harder trick: Pull the current state out of mid-air. static unpacker* get_unpacker() { //fprintf(stderr, "get_unpacker()\n"); JavaVM* vm = null; JNI_GetCreatedJavaVMs(&vm, 1, null); void* envRaw = null; vm->GetEnv(&envRaw, JNI_VERSION_1_1); JNIEnv* env = (JNIEnv*) envRaw; //fprintf(stderr, "get_unpacker() env=%p\n", env); if (env == null) return null; jobject pObj = env->CallStaticObjectMethod(NIclazz, currentInstMID); //fprintf(stderr, "get_unpacker() pObj=%p\n", pObj); if (pObj == null) return null; // Got pObj and env; now do it the easy way. return get_unpacker(env, pObj); }
JNIEXPORT jobject JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_getUnusedInput(JNIEnv *env, jobject pObj) { unpacker* uPtr = get_unpacker(env, pObj); unpacker::file* filep = &uPtr->cur_file; if (uPtr->aborting()) { THROW_IOE(uPtr->get_abort_message()); return false; } // We have fetched all the files. // Now swallow up any remaining input. if (uPtr->input_remaining() == 0) return null; else return env->NewDirectByteBuffer(uPtr->input_scan(), uPtr->input_remaining()); }
PyObject* PyImaging_JpegDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; /* what we want from the decoder */ char* jpegmode; /* what's in the file */ int scale = 1; int draft = 0; if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode, &scale, &draft)) return NULL; if (!jpegmode) jpegmode = ""; decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE)); if (decoder == NULL) return NULL; // libjpeg-turbo supports different output formats. // We are choosing Pillow's native format (3 color bytes + 1 padding) // to avoid extra conversion in Unpack.c. if (ImagingJpegUseJCSExtensions() && strcmp(rawmode, "RGB") == 0) { rawmode = "RGBX"; } if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingJpegDecode; decoder->cleanup = ImagingJpegDecodeCleanup; strncpy(((JPEGSTATE*)decoder->state.context)->rawmode, rawmode, 8); strncpy(((JPEGSTATE*)decoder->state.context)->jpegmode, jpegmode, 8); ((JPEGSTATE*)decoder->state.context)->scale = scale; ((JPEGSTATE*)decoder->state.context)->draft = draft; return (PyObject*) decoder; }
JNIEXPORT jboolean JNICALL Java_com_sun_java_util_jar_pack_NativeUnpack_getNextFile(JNIEnv *env, jobject pObj, jobjectArray pParts) { unpacker* uPtr = get_unpacker(env, pObj); unpacker::file* filep = uPtr->get_next_file(); if (uPtr->aborting()) { THROW_IOE(uPtr->get_abort_message()); return false; } if (filep == null) { return false; // end of the sequence } assert(filep == &uPtr->cur_file); int pidx = 0, iidx = 0; jintArray pIntParts = (jintArray) env->GetObjectArrayElement(pParts, pidx++); jint* intParts = env->GetIntArrayElements(pIntParts, null); intParts[iidx++] = (jint)( (julong)filep->size >> 32 ); intParts[iidx++] = (jint)( (julong)filep->size >> 0 ); intParts[iidx++] = filep->modtime; intParts[iidx++] = filep->deflate_hint() ? 1 : 0; env->ReleaseIntArrayElements(pIntParts, intParts, JNI_COMMIT); env->SetObjectArrayElement(pParts, pidx++, env->NewStringUTF(filep->name)); jobject pDataBuf = null; if (filep->data[0].len > 0) pDataBuf = env->NewDirectByteBuffer(filep->data[0].ptr, filep->data[0].len); env->SetObjectArrayElement(pParts, pidx++, pDataBuf); pDataBuf = null; if (filep->data[1].len > 0) pDataBuf = env->NewDirectByteBuffer(filep->data[1].ptr, filep->data[1].len); env->SetObjectArrayElement(pParts, pidx++, pDataBuf); return true; }
PyObject* PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode)) return NULL; decoder = PyImaging_DecoderNew(0); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingSunRleDecode; return (PyObject*) decoder; }
inline entry_t xml_db_file_source::get_entry( rapidxml::xml_node<>* node ) { entry_t entry; if ( std::memcmp( node->name(), "entry", node->name_size() ) != 0 ) throw std::runtime_error( "invalid db file" ); for ( rapidxml::xml_attribute<>* attr = node->first_attribute(); attr; attr = attr->next_attribute() ) { if ( std::memcmp( attr->name(), "name", attr->name_size() ) == 0 ) entry.name = normalize_string( attr->value() ); else if ( std::memcmp( attr->name(), "url", attr->name_size() ) == 0 ) entry.url = normalize_string( attr->value() ); else if ( std::memcmp( attr->name(), "description", attr->name_size() ) == 0 ) entry.description = normalize_string( attr->value() ); else if ( std::memcmp( attr->name(), "author", attr->name_size() ) == 0 ) entry.author = normalize_string( attr->value() ); else if ( std::memcmp( attr->name(), "priority", attr->name_size() ) == 0 ) entry.priority = normalize_string( attr->value() ); else throw std::runtime_error( "invalid db file" ); } for ( rapidxml::xml_node<>* next_node = node->first_node(); next_node; next_node = next_node->next_sibling() ) { if ( std::memcmp( next_node->name(), "signature", next_node->name_size() ) == 0 ) entry.signatures.push_back( get_signature( next_node ) ); else if ( std::memcmp( next_node->name(), "unpacker", next_node->name_size() ) == 0 ) entry.unpackers.push_back( get_unpacker( next_node ) ); else throw std::runtime_error( "invalid db file" ); } return entry; }
PyObject* PyImaging_PcxDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int stride; if (!PyArg_ParseTuple(args, "ssi", &mode, &rawmode, &stride)) return NULL; decoder = PyImaging_DecoderNew(0); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->state.bytes = stride; decoder->decode = ImagingPcxDecode; return (PyObject*) decoder; }
PyObject* PyImaging_TiffLzwDecoderNew(PyObject* self, PyObject* args) { ImagingDecoderObject* decoder; char* mode; char* rawmode; int filter = 0; if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &filter)) return NULL; decoder = PyImaging_DecoderNew(sizeof(LZWSTATE)); if (decoder == NULL) return NULL; if (get_unpacker(decoder, mode, rawmode) < 0) return NULL; decoder->decode = ImagingLzwDecode; ((LZWSTATE*)decoder->state.context)->filter = filter; return (PyObject*) decoder; }
unpacker* unpacker::current() { return get_unpacker(); }