changeset in /hg/icedtea6: 2008-02-26 Lillian Angel <langel at re...
Lillian Angel
langel at redhat.com
Tue Feb 26 08:14:38 PST 2008
changeset f0d156ff5e76 in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=f0d156ff5e76
description:
2008-02-26 Lillian Angel <langel at redhat.com>
* patches/icedtea-libraries.patch: Fixed dlopen calls. No longer
hardcoding paths to libjpeg.so.62.
diffstat:
2 files changed, 804 insertions(+)
ChangeLog | 5
patches/icedtea-libraries.patch | 799 +++++++++++++++++++++++++++++++++++++++
diffs (truncated from 818 to 500 lines):
diff -r afd8000936d1 -r f0d156ff5e76 ChangeLog
--- a/ChangeLog Wed Feb 20 10:33:16 2008 -0500
+++ b/ChangeLog Tue Feb 26 11:04:51 2008 -0500
@@ -1,3 +1,8 @@ 2008-02-20 Joshua Sumali <jsumali at redh
+2008-02-26 Lillian Angel <langel at redhat.com>
+
+ * patches/icedtea-libraries.patch: Fixed dlopen calls. No longer
+ hardcoding paths to libjpeg.so.62.
+
2008-02-20 Joshua Sumali <jsumali at redhat.com>
* tools/netx/jnlp/security/CertWarningPane.java: Make run and cancel
diff -r afd8000936d1 -r f0d156ff5e76 patches/icedtea-libraries.patch
--- a/patches/icedtea-libraries.patch Wed Feb 20 10:33:16 2008 -0500
+++ b/patches/icedtea-libraries.patch Tue Feb 26 11:04:51 2008 -0500
@@ -25549,3 +25549,802 @@ diff -ruN ..openjdk.old/openjdk/jdk/src/
}
free(scanLinePtr);
RELEASE_ARRAYS(env, data, NULL);
+--- openjdkold/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c 2008-02-12 04:08:13.000000000 -0500
++++ openjdk/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c 2008-02-26 11:02:52.000000000 -0500
+@@ -51,7 +51,9 @@
+
+ /* headers from the JPEG library */
+ #include <jpeglib.h>
+-#include "jerror.h"
++#include <jerror.h>
++
++#include <dlfcn.h>
+
+ #undef MAX
+ #define MAX(a,b) ((a) > (b) ? (a) : (b))
+@@ -75,6 +77,62 @@
+ static jfieldID JPEGHuffmanTable_lengthsID;
+ static jfieldID JPEGHuffmanTable_valuesID;
+
++static void initIDs();
++
++typedef struct jpeg_error_mgr * (*fn_jpegstderror)(struct jpeg_error_mgr *);
++typedef boolean (*fn_jpegresynctorestart)(j_decompress_ptr, int);
++typedef JDIMENSION (*fn_jpegreadscanlines)(j_decompress_ptr, JSAMPARRAY, JDIMENSION);
++typedef boolean (*fn_jpegfinishoutput)(j_decompress_ptr);
++typedef int (*fn_jpegreadheader)(j_decompress_ptr, boolean);
++typedef boolean (*fn_jpegstartdecompress)(j_decompress_ptr);
++typedef boolean (*fn_jpeghasmultiplescans)(j_decompress_ptr);
++typedef boolean (*fn_jpegfinishdecompress)(j_decompress_ptr);
++typedef boolean (*fn_jpegstartoutput)(j_decompress_ptr, int);
++typedef void (*fn_jpegabort)(j_common_ptr);
++typedef void (*fn_jpegabortdecompress)(j_decompress_ptr);
++typedef JHUFF_TBL * (*fn_jpegallochufftable)(j_common_ptr);
++typedef JQUANT_TBL * (*fn_jpegallocquanttable)(j_common_ptr);
++typedef void (*fn_jpegcreatecompress)(j_compress_ptr, int, size_t);
++typedef void (*fn_jpegcreatedecompress)(j_decompress_ptr, int, size_t);
++typedef void (*fn_jpegdestroy)(j_common_ptr);
++typedef void (*fn_jpegfinishcompress)(j_compress_ptr);
++typedef boolean (*fn_jpeginputcomplete)(j_decompress_ptr);
++typedef void (*fn_jpegsavemarkers)(j_decompress_ptr, int, unsigned int);
++typedef void (*fn_jpegsetcolorspace)(j_compress_ptr, J_COLOR_SPACE);
++typedef void (*fn_jpegsetdefaults)(j_compress_ptr);
++typedef void (*fn_jpegsimpleprogression)(j_compress_ptr);
++typedef void (*fn_jpegstartcompress)(j_compress_ptr, boolean);
++typedef void (*fn_jpegsuppresstables)(j_compress_ptr, boolean);
++typedef JDIMENSION (*fn_jpegwritescanlines)(j_compress_ptr, JSAMPARRAY, JDIMENSION);
++typedef void (*fn_jpegwritetables)(j_compress_ptr);
++
++fn_jpegabort jpegabort;
++fn_jpegabortdecompress jpegabortdecompress;
++fn_jpegallochufftable jpegallochufftable;
++fn_jpegallocquanttable jpegallocquanttable;
++fn_jpegcreatecompress jpegcreatecompress;
++fn_jpegcreatedecompress jpegcreatedecompress;
++fn_jpegdestroy jpegdestroy;
++fn_jpegfinishcompress jpegfinishcompress;
++fn_jpeginputcomplete jpeginputcomplete;
++fn_jpegsavemarkers jpegsavemarkers;
++fn_jpegsetcolorspace jpegsetcolorspace;
++fn_jpegsetdefaults jpegsetdefaults;
++fn_jpegsimpleprogression jpegsimpleprogression;
++fn_jpegstartcompress jpegstartcompress;
++fn_jpegsuppresstables jpegsuppresstables;
++fn_jpegwritescanlines jpegwritescanlines;
++fn_jpegwritetables jpegwritetables;
++fn_jpegstderror jpegstderror;
++fn_jpegstartoutput jpegstartoutput;
++fn_jpegfinishdecompress jpegfinishdecompress;
++fn_jpeghasmultiplescans jpeghasmultiplescans;
++fn_jpegstartdecompress jpegstartdecompress;
++fn_jpegreadheader jpegreadheader;
++fn_jpegfinishoutput jpegfinishoutput;
++fn_jpegreadscanlines jpegreadscanlines;
++fn_jpegresynctorestart jpegresynctorestart;
++
+ /*
+ * Defined in jpegdecoder.c. Copy code from there if and
+ * when that disappears. */
+@@ -615,7 +673,7 @@
+ return;
+ }
+
+- jpeg_abort(cinfo); // Frees any markers, but not tables
++ jpegabort(cinfo); // Frees any markers, but not tables
+
+ }
+
+@@ -640,7 +698,7 @@
+ return;
+ }
+
+- jpeg_abort(cinfo); // Does not reset tables
++ jpegabort(cinfo); // Does not reset tables
+
+ }
+
+@@ -658,7 +716,7 @@
+ free(cinfo->dest);
+ cinfo->dest = NULL;
+ }
+- jpeg_destroy(info);
++ jpegdestroy(info);
+ free(info);
+ }
+ }
+@@ -694,14 +752,14 @@
+ decomp = (j_decompress_ptr) cinfo;
+ if (decomp->quant_tbl_ptrs[i] == NULL) {
+ decomp->quant_tbl_ptrs[i] =
+- jpeg_alloc_quant_table(cinfo);
++ jpegallocquanttable(cinfo);
+ }
+ quant_ptr = decomp->quant_tbl_ptrs[i];
+ } else {
+ comp = (j_compress_ptr) cinfo;
+ if (comp->quant_tbl_ptrs[i] == NULL) {
+ comp->quant_tbl_ptrs[i] =
+- jpeg_alloc_quant_table(cinfo);
++ jpegallocquanttable(cinfo);
+ }
+ quant_ptr = comp->quant_tbl_ptrs[i];
+ }
+@@ -777,14 +835,14 @@
+ decomp = (j_decompress_ptr) cinfo;
+ if (decomp->dc_huff_tbl_ptrs[i] == NULL) {
+ decomp->dc_huff_tbl_ptrs[i] =
+- jpeg_alloc_huff_table(cinfo);
++ jpegallochufftable(cinfo);
+ }
+ huff_ptr = decomp->dc_huff_tbl_ptrs[i];
+ } else {
+ comp = (j_compress_ptr) cinfo;
+ if (comp->dc_huff_tbl_ptrs[i] == NULL) {
+ comp->dc_huff_tbl_ptrs[i] =
+- jpeg_alloc_huff_table(cinfo);
++ jpegallochufftable(cinfo);
+ }
+ huff_ptr = comp->dc_huff_tbl_ptrs[i];
+ }
+@@ -798,14 +856,14 @@
+ decomp = (j_decompress_ptr) cinfo;
+ if (decomp->ac_huff_tbl_ptrs[i] == NULL) {
+ decomp->ac_huff_tbl_ptrs[i] =
+- jpeg_alloc_huff_table(cinfo);
++ jpegallochufftable(cinfo);
+ }
+ huff_ptr = decomp->ac_huff_tbl_ptrs[i];
+ } else {
+ comp = (j_compress_ptr) cinfo;
+ if (comp->ac_huff_tbl_ptrs[i] == NULL) {
+ comp->ac_huff_tbl_ptrs[i] =
+- jpeg_alloc_huff_table(cinfo);
++ jpegallochufftable(cinfo);
+ }
+ huff_ptr = comp->ac_huff_tbl_ptrs[i];
+ }
+@@ -1346,6 +1404,8 @@
+ jclass ImageInputStreamClass,
+ jclass qTableClass,
+ jclass huffClass) {
++
++ initIDs();
+
+ ImageInputStream_readID = (*env)->GetMethodID(env,
+ ImageInputStreamClass,
+@@ -1431,7 +1491,7 @@
+ }
+
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo->err = jpeg_std_error(&(jerr->pub));
++ cinfo->err = jpegstderror(&(jerr->pub));
+ jerr->pub.error_exit = sun_jpeg_error_exit;
+ /* We need to setup our own print routines */
+ jerr->pub.output_message = sun_jpeg_output_message;
+@@ -1448,11 +1508,11 @@
+ }
+
+ /* Perform library initialization */
+- jpeg_create_decompress(cinfo);
++ jpegcreatedecompress(cinfo, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct));
+
+ // Set up to keep any APP2 markers, as these might contain ICC profile
+ // data
+- jpeg_save_markers(cinfo, ICC_MARKER, 0xFFFF);
++ jpegsavemarkers(cinfo, ICC_MARKER, 0xFFFF);
+
+ /*
+ * Now set up our source.
+@@ -1470,7 +1530,7 @@
+ cinfo->src->init_source = imageio_init_source;
+ cinfo->src->fill_input_buffer = imageio_fill_input_buffer;
+ cinfo->src->skip_input_data = imageio_skip_input_data;
+- cinfo->src->resync_to_restart = jpeg_resync_to_restart; // use default
++ cinfo->src->resync_to_restart = jpegresynctorestart; // use default
+ cinfo->src->term_source = imageio_term_source;
+
+ /* set up the association to persist for future calls */
+@@ -1588,7 +1648,7 @@
+ src->bytes_in_buffer = 0;
+ }
+
+- ret = jpeg_read_header(cinfo, FALSE);
++ ret = jpegreadheader(cinfo, FALSE);
+
+ if (ret == JPEG_HEADER_TABLES_ONLY) {
+ retval = JNI_TRUE;
+@@ -1709,7 +1769,7 @@
+ cinfo->num_components,
+ read_icc_profile(env, cinfo));
+ if (reset) {
+- jpeg_abort_decompress(cinfo);
++ jpegabortdecompress(cinfo);
+ }
+ }
+
+@@ -1933,7 +1993,7 @@
+ TRUE);
+ }
+
+- progressive = jpeg_has_multiple_scans(cinfo);
++ progressive = jpeghasmultiplescans(cinfo);
+ if (progressive) {
+ cinfo->buffered_image = TRUE;
+ cinfo->input_scan_number = minProgressivePass+1; // Java count from 0
+@@ -1945,7 +2005,7 @@
+
+ data->streamBuf.suspendable = FALSE;
+
+- jpeg_start_decompress(cinfo);
++ jpegstartdecompress(cinfo);
+
+ // loop over progressive passes
+ done = FALSE;
+@@ -1953,7 +2013,7 @@
+ if (progressive) {
+ // initialize the next pass. Note that this skips up to
+ // the first interesting pass.
+- jpeg_start_output(cinfo, cinfo->input_scan_number);
++ jpegstartoutput(cinfo, cinfo->input_scan_number);
+ if (wantUpdates) {
+ (*env)->CallVoidMethod(env, this,
+ JPEGImageReader_passStartedID,
+@@ -1969,7 +2029,7 @@
+ // Skip until the first interesting line
+ while ((data->abortFlag == JNI_FALSE)
+ && ((jint)cinfo->output_scanline < sourceYStart)) {
+- jpeg_read_scanlines(cinfo, &scanLinePtr, 1);
++ jpegreadscanlines(cinfo, &scanLinePtr, 1);
+ }
+
+ scanlineLimit = sourceYStart+sourceHeight;
+@@ -1982,7 +2042,7 @@
+ while ((data->abortFlag == JNI_FALSE)
+ && ((jint)cinfo->output_scanline < scanlineLimit)) {
+
+- jpeg_read_scanlines(cinfo, &scanLinePtr, 1);
++ jpegreadscanlines(cinfo, &scanLinePtr, 1);
+
+ // Now mangle it into our buffer
+ out = data->pixelBuf.buf.bp;
+@@ -2037,13 +2097,13 @@
+ skipLines = linesLeft;
+ }
+ for(i = 0; i < skipLines; i++) {
+- jpeg_read_scanlines(cinfo, &scanLinePtr, 1);
++ jpegreadscanlines(cinfo, &scanLinePtr, 1);
+ }
+ }
+ if (progressive) {
+- jpeg_finish_output(cinfo); // Increments pass counter
++ jpegfinishoutput(cinfo); // Increments pass counter
+ // Call Java to notify pass complete
+- if (jpeg_input_complete(cinfo)
++ if (jpeginputcomplete(cinfo)
+ || (cinfo->input_scan_number > maxProgressivePass)) {
+ done = TRUE;
+ }
+@@ -2063,9 +2123,9 @@
+ if (cinfo->output_scanline == cinfo->output_height) {
+ // if ((cinfo->output_scanline == cinfo->output_height) &&
+ //(jpeg_input_complete(cinfo))) { // We read the whole file
+- jpeg_finish_decompress(cinfo);
++ jpegfinishdecompress(cinfo);
+ } else {
+- jpeg_abort_decompress(cinfo);
++ jpegabortdecompress(cinfo);
+ }
+
+ free(scanLinePtr);
+@@ -2111,7 +2171,7 @@
+
+ cinfo = (j_decompress_ptr) data->jpegObj;
+
+- jpeg_abort_decompress(cinfo);
++ jpegabortdecompress(cinfo);
+ }
+
+
+@@ -2317,6 +2377,142 @@
+
+ /********************** end of destination manager ************/
+
++METHODDEF(void)
++initIDs()
++{
++ void *handle = dlopen("libjpeg.so.62", RTLD_LAZY | RTLD_GLOBAL);
++
++ jpegstderror = (fn_jpegstderror)dlsym(handle, "jpeg_std_error");
++ if (jpegstderror == NULL) {
++ dlclose(handle);
++ }
++
++ jpegreadheader = (fn_jpegreadheader)dlsym(handle, "jpeg_read_header");
++ if (jpegreadheader == NULL) {
++ dlclose(handle);
++ }
++
++ jpeghasmultiplescans = (fn_jpeghasmultiplescans)dlsym(handle, "jpeg_has_multiple_scans");
++ if (jpeghasmultiplescans == NULL) {
++ dlclose(handle);
++ }
++
++ jpegstartdecompress = (fn_jpegstartdecompress)dlsym(handle, "jpeg_start_decompress");
++ if (jpegstartdecompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegstartoutput = (fn_jpegstartoutput)dlsym(handle, "jpeg_start_output");
++ if (jpegstartoutput == NULL) {
++ dlclose(handle);
++ }
++
++ jpegfinishdecompress = (fn_jpegfinishdecompress)dlsym(handle, "jpeg_finish_decompress");
++ if (jpegfinishdecompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegreadscanlines = (fn_jpegreadscanlines)dlsym(handle, "jpeg_read_scanlines");
++ if (jpegreadscanlines == NULL) {
++ dlclose(handle);
++ }
++
++ jpegfinishoutput = (fn_jpegfinishoutput)dlsym(handle, "jpeg_finish_output");
++ if (jpegfinishoutput == NULL) {
++ dlclose(handle);
++ }
++
++ jpegresynctorestart = (fn_jpegresynctorestart)dlsym(handle, "jpeg_resync_to_restart");
++ if (jpegresynctorestart == NULL) {
++ dlclose(handle);
++ }
++
++ jpegabort = (fn_jpegabort)dlsym(handle, "jpeg_abort");
++ if (jpegabort == NULL) {
++ dlclose(handle);
++ }
++
++ jpegabortdecompress = (fn_jpegabortdecompress)dlsym(handle, "jpeg_abort_decompress");
++ if (jpegabortdecompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegallochufftable = (fn_jpegallochufftable)dlsym(handle, "jpeg_alloc_huff_table");
++ if (jpegallochufftable == NULL) {
++ dlclose(handle);
++ }
++
++ jpegallocquanttable = (fn_jpegallocquanttable)dlsym(handle, "jpeg_alloc_quant_table");
++ if (jpegallocquanttable == NULL) {
++ dlclose(handle);
++ }
++
++ jpegcreatecompress = (fn_jpegcreatecompress)dlsym(handle, "jpeg_CreateCompress");
++ if (jpegcreatecompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegcreatedecompress = (fn_jpegcreatedecompress)dlsym(handle, "jpeg_CreateDecompress");
++ if (jpegcreatedecompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegdestroy = (fn_jpegdestroy)dlsym(handle, "jpeg_destroy");
++ if (jpegdestroy == NULL) {
++ dlclose(handle);
++ }
++
++ jpegfinishcompress = (fn_jpegfinishcompress)dlsym(handle, "jpeg_finish_compress");
++ if (jpegfinishcompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpeginputcomplete = (fn_jpeginputcomplete)dlsym(handle, "jpeg_input_complete");
++ if (jpeginputcomplete == NULL) {
++ dlclose(handle);
++ }
++
++ jpegsavemarkers = (fn_jpegsavemarkers)dlsym(handle, "jpeg_save_markers");
++ if (jpegsavemarkers == NULL) {
++ dlclose(handle);
++ }
++
++ jpegsetcolorspace = (fn_jpegsetcolorspace)dlsym(handle, "jpeg_set_colorspace");
++ if (jpegsetcolorspace == NULL) {
++ dlclose(handle);
++ }
++
++ jpegsetdefaults = (fn_jpegsetdefaults)dlsym(handle, "jpeg_set_defaults");
++ if (jpegsetdefaults == NULL) {
++ dlclose(handle);
++ }
++
++ jpegsimpleprogression = (fn_jpegsimpleprogression)dlsym(handle, "jpeg_simple_progression");
++ if (jpegsimpleprogression == NULL) {
++ dlclose(handle);
++ }
++
++ jpegstartcompress = (fn_jpegstartcompress)dlsym(handle, "jpeg_start_compress");
++ if (jpegstartcompress == NULL) {
++ dlclose(handle);
++ }
++
++ jpegsuppresstables = (fn_jpegsuppresstables)dlsym(handle, "jpeg_suppress_tables");
++ if (jpegsuppresstables == NULL) {
++ dlclose(handle);
++ }
++
++ jpegwritescanlines = (fn_jpegwritescanlines)dlsym(handle, "jpeg_write_scanlines");
++ if (jpegwritescanlines == NULL) {
++ dlclose(handle);
++ }
++
++ jpegwritetables = (fn_jpegwritetables)dlsym(handle, "jpeg_write_tables");
++ if (jpegwritetables == NULL) {
++ dlclose(handle);
++ }
++}
++
+ /********************** Writer JNI calls **********************/
+
+
+@@ -2328,6 +2524,8 @@
+ jclass qTableClass,
+ jclass huffClass) {
+
++ initIDs();
++
+ ImageOutputStream_writeID = (*env)->GetMethodID(env,
+ IOSClass,
+ "write",
+@@ -2401,7 +2599,7 @@
+ }
+
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo->err = jpeg_std_error(&(jerr->pub));
++ cinfo->err = jpegstderror(&(jerr->pub));
+ jerr->pub.error_exit = sun_jpeg_error_exit;
+ /* We need to setup our own print routines */
+ jerr->pub.output_message = sun_jpeg_output_message;
+@@ -2418,7 +2616,7 @@
+ }
+
+ /* Perform library initialization */
+- jpeg_create_compress(cinfo);
++ jpegcreatecompress(cinfo, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_compress_struct));
+
+ /* Now set up the destination */
+ dest = malloc(sizeof(struct jpeg_destination_mgr));
+@@ -2527,7 +2725,7 @@
+ return;
+ }
+
+- jpeg_suppress_tables(cinfo, TRUE); // Suppress writing of any current
++ jpegsuppresstables(cinfo, TRUE); // Suppress writing of any current
+
+ data->streamBuf.suspendable = FALSE;
+ if (qtables != NULL) {
+@@ -2542,7 +2740,7 @@
+ DCHuffmanTables, ACHuffmanTables, TRUE);
+ }
+
+- jpeg_write_tables(cinfo); // Flushes the buffer for you
++ jpegwritetables(cinfo); // Flushes the buffer for you
More information about the distro-pkg-dev
mailing list