JNIEXPORT void JNICALL Java_java_util_zip_Deflater_setInputImpl (JNIEnv * env, jobject recv, jbyteArray buf, jint off, jint len, jlong handle) { PORT_ACCESS_FROM_ENV (env); jbyte *in; JCLZipStream *stream; stream = (JCLZipStream *) ((IDATA) handle); if (stream->inaddr != NULL) /*Input has already been provided, free the old buffer */ jclmem_free_memory (env, stream->inaddr); stream->inaddr = jclmem_allocate_memory (env, len); if (stream->inaddr == NULL) { throwNewOutOfMemoryError (env, ""); return; } in = ((*env)->GetPrimitiveArrayCritical (env, buf, 0)); if (in == NULL) { throwNewOutOfMemoryError(env, ""); return; } memcpy (stream->inaddr, (in + off), len); ((*env)->ReleasePrimitiveArrayCritical (env, buf, in, JNI_ABORT)); stream->stream->next_in = (Bytef *) stream->inaddr; stream->stream->avail_in = len; return; }
void * sieb_malloc (JNIEnv * env, size_t byteCnt) { void * adr = malloc(byteCnt); if (adr == 0) { if (byteCnt == 0) throwNewOutOfMemoryError(env, "sieb_malloc(0) NOT ALLOWED"); else throwNewOutOfMemoryError(env, "sieb_malloc"); } return adr; }
JNIEXPORT jint JNICALL Java_java_util_zip_Deflater_deflateImpl (JNIEnv * env, jobject recv, jbyteArray buf, int off, int len, jlong handle, int flushParm) { jbyte *out; JCLZipStream *stream; jint err = 0; jint sin, sout, inBytes = 0; /* We need to get the number of bytes already read */ inBytes = ((*env)-> GetIntField (env, recv, JCL_CACHE_GET (env, FID_java_util_zip_Deflater_inRead))); stream = (JCLZipStream *) ((IDATA) handle); stream->stream->avail_out = len; sin = stream->stream->total_in; sout = stream->stream->total_out; out = ((*env)->GetPrimitiveArrayCritical (env, buf, 0)); if (out == NULL) { throwNewOutOfMemoryError(env, ""); return -1; } stream->stream->next_out = (Bytef *) out + off; err = deflate (stream->stream, flushParm); ((*env)->ReleasePrimitiveArrayCritical (env, buf, out, 0)); if (err != Z_OK) { if (err == Z_MEM_ERROR) { throwNewOutOfMemoryError(env, ""); return 0; } if (err == Z_STREAM_END) { ((*env)-> SetBooleanField (env, recv, JCL_CACHE_GET (env, FID_java_util_zip_Deflater_finished), JNI_TRUE)); return stream->stream->total_out - sout; } } if (flushParm != Z_FINISH) { /* Need to update the number of input bytes read. */ ((*env)-> SetIntField (env, recv, JCL_CACHE_GET (env, FID_java_util_zip_Deflater_inRead), (jint) stream->stream->total_in - sin + inBytes)); } return stream->stream->total_out - sout; }
/* Create a new stream . This stream cannot be used until it has been properly initialized. */ JNIEXPORT jlong JNICALL Java_java_util_zip_Deflater_createStream (JNIEnv * env, jobject recv, jint level, jint strategy, jboolean noHeader) { PORT_ACCESS_FROM_ENV (env); JCLZipStream *jstream; z_stream *stream; int err = 0; int wbits = 15; /*Use MAX for fastest */ #ifdef HY_ZIP_API VMI_ACCESS_FROM_ENV (env); VMIZipFunctionTable *zipFuncs; zipFuncs = (*VMI)->GetZipFunctions(VMI); #endif /*Allocate mem for wrapped struct */ jstream = jclmem_allocate_memory (env, sizeof (JCLZipStream)); if (jstream == NULL) { throwNewOutOfMemoryError (env, ""); return -1; } /*Allocate the z_stream */ stream = jclmem_allocate_memory (env, sizeof (z_stream)); if (stream == NULL) { jclmem_free_memory (env, jstream); throwNewOutOfMemoryError (env, ""); return -1; } stream->opaque = (void *) privatePortLibrary; stream->zalloc = zalloc; stream->zfree = zfree; jstream->stream = stream; jstream->dict = NULL; jstream->inaddr = NULL; /*Unable to find official doc that this is the way to avoid zlib header use. However doc in zipsup.c claims it is so */ if (noHeader) wbits = wbits / -1; err = deflateInit2 (stream, level, Z_DEFLATED, /*Only supported ZLIB method */ wbits, /*Window bits to use. 15 is fastest but consumes the most memory */ 9, /*Memory allocation for internal compression state. 9 uses the most. */ strategy); if (err != Z_OK) { THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException); return -1; } return (jlong) ((IDATA) jstream); }
JNIEXPORT void JNICALL Java_java_util_zip_Deflater_setDictionaryImpl (JNIEnv * env, jobject recv, jbyteArray dict, int off, int len, jlong handle) { PORT_ACCESS_FROM_ENV (env); int err = 0; char *dBytes; JCLZipStream *stream = (JCLZipStream *) ((IDATA) handle); dBytes = jclmem_allocate_memory (env, len); if (dBytes == NULL) { throwNewOutOfMemoryError (env, ""); return; } (*env)->GetByteArrayRegion (env, dict, off, len, (jbyte *) dBytes); err = deflateSetDictionary (stream->stream, (Bytef *) dBytes, len); if (err != Z_OK) { jclmem_free_memory (env, dBytes); THROW_ZIP_EXCEPTION(env, err, IllegalArgumentException); return; } stream->dict = (U_8*) dBytes; }
JNIEXPORT jlong JNICALL Java_org_apache_harmony_luni_platform_OSMemory_malloc (JNIEnv * env, jobject thiz, jlong size) { PORT_ACCESS_FROM_ENV (env); void *address = hymem_allocate_memory ((UDATA) size); if (address == NULL) { throwNewOutOfMemoryError(env, "Insufficient memory available."); } return (jlong) ((IDATA) address); }
JNIEXPORT jlong JNICALL Java_java_util_zip_CRC32_updateImpl (JNIEnv * env, jobject recv, jbyteArray buf, int off, int len, jlong crc) { jbyte *b; jlong result; b = ((*env)->GetPrimitiveArrayCritical (env, buf, 0)); if (b == NULL) { throwNewOutOfMemoryError(env, ""); return -1; } result = crc32 ((uLong) crc, (Bytef *) (b + off), (uInt) len); ((*env)->ReleasePrimitiveArrayCritical (env, buf, b, JNI_ABORT)); return result; }
/* * Class: org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter * Method: setIOS * Signature: (Ljavax/imageio/stream/ImageOutputStream;J)V */ JNIEXPORT void JNICALL Java_org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter_setIOS(JNIEnv *env, jobject encoder, jobject iosObj, jlong handle) { struct jpeg_compress_struct * cinfo = (struct jpeg_compress_struct *) (IDATA)handle; enc_client_data_ptr cdata = (enc_client_data_ptr) cinfo->client_data; if (cdata->ios != NULL) { (*env)->DeleteGlobalRef(env, cdata->ios); cdata->ios = NULL; } cdata->ios = (*env)->NewGlobalRef(env, iosObj); if (cdata->ios == NULL) { throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return; } cinfo->dest->next_output_byte = cdata->jpeg_buffer; cinfo->dest->free_in_buffer = MAX_BUFFER; }
/* * Class: org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter * Method: encode * Signature: ([BIIIIIIIZ[[IJ)Z */ JNIEXPORT jboolean JNICALL Java_org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter_encode(JNIEnv *env, jobject callerObj, jbyteArray arr, jint srcWidth, jint width, jint height, jint deltaX, jint in_cs, jint out_cs, jint numBands, jboolean progressive, jobjectArray dqts, jlong handle) { JSAMPROW row_pointer; struct jpeg_compress_struct * cinfo; enc_error_mgr_ptr err_mgr; int i, j; int cur_scanline; unsigned char * native_buffer; unsigned char * rowPtr; jboolean optimizeHuffman = FALSE; row_pointer = (JSAMPROW) malloc(width * numBands); if (!row_pointer) { throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return FALSE; } cinfo = (struct jpeg_compress_struct *) (IDATA)handle; err_mgr = (enc_error_mgr_ptr) cinfo->err; if (setjmp(err_mgr->jmp_buffer)) { if (!(*env)->ExceptionOccurred(env)) { char msg_buffer[JMSG_LENGTH_MAX]; cinfo->err->format_message((j_common_ptr)cinfo, msg_buffer); throwNewExceptionByName(env, "javax/imageio/IIOException", msg_buffer); } if (row_pointer) { free(row_pointer); } return FALSE; } cinfo->image_width = width; cinfo->image_height = height; cinfo->input_components = numBands; cinfo->in_color_space = in_cs; jpeg_set_defaults(cinfo); jpeg_set_colorspace(cinfo, out_cs); cinfo->optimize_coding = optimizeHuffman; //-- TRUE - for pure abbrivated images (wo tables) creation //-- if you want to write some tables set "sent_table = FALSE" after //-- this call for the table to be emitted. //jpeg_suppress_tables(&cinfo, TRUE); jpeg_suppress_tables(cinfo, FALSE); setupDQTs(env, cinfo, dqts); //-- only simple progression sequence if (progressive) { jpeg_simple_progression(cinfo); } //-- TRUE forces all "sent_table = FALSE" so all tables will be written jpeg_start_compress(cinfo, TRUE); //-- use this for tables-only files and abbrivated images. //-- If using jpeg_suppress_tables(&cinfo, TRUE): //-- Only DQT sent_table = FALSE right now -> so DQT will be written but not DHT. //-- uncomment when custom huffman tables be used. //jpeg_start_compress(&cinfo, FALSE); cur_scanline = 0; while (cinfo->next_scanline < cinfo->image_height) { (*env)->CallVoidMethod(env, callerObj, getScanlineID, cur_scanline); // checking for an exception in the java method if ((*env)->ExceptionOccurred(env)) { //c_struct->exception_in_callback = TRUE; cinfo->err->error_exit((j_common_ptr) cinfo); } native_buffer = (JOCTET*) (*env)->GetPrimitiveArrayCritical(env, arr, NULL); // subsampling and copying to internal array rowPtr = row_pointer; for (i = 0; i < srcWidth * numBands; i += numBands * deltaX) { for (j = 0; j < numBands; j++) { *rowPtr++ = native_buffer[i + j]; } } (*env)->ReleasePrimitiveArrayCritical(env, arr, native_buffer, 0); jpeg_write_scanlines(cinfo, &row_pointer, 1); cur_scanline++; } jpeg_finish_compress(cinfo); free(row_pointer); return TRUE; }
//GLOBAL(CompressStruct*) ios_create_compress(JNIEnv *env) { GLOBAL(struct jpeg_compress_struct *) ios_create_compress(JNIEnv *env) { struct jpeg_compress_struct * cinfo; struct jpeg_destination_mgr * dest_mgr; enc_error_mgr_ptr err_mgr; enc_client_data_ptr client_data; //-- create compress struct cinfo = malloc(sizeof(struct jpeg_compress_struct)); if (!cinfo) { throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return 0; } //-- create error manager err_mgr = malloc(sizeof(enc_error_mgr)); if (!err_mgr) { free(cinfo); throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return 0; } cinfo->err = jpeg_std_error(&(err_mgr->base)); err_mgr->base.error_exit = ios_jpeg_error_exit; //-- TODO setjmp before every call to libjpeg jpeg_create_compress(cinfo); dest_mgr = malloc(sizeof(struct jpeg_destination_mgr)); if (!dest_mgr) { free(cinfo); free(err_mgr); throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return 0; } cinfo->dest = dest_mgr; client_data = malloc(sizeof(enc_client_data)); if (!client_data) { free(cinfo); free(err_mgr); free(dest_mgr); throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return 0; } cinfo->client_data = client_data; client_data->ios = NULL; client_data->jpeg_buffer = malloc(MAX_BUFFER); if (!client_data->jpeg_buffer) { free(cinfo); free(err_mgr); free(dest_mgr); free(client_data); throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures"); return 0; } dest_mgr->next_output_byte = client_data->jpeg_buffer; dest_mgr->free_in_buffer = MAX_BUFFER; dest_mgr->init_destination = ios_init_destination; dest_mgr->empty_output_buffer = ios_empty_output_buffer; dest_mgr->term_destination = ios_term_destination; return cinfo; }
JNIEXPORT jbyteArray JNICALL Java_java_util_zip_ZipFile_inflateEntryImpl2 (JNIEnv * env, jobject recv, jlong descriptor, jstring entryName) { PORT_ACCESS_FROM_ENV (env); I_32 retval; HyZipFile *zipFile; HyZipEntry zipEntry; const char *entryCopy; jbyteArray buf; JCLZipFile *jclZipFile = (JCLZipFile *) (IDATA) descriptor; /* Build the zipFile */ if (jclZipFile == (void *) -1) { throwNewIllegalStateException (env, ""); return NULL; } zipFile = &(jclZipFile->hyZipFile); entryCopy = (*env)->GetStringUTFChars (env, entryName, NULL); if (entryCopy == NULL) return NULL; zip_initZipEntry (privatePortLibrary, &zipEntry); retval = zip_getZipEntry (privatePortLibrary, zipFile, &zipEntry, entryCopy, TRUE); (*env)->ReleaseStringUTFChars (env, entryName, entryCopy); if (retval) { zip_freeZipEntry (privatePortLibrary, &zipEntry); if (retval == ZIP_ERR_OUT_OF_MEMORY) throwNewOutOfMemoryError (env, ""); return NULL; } buf = (*env)->NewByteArray (env, zipEntry.uncompressedSize); if (!buf) { throwNewOutOfMemoryError (env, ""); return NULL; } retval = zip_getZipEntryData (privatePortLibrary, zipFile, &zipEntry, NULL, zipEntry.uncompressedSize); if (retval == 0) (*env)->SetByteArrayRegion (env, buf, 0, zipEntry.uncompressedSize, zipEntry.data); zip_freeZipEntry (privatePortLibrary, &zipEntry); if (!retval) return buf; if (retval == ZIP_ERR_OUT_OF_MEMORY) throwNewOutOfMemoryError (env, ""); else throwJavaZIOException (env, ""); return NULL; }
/** * Create a System Process with the specified * environment and arguments */ JNIEXPORT jlongArray JNICALL Java_org_apache_harmony_luni_internal_process_SystemProcess_createImpl (JNIEnv * env, jclass clazz, jobject recv, jobjectArray arg1, jobjectArray arg2, jbyteArray dir) { jbyteArray envString; jlongArray pVals = NULL; jlong npVals[4]; char *envArray[256]; char *command[256]; int i, retVal; IDATA pHandle, inHandle, outHandle, errHandle; int envLength, commandLineLength, len; char *workingDir = NULL; PORT_ACCESS_FROM_ENV (env); /* validate sizes */ commandLineLength = (*env)->GetArrayLength (env, arg1); envLength = (*env)->GetArrayLength (env, arg2); if (commandLineLength >= 255) { throwJavaIoIOException(env, "Too many arguments"); return NULL; } if (envLength >= 255) { throwJavaIoIOException(env, "Too many environment arguments"); return NULL; } memset (command, 0, sizeof (command)); memset (envArray, 0, sizeof (envArray)); /* Get the command string and arguments */ /* convert java.lang.String into C char* */ for (i = commandLineLength; --i >= 0;) { jbyteArray element = (*env)->GetObjectArrayElement (env, arg1, i); len = (*env)->GetArrayLength (env, element); command[i] = jclmem_allocate_memory (env, len + 1); if (command[i] == NULL) { throwNewOutOfMemoryError (env, ""); goto failed; } (*env)->GetByteArrayRegion (env, element, 0, len, (jbyte *)command[i]); command[i][len] = 0; } if (envLength) for (i = 0; i < envLength; i++) { envString = (*env)->GetObjectArrayElement (env, arg2, i); len = (*env)->GetArrayLength (env, envString); envArray[i] = jclmem_allocate_memory (env, len + 1); if (envArray[i] == NULL) { throwNewOutOfMemoryError (env, ""); goto failed; } (*env)->GetByteArrayRegion (env, envString, 0, len, (jbyte *)envArray[i]); envArray[i][len] = 0; } /* NULL terminate for UNIX (does work on windows too; in fact, it doesn't care) */ command[commandLineLength] = NULL; envArray[envLength] = NULL; if (dir != NULL) { jsize dirLength = (*env)->GetArrayLength (env, dir); workingDir = jclmem_allocate_memory (env, dirLength + 1); if (workingDir) { (*env)->GetByteArrayRegion (env, dir, 0, dirLength, (jbyte *) workingDir); workingDir[dirLength] = '\0'; } } /* * now call execProgram. Any non-zero return code * indicates some kind of failure */ retVal = execProgram (env, recv, command, commandLineLength, envArray, envLength, workingDir, &pHandle, &inHandle, &outHandle, &errHandle); if (workingDir) { jclmem_free_memory (env, workingDir); } if (retVal) { char errMsg[256]; /* Failed to exec program */ switch(retVal) { case 1001 : sprintf(errMsg, "Unable to start program : %s", "fork() failed with errno = EOMEM"); break; case 1002 : sprintf(errMsg, "Unable to start program : %s", "fork() failed with errno = EAGAIN"); break; default: sprintf(errMsg, "Unable to start program : %s", "unknown"); break; } throwJavaIoIOException(env, errMsg); goto failed; } pVals = (*env)->NewLongArray (env, 4); if (pVals) { npVals[0] = (jlong) pHandle; npVals[1] = (jlong) inHandle; npVals[2] = (jlong) outHandle; npVals[3] = (jlong) errHandle; (*env)->SetLongArrayRegion (env, pVals, 0, 4, (jlong *) (&npVals)); } failed: for (i = 0; i < envLength; i++) { if (envArray[i]) jclmem_free_memory (env, envArray[i]); } for (i = commandLineLength; --i >= 0;) { if (command[i]) jclmem_free_memory (env, command[i]); } return pVals; }