From 5ebe60a00de3047d6f745094b06cce67d2d5a127 Mon Sep 17 00:00:00 2001 From: DrKLO Date: Sat, 17 May 2014 03:05:49 +0400 Subject: [PATCH] Improved notifications settings, 3x emoji, libjpeg, code refactoring, bug fixes https://github.com/DrKLO/Telegram/pull/418 --- TMessagesProj/build.gradle | 6 +- TMessagesProj/jni/Android.mk | 56 +- TMessagesProj/jni/image.c | 104 ++ TMessagesProj/jni/libjpeg/armv6_idct.S | 366 +++++ TMessagesProj/jni/libjpeg/jcapimin.c | 280 ++++ TMessagesProj/jni/libjpeg/jcapistd.c | 161 ++ TMessagesProj/jni/libjpeg/jccoefct.c | 449 ++++++ TMessagesProj/jni/libjpeg/jccolor.c | 527 ++++++ TMessagesProj/jni/libjpeg/jcdctmgr.c | 387 +++++ TMessagesProj/jni/libjpeg/jchuff.c | 909 +++++++++++ TMessagesProj/jni/libjpeg/jchuff.h | 47 + TMessagesProj/jni/libjpeg/jcinit.c | 72 + TMessagesProj/jni/libjpeg/jcmainct.c | 293 ++++ TMessagesProj/jni/libjpeg/jcmarker.c | 664 ++++++++ TMessagesProj/jni/libjpeg/jcmaster.c | 590 +++++++ TMessagesProj/jni/libjpeg/jcomapi.c | 106 ++ TMessagesProj/jni/libjpeg/jconfig.h | 156 ++ TMessagesProj/jni/libjpeg/jcparam.c | 610 +++++++ TMessagesProj/jni/libjpeg/jcphuff.c | 833 ++++++++++ TMessagesProj/jni/libjpeg/jcprepct.c | 354 +++++ TMessagesProj/jni/libjpeg/jcsample.c | 519 ++++++ TMessagesProj/jni/libjpeg/jctrans.c | 388 +++++ TMessagesProj/jni/libjpeg/jdapimin.c | 401 +++++ TMessagesProj/jni/libjpeg/jdapistd.c | 397 +++++ TMessagesProj/jni/libjpeg/jdatadst.c | 151 ++ TMessagesProj/jni/libjpeg/jdatasrc.c | 212 +++ TMessagesProj/jni/libjpeg/jdcoefct.c | 1038 ++++++++++++ TMessagesProj/jni/libjpeg/jdcolor.c | 899 +++++++++++ TMessagesProj/jni/libjpeg/jdct.h | 180 +++ TMessagesProj/jni/libjpeg/jddctmgr.c | 383 +++++ TMessagesProj/jni/libjpeg/jdhuff.c | 894 +++++++++++ TMessagesProj/jni/libjpeg/jdhuff.h | 202 +++ TMessagesProj/jni/libjpeg/jdinput.c | 415 +++++ TMessagesProj/jni/libjpeg/jdmainct.c | 512 ++++++ TMessagesProj/jni/libjpeg/jdmarker.c | 1410 +++++++++++++++++ TMessagesProj/jni/libjpeg/jdmaster.c | 580 +++++++ TMessagesProj/jni/libjpeg/jdmerge.c | 757 +++++++++ TMessagesProj/jni/libjpeg/jdphuff.c | 770 +++++++++ TMessagesProj/jni/libjpeg/jdpostct.c | 290 ++++ TMessagesProj/jni/libjpeg/jdsample.c | 478 ++++++ TMessagesProj/jni/libjpeg/jdtrans.c | 270 ++++ TMessagesProj/jni/libjpeg/jerror.c | 252 +++ TMessagesProj/jni/libjpeg/jerror.h | 291 ++++ TMessagesProj/jni/libjpeg/jfdctflt.c | 168 ++ TMessagesProj/jni/libjpeg/jfdctfst.c | 224 +++ TMessagesProj/jni/libjpeg/jfdctint.c | 283 ++++ TMessagesProj/jni/libjpeg/jidctflt.c | 242 +++ TMessagesProj/jni/libjpeg/jidctfst.c | 368 +++++ TMessagesProj/jni/libjpeg/jidctint.c | 389 +++++ TMessagesProj/jni/libjpeg/jidctred.c | 398 +++++ TMessagesProj/jni/libjpeg/jinclude.h | 91 ++ TMessagesProj/jni/libjpeg/jmemmgr.c | 1118 +++++++++++++ TMessagesProj/jni/libjpeg/jmemnobs.c | 109 ++ TMessagesProj/jni/libjpeg/jmemsys.h | 204 +++ TMessagesProj/jni/libjpeg/jmorecfg.h | 395 +++++ TMessagesProj/jni/libjpeg/jpegint.h | 432 +++++ TMessagesProj/jni/libjpeg/jpeglib.h | 1184 ++++++++++++++ TMessagesProj/jni/libjpeg/jquant1.c | 856 ++++++++++ TMessagesProj/jni/libjpeg/jquant2.c | 1310 +++++++++++++++ TMessagesProj/jni/libjpeg/jutils.c | 185 +++ TMessagesProj/jni/libjpeg/jversion.h | 14 + TMessagesProj/jni/utils.c | 14 + TMessagesProj/jni/utils.h | 3 + .../libs/armeabi-v7a/libtmessages.so | Bin 778916 -> 991908 bytes TMessagesProj/libs/armeabi/libtmessages.so | Bin 795280 -> 922256 bytes TMessagesProj/libs/x86/libtmessages.so | Bin 1377300 -> 1713204 bytes .../src/main/assets/emoji/emoji2.0x.jpg | Bin 0 -> 635669 bytes .../src/main/assets/emoji/emoji2.0x_a.jpg | Bin 0 -> 287249 bytes .../src/main/assets/emoji/emoji3.0x.jpg | Bin 0 -> 1136860 bytes .../src/main/assets/emoji/emoji3.0x_a.jpg | Bin 0 -> 486621 bytes .../src/main/assets/emojisprite_0.png | Bin 739663 -> 0 bytes .../src/main/assets/emojisprite_1.png | Bin 543573 -> 0 bytes .../src/main/assets/emojisprite_2.png | Bin 967006 -> 0 bytes .../src/main/assets/emojisprite_3.png | Bin 411864 -> 0 bytes .../src/main/assets/emojisprite_4.png | Bin 481487 -> 0 bytes .../telegram/messenger/ConnectionContext.java | 109 ++ .../messenger/ConnectionsManager.java | 366 ++--- .../org/telegram/messenger/Datacenter.java | 3 - .../java/org/telegram/messenger/Emoji.java | 389 ++--- .../telegram/messenger/FileLoadOperation.java | 12 +- .../messenger/FileUploadOperation.java | 4 +- .../telegram/messenger/HandshakeAction.java | 10 +- .../telegram/messenger/LocaleController.java | 45 +- .../telegram/messenger/MediaController.java | 112 +- .../messenger/MessagesController.java | 335 ++-- .../org/telegram/messenger/NativeLoader.java | 26 +- .../java/org/telegram/messenger/TLRPC.java | 2 +- .../org/telegram/messenger/TcpConnection.java | 3 +- .../org/telegram/messenger/Utilities.java | 65 +- .../org/telegram/objects/MessageObject.java | 6 +- .../org/telegram/ui/ApplicationLoader.java | 2 +- .../org/telegram/ui/Cells/ChatBaseCell.java | 2 + .../org/telegram/ui/Cells/ChatMediaCell.java | 3 +- .../org/telegram/ui/Cells/ChatOrUserCell.java | 20 +- .../org/telegram/ui/Cells/DialogCell.java | 8 +- .../java/org/telegram/ui/ChatActivity.java | 98 +- .../org/telegram/ui/ChatProfileActivity.java | 280 ++-- .../org/telegram/ui/ContactAddActivity.java | 15 +- .../telegram/ui/CountrySelectActivity.java | 2 - .../org/telegram/ui/GroupCreateActivity.java | 64 +- .../java/org/telegram/ui/IntroActivity.java | 2 + .../java/org/telegram/ui/LaunchActivity.java | 453 +++--- .../org/telegram/ui/LocationActivity.java | 6 +- .../java/org/telegram/ui/LoginActivity.java | 6 +- .../telegram/ui/LoginActivityPhoneView.java | 2 +- .../ui/LoginActivityRegisterView.java | 2 +- .../org/telegram/ui/LoginActivitySmsView.java | 14 +- .../org/telegram/ui/MessagesActivity.java | 2 +- .../org/telegram/ui/SettingsActivity.java | 28 +- .../ui/SettingsNotificationsActivity.java | 212 +-- .../org/telegram/ui/UserProfileActivity.java | 289 ++-- .../java/org/telegram/ui/Views/EmojiView.java | 13 +- .../org/telegram/ui/Views/GifDrawable.java | 4 +- .../org/telegram/ui/Views/ImageReceiver.java | 26 +- .../org/telegram/ui/Views/PZSImageView.java | 4 +- .../main/res/layout/settings_row_version.xml | 16 + .../src/main/res/values-ar/strings.xml | 5 +- .../src/main/res/values-de/strings.xml | 5 +- .../src/main/res/values-es/strings.xml | 5 +- .../src/main/res/values-it/strings.xml | 5 +- .../src/main/res/values-nl/strings.xml | 5 +- TMessagesProj/src/main/res/values/strings.xml | 5 +- 122 files changed, 28206 insertions(+), 1530 deletions(-) create mode 100644 TMessagesProj/jni/image.c create mode 100755 TMessagesProj/jni/libjpeg/armv6_idct.S create mode 100755 TMessagesProj/jni/libjpeg/jcapimin.c create mode 100755 TMessagesProj/jni/libjpeg/jcapistd.c create mode 100755 TMessagesProj/jni/libjpeg/jccoefct.c create mode 100755 TMessagesProj/jni/libjpeg/jccolor.c create mode 100755 TMessagesProj/jni/libjpeg/jcdctmgr.c create mode 100755 TMessagesProj/jni/libjpeg/jchuff.c create mode 100755 TMessagesProj/jni/libjpeg/jchuff.h create mode 100755 TMessagesProj/jni/libjpeg/jcinit.c create mode 100755 TMessagesProj/jni/libjpeg/jcmainct.c create mode 100755 TMessagesProj/jni/libjpeg/jcmarker.c create mode 100755 TMessagesProj/jni/libjpeg/jcmaster.c create mode 100755 TMessagesProj/jni/libjpeg/jcomapi.c create mode 100755 TMessagesProj/jni/libjpeg/jconfig.h create mode 100755 TMessagesProj/jni/libjpeg/jcparam.c create mode 100755 TMessagesProj/jni/libjpeg/jcphuff.c create mode 100755 TMessagesProj/jni/libjpeg/jcprepct.c create mode 100755 TMessagesProj/jni/libjpeg/jcsample.c create mode 100755 TMessagesProj/jni/libjpeg/jctrans.c create mode 100755 TMessagesProj/jni/libjpeg/jdapimin.c create mode 100755 TMessagesProj/jni/libjpeg/jdapistd.c create mode 100755 TMessagesProj/jni/libjpeg/jdatadst.c create mode 100755 TMessagesProj/jni/libjpeg/jdatasrc.c create mode 100755 TMessagesProj/jni/libjpeg/jdcoefct.c create mode 100755 TMessagesProj/jni/libjpeg/jdcolor.c create mode 100755 TMessagesProj/jni/libjpeg/jdct.h create mode 100755 TMessagesProj/jni/libjpeg/jddctmgr.c create mode 100755 TMessagesProj/jni/libjpeg/jdhuff.c create mode 100755 TMessagesProj/jni/libjpeg/jdhuff.h create mode 100755 TMessagesProj/jni/libjpeg/jdinput.c create mode 100755 TMessagesProj/jni/libjpeg/jdmainct.c create mode 100755 TMessagesProj/jni/libjpeg/jdmarker.c create mode 100755 TMessagesProj/jni/libjpeg/jdmaster.c create mode 100755 TMessagesProj/jni/libjpeg/jdmerge.c create mode 100755 TMessagesProj/jni/libjpeg/jdphuff.c create mode 100755 TMessagesProj/jni/libjpeg/jdpostct.c create mode 100755 TMessagesProj/jni/libjpeg/jdsample.c create mode 100755 TMessagesProj/jni/libjpeg/jdtrans.c create mode 100755 TMessagesProj/jni/libjpeg/jerror.c create mode 100755 TMessagesProj/jni/libjpeg/jerror.h create mode 100755 TMessagesProj/jni/libjpeg/jfdctflt.c create mode 100755 TMessagesProj/jni/libjpeg/jfdctfst.c create mode 100755 TMessagesProj/jni/libjpeg/jfdctint.c create mode 100755 TMessagesProj/jni/libjpeg/jidctflt.c create mode 100755 TMessagesProj/jni/libjpeg/jidctfst.c create mode 100755 TMessagesProj/jni/libjpeg/jidctint.c create mode 100755 TMessagesProj/jni/libjpeg/jidctred.c create mode 100755 TMessagesProj/jni/libjpeg/jinclude.h create mode 100755 TMessagesProj/jni/libjpeg/jmemmgr.c create mode 100755 TMessagesProj/jni/libjpeg/jmemnobs.c create mode 100755 TMessagesProj/jni/libjpeg/jmemsys.h create mode 100755 TMessagesProj/jni/libjpeg/jmorecfg.h create mode 100755 TMessagesProj/jni/libjpeg/jpegint.h create mode 100755 TMessagesProj/jni/libjpeg/jpeglib.h create mode 100755 TMessagesProj/jni/libjpeg/jquant1.c create mode 100755 TMessagesProj/jni/libjpeg/jquant2.c create mode 100755 TMessagesProj/jni/libjpeg/jutils.c create mode 100755 TMessagesProj/jni/libjpeg/jversion.h create mode 100644 TMessagesProj/jni/utils.c create mode 100644 TMessagesProj/src/main/assets/emoji/emoji2.0x.jpg create mode 100644 TMessagesProj/src/main/assets/emoji/emoji2.0x_a.jpg create mode 100644 TMessagesProj/src/main/assets/emoji/emoji3.0x.jpg create mode 100644 TMessagesProj/src/main/assets/emoji/emoji3.0x_a.jpg delete mode 100644 TMessagesProj/src/main/assets/emojisprite_0.png delete mode 100644 TMessagesProj/src/main/assets/emojisprite_1.png delete mode 100644 TMessagesProj/src/main/assets/emojisprite_2.png delete mode 100644 TMessagesProj/src/main/assets/emojisprite_3.png delete mode 100644 TMessagesProj/src/main/assets/emojisprite_4.png create mode 100644 TMessagesProj/src/main/java/org/telegram/messenger/ConnectionContext.java create mode 100644 TMessagesProj/src/main/res/layout/settings_row_version.xml diff --git a/TMessagesProj/build.gradle b/TMessagesProj/build.gradle index d0a742de8..0cf0b3990 100644 --- a/TMessagesProj/build.gradle +++ b/TMessagesProj/build.gradle @@ -3,7 +3,7 @@ buildscript { mavenCentral() } dependencies { - classpath 'com.android.tools.build:gradle:0.9.+' + classpath 'com.android.tools.build:gradle:0.10.+' } } apply plugin: 'android' @@ -25,7 +25,7 @@ dependencies { android { compileSdkVersion 19 - buildToolsVersion '19.0.3' + buildToolsVersion '19.1.0' aaptOptions.useAaptPngCruncher = true @@ -82,7 +82,7 @@ android { defaultConfig { minSdkVersion 8 targetSdkVersion 19 - versionCode 230 + versionCode 231 versionName "1.4.13" } } diff --git a/TMessagesProj/jni/Android.mk b/TMessagesProj/jni/Android.mk index 5bf5f2790..2a4ee466a 100755 --- a/TMessagesProj/jni/Android.mk +++ b/TMessagesProj/jni/Android.mk @@ -4,8 +4,9 @@ include $(CLEAR_VARS) LOCAL_MODULE := tmessages LOCAL_CFLAGS := -w -std=gnu99 -O3 -DNULL=0 -DSOCKLEN_T=socklen_t -DLOCALE_NOT_USED -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64 LOCAL_CFLAGS += -Drestrict='' -D__EMX__ -DOPUS_BUILD -DFIXED_POINT -DUSE_ALLOCA -DHAVE_LRINT -DHAVE_LRINTF -fno-math-errno +LOCAL_CFLAGS += -DANDROID_NDK -DDISABLE_IMPORTGL -fno-strict-aliasing -fprefetch-loop-arrays -DAVOID_TABLES -DANDROID_TILE_BASED_DECODE -DANDROID_ARMV6_IDCT LOCAL_CPPFLAGS := -DBSD=1 -ffast-math -O3 -funroll-loops -LOCAL_LDLIBS := -llog -lm +LOCAL_LDLIBS := -llog -lm -ljnigraphics LOCAL_SRC_FILES := \ ./opus/src/opus.c \ @@ -174,6 +175,55 @@ LOCAL_C_INCLUDES := \ ./opus/ \ ./opus/opusfile +LOCAL_SRC_FILES += \ +./libjpeg/jcapimin.c \ +./libjpeg/jcapistd.c \ +./libjpeg/armv6_idct.S \ +./libjpeg/jccoefct.c \ +./libjpeg/jccolor.c \ +./libjpeg/jcdctmgr.c \ +./libjpeg/jchuff.c \ +./libjpeg/jcinit.c \ +./libjpeg/jcmainct.c \ +./libjpeg/jcmarker.c \ +./libjpeg/jcmaster.c \ +./libjpeg/jcomapi.c \ +./libjpeg/jcparam.c \ +./libjpeg/jcphuff.c \ +./libjpeg/jcprepct.c \ +./libjpeg/jcsample.c \ +./libjpeg/jctrans.c \ +./libjpeg/jdapimin.c \ +./libjpeg/jdapistd.c \ +./libjpeg/jdatadst.c \ +./libjpeg/jdatasrc.c \ +./libjpeg/jdcoefct.c \ +./libjpeg/jdcolor.c \ +./libjpeg/jddctmgr.c \ +./libjpeg/jdhuff.c \ +./libjpeg/jdinput.c \ +./libjpeg/jdmainct.c \ +./libjpeg/jdmarker.c \ +./libjpeg/jdmaster.c \ +./libjpeg/jdmerge.c \ +./libjpeg/jdphuff.c \ +./libjpeg/jdpostct.c \ +./libjpeg/jdsample.c \ +./libjpeg/jdtrans.c \ +./libjpeg/jerror.c \ +./libjpeg/jfdctflt.c \ +./libjpeg/jfdctfst.c \ +./libjpeg/jfdctint.c \ +./libjpeg/jidctflt.c \ +./libjpeg/jidctfst.c \ +./libjpeg/jidctint.c \ +./libjpeg/jidctred.c \ +./libjpeg/jmemmgr.c \ +./libjpeg/jmemnobs.c \ +./libjpeg/jquant1.c \ +./libjpeg/jquant2.c \ +./libjpeg/jutils.c + LOCAL_SRC_FILES += \ ./jni.c \ ./sqlite_cursor.c \ @@ -181,6 +231,8 @@ LOCAL_SRC_FILES += \ ./sqlite_statement.c \ ./sqlite.c \ ./audio.c \ -./gif.c +./gif.c \ +./utils.c \ +./image.c include $(BUILD_SHARED_LIBRARY) \ No newline at end of file diff --git a/TMessagesProj/jni/image.c b/TMessagesProj/jni/image.c new file mode 100644 index 000000000..e60eed7b8 --- /dev/null +++ b/TMessagesProj/jni/image.c @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include +#include "utils.h" + +typedef struct my_error_mgr { + struct jpeg_error_mgr pub; + jmp_buf setjmp_buffer; +} *my_error_ptr; + + +METHODDEF(void) my_error_exit(j_common_ptr cinfo) { + my_error_ptr myerr = (my_error_ptr) cinfo->err; + (*cinfo->err->output_message) (cinfo); + longjmp(myerr->setjmp_buffer, 1); +} + +JNIEXPORT void Java_org_telegram_messenger_Utilities_loadBitmap(JNIEnv *env, jclass class, jstring path, jobject bitmap, int scale) { + + AndroidBitmapInfo info; + int i; + + if ((i = AndroidBitmap_getInfo(env, bitmap, &info)) >= 0) { + char *fileName = (*env)->GetStringUTFChars(env, path, NULL); + FILE *infile; + + if ((infile = fopen(fileName, "rb"))) { + struct my_error_mgr jerr; + struct jpeg_decompress_struct cinfo; + + cinfo.err = jpeg_std_error(&jerr.pub); + jerr.pub.error_exit = my_error_exit; + + if (!setjmp(jerr.setjmp_buffer)) { + jpeg_create_decompress(&cinfo); + jpeg_stdio_src(&cinfo, infile); + + jpeg_read_header(&cinfo, TRUE); + + cinfo.scale_denom = scale; + cinfo.scale_num = 1; + + jpeg_start_decompress(&cinfo); + int row_stride = cinfo.output_width * cinfo.output_components; + JSAMPARRAY buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); + + unsigned char *pixels; + if ((i = AndroidBitmap_lockPixels(env, bitmap, &pixels)) >= 0) { + + int rowCount = min(cinfo.output_height, info.height); + int colCount = min(cinfo.output_width, info.width); + + while (cinfo.output_scanline < rowCount) { + jpeg_read_scanlines(&cinfo, buffer, 1); + + if (info.format == ANDROID_BITMAP_FORMAT_RGBA_8888) { + if (cinfo.out_color_space == JCS_GRAYSCALE) { + for (i = 0; i < colCount; i++) { + float alpha = buffer[0][i] / 255.0f; + pixels[i * 4] *= alpha; + pixels[i * 4 + 1] *= alpha; + pixels[i * 4 + 2] *= alpha; + pixels[i * 4 + 3] = buffer[0][i]; + } + } else { + int c = 0; + for (i = 0; i < colCount; i++) { + pixels[i * 4] = buffer[0][i * 3]; + pixels[i * 4 + 1] = buffer[0][i * 3 + 1]; + pixels[i * 4 + 2] = buffer[0][i * 3 + 2]; + pixels[i * 4 + 3] = 255; + c += 4; + } + } + } else if (info.format == ANDROID_BITMAP_FORMAT_RGB_565) { + + } + + pixels += info.stride; + } + + AndroidBitmap_unlockPixels(env, bitmap); + } else { + throwException(env, "AndroidBitmap_lockPixels() failed ! error=%d", i); + } + + jpeg_finish_decompress(&cinfo); + } else { + throwException(env, "the JPEG code has signaled an error"); + } + + jpeg_destroy_decompress(&cinfo); + fclose(infile); + } else { + throwException(env, "can't open %s\n", fileName); + } + + (*env)->ReleaseStringUTFChars(env, path, fileName); + } else { + throwException(env, "AndroidBitmap_getInfo() failed ! error=%d", i); + } +} diff --git a/TMessagesProj/jni/libjpeg/armv6_idct.S b/TMessagesProj/jni/libjpeg/armv6_idct.S new file mode 100755 index 000000000..18e4e8a18 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/armv6_idct.S @@ -0,0 +1,366 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This is a fast-and-accurate implementation of inverse Discrete Cosine + * Transform (IDCT) for ARMv6+. It also performs dequantization of the input + * coefficients just like other methods. + * + * This implementation is based on the scaled 1-D DCT algorithm proposed by + * Arai, Agui, and Nakajima. The following code is based on the figure 4-8 + * on page 52 of the JPEG textbook by Pennebaker and Mitchell. Coefficients + * are (almost) directly mapped into registers. + * + * The accuracy is achieved by using SMULWy and SMLAWy instructions. Both + * multiply 32 bits by 16 bits and store the top 32 bits of the result. It + * makes 32-bit fixed-point arithmetic possible without overflow. That is + * why jpeg_idct_ifast(), which is written in C, cannot be improved. + * + * More tricks are used to gain more speed. First of all, we use as many + * registers as possible. ARM processor has 16 registers including sp (r13) + * and pc (r15), so only 14 registers can be used without limitations. In + * general, we let r0 to r7 hold the coefficients; r10 and r11 hold four + * 16-bit constants; r12 and r14 hold two of the four arguments; and r8 hold + * intermediate value. In the second pass, r9 is the loop counter. In the + * first pass, r8 to r11 are used to hold quantization values, so the loop + * counter is held by sp. Yes, the stack pointer. Since it must be aligned + * to 4-byte boundary all the time, we align it to 32-byte boundary and use + * bit 3 to bit 5. As the result, we actually use 14.1 registers. :-) + * + * Second, we rearrange quantization values to access them sequentially. The + * table is first transposed, and the new columns are placed in the order of + * 7, 5, 1, 3, 0, 2, 4, 6. Thus we can use LDMDB to load four values at a + * time. Rearranging coefficients also helps, but that requires to change a + * dozen of files, which seems not worth it. In addition, we choose to scale + * up quantization values by 13 bits, so the coefficients are scaled up by + * 16 bits after both passes. Then we can pack and saturate them two at a + * time using PKHTB and USAT16 instructions. + * + * Third, we reorder the instructions to avoid bubbles in the pipeline. This + * is done by hand accroding to the cycle timings and the interlock behavior + * described in the technical reference manual of ARM1136JF-S. We also take + * advantage of dual issue processors by interleaving instructions with + * dependencies. It has been benchmarked on four devices and all the results + * showed distinguishable improvements. Note that PLD instructions actually + * slow things down, so they are removed at the last minute. In the future, + * this might be futher improved using a system profiler. + */ + +#ifdef __arm__ +#include +#endif + +#if __ARM_ARCH__ >= 6 + +// void armv6_idct(short *coefs, int *quans, unsigned char *rows, int col) + .arm + .text + .align + .global armv6_idct + .func armv6_idct + +armv6_idct: + // Push everything except sp (r13) and pc (r15). + stmdb sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r12, r14} + + // r12 = quans, r14 = coefs. + sub r4, sp, #236 + bic sp, r4, #31 + add r5, sp, #224 + add r12, r1, #256 + stm r5, {r2, r3, r4} + add r14, r0, #16 + +pass1_head: + // Load quantization values. (q[0, 2, 4, 6]) + ldmdb r12!, {r8, r9, r10, r11} + + // Load coefficients. (c[4, 1, 2, 3, 0, 5, 6, 7]) + ldrsh r4, [r14, #-2] ! + ldrsh r1, [r14, #16] + ldrsh r2, [r14, #32] + ldrsh r3, [r14, #48] + ldrsh r0, [r14, #64] + ldrsh r5, [r14, #80] + ldrsh r6, [r14, #96] + ldrsh r7, [r14, #112] + + // r4 = q[0] * c[0]; + mul r4, r8, r4 + + // Check if ACs are all zero. + cmp r0, #0 + orreqs r8, r1, r2 + orreqs r8, r3, r5 + orreqs r8, r6, r7 + beq pass1_zero + + // Step 1: Dequantizations. + + // r2 = q[2] * c[2]; + // r0 = q[4] * c[4] + r4; + // r6 = q[6] * c[6] + r2; + mul r2, r9, r2 + mla r0, r10, r0, r4 + mla r6, r11, r6, r2 + + // Load quantization values. (q[7, 5, 1, 3]) + ldmdb r12!, {r8, r9, r10, r11} + + // r4 = r4 * 2 - r0 = -(r0 - r4 * 2); + // r2 = r2 * 2 - r6 = -(r6 - r2 * 2); + rsb r4, r0, r4, lsl #1 + rsb r2, r6, r2, lsl #1 + + // r7 = q[7] * c[7]; + // r5 = q[5] * c[5]; + // r1 = q[1] * c[1] + r7; + // r3 = q[3] * c[3] + r5; + mul r7, r8, r7 + mul r5, r9, r5 + mla r1, r10, r1, r7 + mla r3, r11, r3, r5 + + // Load constants. + ldrd r10, constants + + // Step 2: Rotations and Butterflies. + + // r7 = r1 - r7 * 2; + // r1 = r1 - r3; + // r5 = r5 * 2 - r3 = -(r3 - r5 * 2); + // r3 = r1 + r3 * 2; + // r8 = r5 + r7; + sub r7, r1, r7, lsl #1 + sub r1, r1, r3 + rsb r5, r3, r5, lsl #1 + add r3, r1, r3, lsl #1 + add r8, r5, r7 + + // r2 = r2 * 1.41421 = r2 * 27146 / 65536 + r2; + // r8 = r8 * 1.84776 / 8 = r8 * 15137 / 65536; + // r1 = r1 * 1.41421 = r1 * 27146 / 65536 + r1; + smlawt r2, r2, r10, r2 + smulwb r8, r8, r10 + smlawt r1, r1, r10, r1 + + // r0 = r0 + r6; + // r2 = r2 - r6; + // r6 = r0 - r6 * 2; + add r0, r0, r6 + sub r2, r2, r6 + sub r6, r0, r6, lsl #1 + + // r5 = r5 * -2.61313 / 8 + r8 = r5 * -21407 / 65536 + r8; + // r8 = r7 * -1.08239 / 8 + r8 = r7 * -8867 / 65536 + r8; + smlawt r5, r5, r11, r8 + smlawb r8, r7, r11, r8 + + // r4 = r4 + r2; + // r0 = r0 + r3; + // r2 = r4 - r2 * 2; + add r4, r4, r2 + add r0, r0, r3 + sub r2, r4, r2, lsl #1 + + // r7 = r5 * 8 - r3 = -(r3 - r5 * 8); + // r3 = r0 - r3 * 2; + // r1 = r1 - r7; + // r4 = r4 + r7; + // r5 = r8 * 8 - r1 = -(r1 - r8 * 8); + // r7 = r4 - r7 * 2; + rsb r7, r3, r5, lsl #3 + sub r3, r0, r3, lsl #1 + sub r1, r1, r7 + add r4, r4, r7 + rsb r5, r1, r8, lsl #3 + sub r7, r4, r7, lsl #1 + + // r2 = r2 + r1; + // r6 = r6 + r5; + // r1 = r2 - r1 * 2; + // r5 = r6 - r5 * 2; + add r2, r2, r1 + add r6, r6, r5 + sub r1, r2, r1, lsl #1 + sub r5, r6, r5, lsl #1 + + // Step 3: Reorder and Save. + + str r0, [sp, #-4] ! + str r4, [sp, #32] + str r2, [sp, #64] + str r6, [sp, #96] + str r5, [sp, #128] + str r1, [sp, #160] + str r7, [sp, #192] + str r3, [sp, #224] + b pass1_tail + + // Precomputed 16-bit constants: 27146, 15137, -21407, -8867. + // Put them in the middle since LDRD only accepts offsets from -255 to 255. + .align 3 +constants: + .word 0x6a0a3b21 + .word 0xac61dd5d + +pass1_zero: + str r4, [sp, #-4] ! + str r4, [sp, #32] + str r4, [sp, #64] + str r4, [sp, #96] + str r4, [sp, #128] + str r4, [sp, #160] + str r4, [sp, #192] + str r4, [sp, #224] + sub r12, r12, #16 + +pass1_tail: + ands r9, sp, #31 + bne pass1_head + + // r12 = rows, r14 = col. + ldr r12, [sp, #256] + ldr r14, [sp, #260] + + // Load constants. + ldrd r10, constants + +pass2_head: + // Load coefficients. (c[0, 1, 2, 3, 4, 5, 6, 7]) + ldmia sp!, {r0, r1, r2, r3, r4, r5, r6, r7} + + // r0 = r0 + 0x00808000; + add r0, r0, #0x00800000 + add r0, r0, #0x00008000 + + // Step 1: Analog to the first pass. + + // r0 = r0 + r4; + // r6 = r6 + r2; + add r0, r0, r4 + add r6, r6, r2 + + // r4 = r0 - r4 * 2; + // r2 = r2 * 2 - r6 = -(r6 - r2 * 2); + sub r4, r0, r4, lsl #1 + rsb r2, r6, r2, lsl #1 + + // r1 = r1 + r7; + // r3 = r3 + r5; + add r1, r1, r7 + add r3, r3, r5 + + // Step 2: Rotations and Butterflies. + + // r7 = r1 - r7 * 2; + // r1 = r1 - r3; + // r5 = r5 * 2 - r3 = -(r3 - r5 * 2); + // r3 = r1 + r3 * 2; + // r8 = r5 + r7; + sub r7, r1, r7, lsl #1 + sub r1, r1, r3 + rsb r5, r3, r5, lsl #1 + add r3, r1, r3, lsl #1 + add r8, r5, r7 + + // r2 = r2 * 1.41421 = r2 * 27146 / 65536 + r2; + // r8 = r8 * 1.84776 / 8 = r8 * 15137 / 65536; + // r1 = r1 * 1.41421 = r1 * 27146 / 65536 + r1; + smlawt r2, r2, r10, r2 + smulwb r8, r8, r10 + smlawt r1, r1, r10, r1 + + // r0 = r0 + r6; + // r2 = r2 - r6; + // r6 = r0 - r6 * 2; + add r0, r0, r6 + sub r2, r2, r6 + sub r6, r0, r6, lsl #1 + + // r5 = r5 * -2.61313 / 8 + r8 = r5 * -21407 / 65536 + r8; + // r8 = r7 * -1.08239 / 8 + r8 = r7 * -8867 / 65536 + r8; + smlawt r5, r5, r11, r8 + smlawb r8, r7, r11, r8 + + // r4 = r4 + r2; + // r0 = r0 + r3; + // r2 = r4 - r2 * 2; + add r4, r4, r2 + add r0, r0, r3 + sub r2, r4, r2, lsl #1 + + // r7 = r5 * 8 - r3 = -(r3 - r5 * 8); + // r3 = r0 - r3 * 2; + // r1 = r1 - r7; + // r4 = r4 + r7; + // r5 = r8 * 8 - r1 = -(r1 - r8 * 8); + // r7 = r4 - r7 * 2; + rsb r7, r3, r5, lsl #3 + sub r3, r0, r3, lsl #1 + sub r1, r1, r7 + add r4, r4, r7 + rsb r5, r1, r8, lsl #3 + sub r7, r4, r7, lsl #1 + + // r2 = r2 + r1; + // r6 = r6 + r5; + // r1 = r2 - r1 * 2; + // r5 = r6 - r5 * 2; + add r2, r2, r1 + add r6, r6, r5 + sub r1, r2, r1, lsl #1 + sub r5, r6, r5, lsl #1 + + // Step 3: Reorder and Save. + + // Load output pointer. + ldr r8, [r12], #4 + + // For little endian: r6, r2, r4, r0, r3, r7, r1, r5. + pkhtb r6, r6, r4, asr #16 + pkhtb r2, r2, r0, asr #16 + pkhtb r3, r3, r1, asr #16 + pkhtb r7, r7, r5, asr #16 + usat16 r6, #8, r6 + usat16 r2, #8, r2 + usat16 r3, #8, r3 + usat16 r7, #8, r7 + orr r0, r2, r6, lsl #8 + orr r1, r7, r3, lsl #8 + +#ifdef __ARMEB__ + // Reverse bytes for big endian. + rev r0, r0 + rev r1, r1 +#endif + + // Use STR instead of STRD to support unaligned access. + str r0, [r8, r14] ! + str r1, [r8, #4] + +pass2_tail: + adds r9, r9, #0x10000000 + bpl pass2_head + + ldr sp, [sp, #8] + add sp, sp, #236 + + ldmia sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r12, r14} + bx lr + .endfunc + +#endif diff --git a/TMessagesProj/jni/libjpeg/jcapimin.c b/TMessagesProj/jni/libjpeg/jcapimin.c new file mode 100755 index 000000000..54fb8c58c --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcapimin.c @@ -0,0 +1,280 @@ +/* + * jcapimin.c + * + * Copyright (C) 1994-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains application interface code for the compression half + * of the JPEG library. These are the "minimum" API routines that may be + * needed in either the normal full-compression case or the transcoding-only + * case. + * + * Most of the routines intended to be called directly by an application + * are in this file or in jcapistd.c. But also see jcparam.c for + * parameter-setup helper routines, jcomapi.c for routines shared by + * compression and decompression, and jctrans.c for the transcoding case. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Initialization of a JPEG compression object. + * The error manager must already be set up (in case memory manager fails). + */ + +GLOBAL(void) +jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize) +{ + int i; + + /* Guard against version mismatches between library and caller. */ + cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */ + if (version != JPEG_LIB_VERSION) + ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version); + if (structsize != SIZEOF(struct jpeg_compress_struct)) + ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, + (int) SIZEOF(struct jpeg_compress_struct), (int) structsize); + + /* For debugging purposes, we zero the whole master structure. + * But the application has already set the err pointer, and may have set + * client_data, so we have to save and restore those fields. + * Note: if application hasn't set client_data, tools like Purify may + * complain here. + */ + { + struct jpeg_error_mgr * err = cinfo->err; + void * client_data = cinfo->client_data; /* ignore Purify complaint here */ + MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct)); + cinfo->err = err; + cinfo->client_data = client_data; + } + cinfo->is_decompressor = FALSE; + + /* Initialize a memory manager instance for this object */ + jinit_memory_mgr((j_common_ptr) cinfo); + + /* Zero out pointers to permanent structures. */ + cinfo->progress = NULL; + cinfo->dest = NULL; + + cinfo->comp_info = NULL; + + for (i = 0; i < NUM_QUANT_TBLS; i++) + cinfo->quant_tbl_ptrs[i] = NULL; + + for (i = 0; i < NUM_HUFF_TBLS; i++) { + cinfo->dc_huff_tbl_ptrs[i] = NULL; + cinfo->ac_huff_tbl_ptrs[i] = NULL; + } + + cinfo->script_space = NULL; + + cinfo->input_gamma = 1.0; /* in case application forgets */ + + /* OK, I'm ready */ + cinfo->global_state = CSTATE_START; +} + + +/* + * Destruction of a JPEG compression object + */ + +GLOBAL(void) +jpeg_destroy_compress (j_compress_ptr cinfo) +{ + jpeg_destroy((j_common_ptr) cinfo); /* use common routine */ +} + + +/* + * Abort processing of a JPEG compression operation, + * but don't destroy the object itself. + */ + +GLOBAL(void) +jpeg_abort_compress (j_compress_ptr cinfo) +{ + jpeg_abort((j_common_ptr) cinfo); /* use common routine */ +} + + +/* + * Forcibly suppress or un-suppress all quantization and Huffman tables. + * Marks all currently defined tables as already written (if suppress) + * or not written (if !suppress). This will control whether they get emitted + * by a subsequent jpeg_start_compress call. + * + * This routine is exported for use by applications that want to produce + * abbreviated JPEG datastreams. It logically belongs in jcparam.c, but + * since it is called by jpeg_start_compress, we put it here --- otherwise + * jcparam.o would be linked whether the application used it or not. + */ + +GLOBAL(void) +jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress) +{ + int i; + JQUANT_TBL * qtbl; + JHUFF_TBL * htbl; + + for (i = 0; i < NUM_QUANT_TBLS; i++) { + if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL) + qtbl->sent_table = suppress; + } + + for (i = 0; i < NUM_HUFF_TBLS; i++) { + if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL) + htbl->sent_table = suppress; + if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL) + htbl->sent_table = suppress; + } +} + + +/* + * Finish JPEG compression. + * + * If a multipass operating mode was selected, this may do a great deal of + * work including most of the actual output. + */ + +GLOBAL(void) +jpeg_finish_compress (j_compress_ptr cinfo) +{ + JDIMENSION iMCU_row; + + if (cinfo->global_state == CSTATE_SCANNING || + cinfo->global_state == CSTATE_RAW_OK) { + /* Terminate first pass */ + if (cinfo->next_scanline < cinfo->image_height) + ERREXIT(cinfo, JERR_TOO_LITTLE_DATA); + (*cinfo->master->finish_pass) (cinfo); + } else if (cinfo->global_state != CSTATE_WRCOEFS) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + /* Perform any remaining passes */ + while (! cinfo->master->is_last_pass) { + (*cinfo->master->prepare_for_pass) (cinfo); + for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) { + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) iMCU_row; + cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + /* We bypass the main controller and invoke coef controller directly; + * all work is being done from the coefficient buffer. + */ + if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL)) + ERREXIT(cinfo, JERR_CANT_SUSPEND); + } + (*cinfo->master->finish_pass) (cinfo); + } + /* Write EOI, do final cleanup */ + (*cinfo->marker->write_file_trailer) (cinfo); + (*cinfo->dest->term_destination) (cinfo); + /* We can use jpeg_abort to release memory and reset global_state */ + jpeg_abort((j_common_ptr) cinfo); +} + + +/* + * Write a special marker. + * This is only recommended for writing COM or APPn markers. + * Must be called after jpeg_start_compress() and before + * first call to jpeg_write_scanlines() or jpeg_write_raw_data(). + */ + +GLOBAL(void) +jpeg_write_marker (j_compress_ptr cinfo, int marker, + const JOCTET *dataptr, unsigned int datalen) +{ + JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val)); + + if (cinfo->next_scanline != 0 || + (cinfo->global_state != CSTATE_SCANNING && + cinfo->global_state != CSTATE_RAW_OK && + cinfo->global_state != CSTATE_WRCOEFS)) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + (*cinfo->marker->write_marker_header) (cinfo, marker, datalen); + write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */ + while (datalen--) { + (*write_marker_byte) (cinfo, *dataptr); + dataptr++; + } +} + +/* Same, but piecemeal. */ + +GLOBAL(void) +jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen) +{ + if (cinfo->next_scanline != 0 || + (cinfo->global_state != CSTATE_SCANNING && + cinfo->global_state != CSTATE_RAW_OK && + cinfo->global_state != CSTATE_WRCOEFS)) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + (*cinfo->marker->write_marker_header) (cinfo, marker, datalen); +} + +GLOBAL(void) +jpeg_write_m_byte (j_compress_ptr cinfo, int val) +{ + (*cinfo->marker->write_marker_byte) (cinfo, val); +} + + +/* + * Alternate compression function: just write an abbreviated table file. + * Before calling this, all parameters and a data destination must be set up. + * + * To produce a pair of files containing abbreviated tables and abbreviated + * image data, one would proceed as follows: + * + * initialize JPEG object + * set JPEG parameters + * set destination to table file + * jpeg_write_tables(cinfo); + * set destination to image file + * jpeg_start_compress(cinfo, FALSE); + * write data... + * jpeg_finish_compress(cinfo); + * + * jpeg_write_tables has the side effect of marking all tables written + * (same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress + * will not re-emit the tables unless it is passed write_all_tables=TRUE. + */ + +GLOBAL(void) +jpeg_write_tables (j_compress_ptr cinfo) +{ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + /* (Re)initialize error mgr and destination modules */ + (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); + (*cinfo->dest->init_destination) (cinfo); + /* Initialize the marker writer ... bit of a crock to do it here. */ + jinit_marker_writer(cinfo); + /* Write them tables! */ + (*cinfo->marker->write_tables_only) (cinfo); + /* And clean up. */ + (*cinfo->dest->term_destination) (cinfo); + /* + * In library releases up through v6a, we called jpeg_abort() here to free + * any working memory allocated by the destination manager and marker + * writer. Some applications had a problem with that: they allocated space + * of their own from the library memory manager, and didn't want it to go + * away during write_tables. So now we do nothing. This will cause a + * memory leak if an app calls write_tables repeatedly without doing a full + * compression cycle or otherwise resetting the JPEG object. However, that + * seems less bad than unexpectedly freeing memory in the normal case. + * An app that prefers the old behavior can call jpeg_abort for itself after + * each call to jpeg_write_tables(). + */ +} diff --git a/TMessagesProj/jni/libjpeg/jcapistd.c b/TMessagesProj/jni/libjpeg/jcapistd.c new file mode 100755 index 000000000..c0320b1b1 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcapistd.c @@ -0,0 +1,161 @@ +/* + * jcapistd.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains application interface code for the compression half + * of the JPEG library. These are the "standard" API routines that are + * used in the normal full-compression case. They are not used by a + * transcoding-only application. Note that if an application links in + * jpeg_start_compress, it will end up linking in the entire compressor. + * We thus must separate this file from jcapimin.c to avoid linking the + * whole compression library into a transcoder. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Compression initialization. + * Before calling this, all parameters and a data destination must be set up. + * + * We require a write_all_tables parameter as a failsafe check when writing + * multiple datastreams from the same compression object. Since prior runs + * will have left all the tables marked sent_table=TRUE, a subsequent run + * would emit an abbreviated stream (no tables) by default. This may be what + * is wanted, but for safety's sake it should not be the default behavior: + * programmers should have to make a deliberate choice to emit abbreviated + * images. Therefore the documentation and examples should encourage people + * to pass write_all_tables=TRUE; then it will take active thought to do the + * wrong thing. + */ + +GLOBAL(void) +jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables) +{ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + if (write_all_tables) + jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */ + + /* (Re)initialize error mgr and destination modules */ + (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); + (*cinfo->dest->init_destination) (cinfo); + /* Perform master selection of active modules */ + jinit_compress_master(cinfo); + /* Set up for the first pass */ + (*cinfo->master->prepare_for_pass) (cinfo); + /* Ready for application to drive first pass through jpeg_write_scanlines + * or jpeg_write_raw_data. + */ + cinfo->next_scanline = 0; + cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING); +} + + +/* + * Write some scanlines of data to the JPEG compressor. + * + * The return value will be the number of lines actually written. + * This should be less than the supplied num_lines only in case that + * the data destination module has requested suspension of the compressor, + * or if more than image_height scanlines are passed in. + * + * Note: we warn about excess calls to jpeg_write_scanlines() since + * this likely signals an application programmer error. However, + * excess scanlines passed in the last valid call are *silently* ignored, + * so that the application need not adjust num_lines for end-of-image + * when using a multiple-scanline buffer. + */ + +GLOBAL(JDIMENSION) +jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines, + JDIMENSION num_lines) +{ + JDIMENSION row_ctr, rows_left; + + if (cinfo->global_state != CSTATE_SCANNING) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + if (cinfo->next_scanline >= cinfo->image_height) + WARNMS(cinfo, JWRN_TOO_MUCH_DATA); + + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) cinfo->next_scanline; + cinfo->progress->pass_limit = (long) cinfo->image_height; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + + /* Give master control module another chance if this is first call to + * jpeg_write_scanlines. This lets output of the frame/scan headers be + * delayed so that application can write COM, etc, markers between + * jpeg_start_compress and jpeg_write_scanlines. + */ + if (cinfo->master->call_pass_startup) + (*cinfo->master->pass_startup) (cinfo); + + /* Ignore any extra scanlines at bottom of image. */ + rows_left = cinfo->image_height - cinfo->next_scanline; + if (num_lines > rows_left) + num_lines = rows_left; + + row_ctr = 0; + (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines); + cinfo->next_scanline += row_ctr; + return row_ctr; +} + + +/* + * Alternate entry point to write raw data. + * Processes exactly one iMCU row per call, unless suspended. + */ + +GLOBAL(JDIMENSION) +jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION num_lines) +{ + JDIMENSION lines_per_iMCU_row; + + if (cinfo->global_state != CSTATE_RAW_OK) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + if (cinfo->next_scanline >= cinfo->image_height) { + WARNMS(cinfo, JWRN_TOO_MUCH_DATA); + return 0; + } + + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) cinfo->next_scanline; + cinfo->progress->pass_limit = (long) cinfo->image_height; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + + /* Give master control module another chance if this is first call to + * jpeg_write_raw_data. This lets output of the frame/scan headers be + * delayed so that application can write COM, etc, markers between + * jpeg_start_compress and jpeg_write_raw_data. + */ + if (cinfo->master->call_pass_startup) + (*cinfo->master->pass_startup) (cinfo); + + /* Verify that at least one iMCU row has been passed. */ + lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE; + if (num_lines < lines_per_iMCU_row) + ERREXIT(cinfo, JERR_BUFFER_SIZE); + + /* Directly compress the row. */ + if (! (*cinfo->coef->compress_data) (cinfo, data)) { + /* If compressor did not consume the whole row, suspend processing. */ + return 0; + } + + /* OK, we processed one iMCU row. */ + cinfo->next_scanline += lines_per_iMCU_row; + return lines_per_iMCU_row; +} diff --git a/TMessagesProj/jni/libjpeg/jccoefct.c b/TMessagesProj/jni/libjpeg/jccoefct.c new file mode 100755 index 000000000..1963ddb61 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jccoefct.c @@ -0,0 +1,449 @@ +/* + * jccoefct.c + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the coefficient buffer controller for compression. + * This controller is the top level of the JPEG compressor proper. + * The coefficient buffer lies between forward-DCT and entropy encoding steps. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* We use a full-image coefficient buffer when doing Huffman optimization, + * and also for writing multiple-scan JPEG files. In all cases, the DCT + * step is run during the first pass, and subsequent passes need only read + * the buffered coefficients. + */ +#ifdef ENTROPY_OPT_SUPPORTED +#define FULL_COEF_BUFFER_SUPPORTED +#else +#ifdef C_MULTISCAN_FILES_SUPPORTED +#define FULL_COEF_BUFFER_SUPPORTED +#endif +#endif + + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_c_coef_controller pub; /* public fields */ + + JDIMENSION iMCU_row_num; /* iMCU row # within image */ + JDIMENSION mcu_ctr; /* counts MCUs processed in current row */ + int MCU_vert_offset; /* counts MCU rows within iMCU row */ + int MCU_rows_per_iMCU_row; /* number of such rows needed */ + + /* For single-pass compression, it's sufficient to buffer just one MCU + * (although this may prove a bit slow in practice). We allocate a + * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each + * MCU constructed and sent. (On 80x86, the workspace is FAR even though + * it's not really very big; this is to keep the module interfaces unchanged + * when a large coefficient buffer is necessary.) + * In multi-pass modes, this array points to the current MCU's blocks + * within the virtual arrays. + */ + JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU]; + + /* In multi-pass modes, we need a virtual block array for each component. */ + jvirt_barray_ptr whole_image[MAX_COMPONENTS]; +} my_coef_controller; + +typedef my_coef_controller * my_coef_ptr; + + +/* Forward declarations */ +METHODDEF(boolean) compress_data + JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); +#ifdef FULL_COEF_BUFFER_SUPPORTED +METHODDEF(boolean) compress_first_pass + JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); +METHODDEF(boolean) compress_output + JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); +#endif + + +LOCAL(void) +start_iMCU_row (j_compress_ptr cinfo) +/* Reset within-iMCU-row counters for a new row */ +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + /* In an interleaved scan, an MCU row is the same as an iMCU row. + * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. + * But at the bottom of the image, process only what's left. + */ + if (cinfo->comps_in_scan > 1) { + coef->MCU_rows_per_iMCU_row = 1; + } else { + if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1)) + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; + else + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; + } + + coef->mcu_ctr = 0; + coef->MCU_vert_offset = 0; +} + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + coef->iMCU_row_num = 0; + start_iMCU_row(cinfo); + + switch (pass_mode) { + case JBUF_PASS_THRU: + if (coef->whole_image[0] != NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + coef->pub.compress_data = compress_data; + break; +#ifdef FULL_COEF_BUFFER_SUPPORTED + case JBUF_SAVE_AND_PASS: + if (coef->whole_image[0] == NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + coef->pub.compress_data = compress_first_pass; + break; + case JBUF_CRANK_DEST: + if (coef->whole_image[0] == NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + coef->pub.compress_data = compress_output; + break; +#endif + default: + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + break; + } +} + + +/* + * Process some data in the single-pass case. + * We process the equivalent of one fully interleaved MCU row ("iMCU" row) + * per call, ie, v_samp_factor block rows for each component in the image. + * Returns TRUE if the iMCU row is completed, FALSE if suspended. + * + * NB: input_buf contains a plane for each component in image, + * which we index according to the component's SOF position. + */ + +METHODDEF(boolean) +compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + int blkn, bi, ci, yindex, yoffset, blockcnt; + JDIMENSION ypos, xpos; + jpeg_component_info *compptr; + + /* Loop to write as much as one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col; + MCU_col_num++) { + /* Determine where data comes from in input_buf and do the DCT thing. + * Each call on forward_DCT processes a horizontal row of DCT blocks + * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks + * sequentially. Dummy blocks at the right or bottom edge are filled in + * specially. The data in them does not matter for image reconstruction, + * so we fill them with values that will encode to the smallest amount of + * data, viz: all zeroes in the AC entries, DC entries equal to previous + * block's DC value. (Thanks to Thomas Kinsman for this idea.) + */ + blkn = 0; + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width + : compptr->last_col_width; + xpos = MCU_col_num * compptr->MCU_sample_width; + ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */ + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + if (coef->iMCU_row_num < last_iMCU_row || + yoffset+yindex < compptr->last_row_height) { + (*cinfo->fdct->forward_DCT) (cinfo, compptr, + input_buf[compptr->component_index], + coef->MCU_buffer[blkn], + ypos, xpos, (JDIMENSION) blockcnt); + if (blockcnt < compptr->MCU_width) { + /* Create some dummy blocks at the right edge of the image. */ + jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt], + (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK)); + for (bi = blockcnt; bi < compptr->MCU_width; bi++) { + coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0]; + } + } + } else { + /* Create a row of dummy blocks at the bottom of the image. */ + jzero_far((void FAR *) coef->MCU_buffer[blkn], + compptr->MCU_width * SIZEOF(JBLOCK)); + for (bi = 0; bi < compptr->MCU_width; bi++) { + coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0]; + } + } + blkn += compptr->MCU_width; + ypos += DCTSIZE; + } + } + /* Try to write the MCU. In event of a suspension failure, we will + * re-DCT the MCU on restart (a bit inefficient, could be fixed...) + */ + if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->mcu_ctr = MCU_col_num; + return FALSE; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->mcu_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + coef->iMCU_row_num++; + start_iMCU_row(cinfo); + return TRUE; +} + + +#ifdef FULL_COEF_BUFFER_SUPPORTED + +/* + * Process some data in the first pass of a multi-pass case. + * We process the equivalent of one fully interleaved MCU row ("iMCU" row) + * per call, ie, v_samp_factor block rows for each component in the image. + * This amount of data is read from the source buffer, DCT'd and quantized, + * and saved into the virtual arrays. We also generate suitable dummy blocks + * as needed at the right and lower edges. (The dummy blocks are constructed + * in the virtual arrays, which have been padded appropriately.) This makes + * it possible for subsequent passes not to worry about real vs. dummy blocks. + * + * We must also emit the data to the entropy encoder. This is conveniently + * done by calling compress_output() after we've loaded the current strip + * of the virtual arrays. + * + * NB: input_buf contains a plane for each component in image. All + * components are DCT'd and loaded into the virtual arrays in this pass. + * However, it may be that only a subset of the components are emitted to + * the entropy encoder during this first pass; be careful about looking + * at the scan-dependent variables (MCU dimensions, etc). + */ + +METHODDEF(boolean) +compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + JDIMENSION blocks_across, MCUs_across, MCUindex; + int bi, ci, h_samp_factor, block_row, block_rows, ndummy; + JCOEF lastDC; + jpeg_component_info *compptr; + JBLOCKARRAY buffer; + JBLOCKROW thisblockrow, lastblockrow; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Align the virtual buffer for this component. */ + buffer = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[ci], + coef->iMCU_row_num * compptr->v_samp_factor, + (JDIMENSION) compptr->v_samp_factor, TRUE); + /* Count non-dummy DCT block rows in this iMCU row. */ + if (coef->iMCU_row_num < last_iMCU_row) + block_rows = compptr->v_samp_factor; + else { + /* NB: can't use last_row_height here, since may not be set! */ + block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); + if (block_rows == 0) block_rows = compptr->v_samp_factor; + } + blocks_across = compptr->width_in_blocks; + h_samp_factor = compptr->h_samp_factor; + /* Count number of dummy blocks to be added at the right margin. */ + ndummy = (int) (blocks_across % h_samp_factor); + if (ndummy > 0) + ndummy = h_samp_factor - ndummy; + /* Perform DCT for all non-dummy blocks in this iMCU row. Each call + * on forward_DCT processes a complete horizontal row of DCT blocks. + */ + for (block_row = 0; block_row < block_rows; block_row++) { + thisblockrow = buffer[block_row]; + (*cinfo->fdct->forward_DCT) (cinfo, compptr, + input_buf[ci], thisblockrow, + (JDIMENSION) (block_row * DCTSIZE), + (JDIMENSION) 0, blocks_across); + if (ndummy > 0) { + /* Create dummy blocks at the right edge of the image. */ + thisblockrow += blocks_across; /* => first dummy block */ + jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK)); + lastDC = thisblockrow[-1][0]; + for (bi = 0; bi < ndummy; bi++) { + thisblockrow[bi][0] = lastDC; + } + } + } + /* If at end of image, create dummy block rows as needed. + * The tricky part here is that within each MCU, we want the DC values + * of the dummy blocks to match the last real block's DC value. + * This squeezes a few more bytes out of the resulting file... + */ + if (coef->iMCU_row_num == last_iMCU_row) { + blocks_across += ndummy; /* include lower right corner */ + MCUs_across = blocks_across / h_samp_factor; + for (block_row = block_rows; block_row < compptr->v_samp_factor; + block_row++) { + thisblockrow = buffer[block_row]; + lastblockrow = buffer[block_row-1]; + jzero_far((void FAR *) thisblockrow, + (size_t) (blocks_across * SIZEOF(JBLOCK))); + for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) { + lastDC = lastblockrow[h_samp_factor-1][0]; + for (bi = 0; bi < h_samp_factor; bi++) { + thisblockrow[bi][0] = lastDC; + } + thisblockrow += h_samp_factor; /* advance to next MCU in row */ + lastblockrow += h_samp_factor; + } + } + } + } + /* NB: compress_output will increment iMCU_row_num if successful. + * A suspension return will result in redoing all the work above next time. + */ + + /* Emit data to the entropy encoder, sharing code with subsequent passes */ + return compress_output(cinfo, input_buf); +} + + +/* + * Process some data in subsequent passes of a multi-pass case. + * We process the equivalent of one fully interleaved MCU row ("iMCU" row) + * per call, ie, v_samp_factor block rows for each component in the scan. + * The data is obtained from the virtual arrays and fed to the entropy coder. + * Returns TRUE if the iMCU row is completed, FALSE if suspended. + * + * NB: input_buf is ignored; it is likely to be a NULL pointer. + */ + +METHODDEF(boolean) +compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + int blkn, ci, xindex, yindex, yoffset; + JDIMENSION start_col; + JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; + JBLOCKROW buffer_ptr; + jpeg_component_info *compptr; + + /* Align the virtual buffers for the components used in this scan. + * NB: during first pass, this is safe only because the buffers will + * already be aligned properly, so jmemmgr.c won't need to do any I/O. + */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + buffer[ci] = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], + coef->iMCU_row_num * compptr->v_samp_factor, + (JDIMENSION) compptr->v_samp_factor, FALSE); + } + + /* Loop to process one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row; + MCU_col_num++) { + /* Construct list of pointers to DCT blocks belonging to this MCU */ + blkn = 0; /* index of current DCT block within MCU */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + start_col = MCU_col_num * compptr->MCU_width; + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + buffer_ptr = buffer[ci][yindex+yoffset] + start_col; + for (xindex = 0; xindex < compptr->MCU_width; xindex++) { + coef->MCU_buffer[blkn++] = buffer_ptr++; + } + } + } + /* Try to write the MCU. */ + if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->mcu_ctr = MCU_col_num; + return FALSE; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->mcu_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + coef->iMCU_row_num++; + start_iMCU_row(cinfo); + return TRUE; +} + +#endif /* FULL_COEF_BUFFER_SUPPORTED */ + + +/* + * Initialize coefficient buffer controller. + */ + +GLOBAL(void) +jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer) +{ + my_coef_ptr coef; + + coef = (my_coef_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_coef_controller)); + cinfo->coef = (struct jpeg_c_coef_controller *) coef; + coef->pub.start_pass = start_pass_coef; + + /* Create the coefficient buffer. */ + if (need_full_buffer) { +#ifdef FULL_COEF_BUFFER_SUPPORTED + /* Allocate a full-image virtual array for each component, */ + /* padded to a multiple of samp_factor DCT blocks in each direction. */ + int ci; + jpeg_component_info *compptr; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, + (JDIMENSION) jround_up((long) compptr->width_in_blocks, + (long) compptr->h_samp_factor), + (JDIMENSION) jround_up((long) compptr->height_in_blocks, + (long) compptr->v_samp_factor), + (JDIMENSION) compptr->v_samp_factor); + } +#else + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); +#endif + } else { + /* We only need a single-MCU buffer. */ + JBLOCKROW buffer; + int i; + + buffer = (JBLOCKROW) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); + for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) { + coef->MCU_buffer[i] = buffer + i; + } + coef->whole_image[0] = NULL; /* flag for no virtual arrays */ + } +} diff --git a/TMessagesProj/jni/libjpeg/jccolor.c b/TMessagesProj/jni/libjpeg/jccolor.c new file mode 100755 index 000000000..57a76c36b --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jccolor.c @@ -0,0 +1,527 @@ +/* + * jccolor.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains input colorspace conversion routines. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + +// this enables unrolling null_convert's loop, and reading/write ints for speed +#define ENABLE_ANDROID_NULL_CONVERT + +/* Private subobject */ + +typedef struct { + struct jpeg_color_converter pub; /* public fields */ + + /* Private state for RGB->YCC conversion */ + INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */ +} my_color_converter; + +typedef my_color_converter * my_cconvert_ptr; + + +/**************** RGB -> YCbCr conversion: most common case **************/ + +/* + * YCbCr is defined per CCIR 601-1, except that Cb and Cr are + * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. + * The conversion equations to be implemented are therefore + * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B + * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE + * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE + * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) + * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2, + * rather than CENTERJSAMPLE, for Cb and Cr. This gave equal positive and + * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0) + * were not represented exactly. Now we sacrifice exact representation of + * maximum red and maximum blue in order to get exact grayscales. + * + * To avoid floating-point arithmetic, we represent the fractional constants + * as integers scaled up by 2^16 (about 4 digits precision); we have to divide + * the products by 2^16, with appropriate rounding, to get the correct answer. + * + * For even more speed, we avoid doing any multiplications in the inner loop + * by precalculating the constants times R,G,B for all possible values. + * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); + * for 12-bit samples it is still acceptable. It's not very reasonable for + * 16-bit samples, but if you want lossless storage you shouldn't be changing + * colorspace anyway. + * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included + * in the tables to save adding them separately in the inner loop. + */ + +#define SCALEBITS 16 /* speediest right-shift on some machines */ +#define CBCR_OFFSET ((INT32) CENTERJSAMPLE << SCALEBITS) +#define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) +#define FIX(x) ((INT32) ((x) * (1L< Y section */ +#define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */ +#define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */ +#define R_CB_OFF (3*(MAXJSAMPLE+1)) +#define G_CB_OFF (4*(MAXJSAMPLE+1)) +#define B_CB_OFF (5*(MAXJSAMPLE+1)) +#define R_CR_OFF B_CB_OFF /* B=>Cb, R=>Cr are the same */ +#define G_CR_OFF (6*(MAXJSAMPLE+1)) +#define B_CR_OFF (7*(MAXJSAMPLE+1)) +#define TABLE_SIZE (8*(MAXJSAMPLE+1)) + + +/* + * Initialize for RGB->YCC colorspace conversion. + */ + +METHODDEF(void) +rgb_ycc_start (j_compress_ptr cinfo) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + INT32 * rgb_ycc_tab; + INT32 i; + + /* Allocate and fill in the conversion tables. */ + cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (TABLE_SIZE * SIZEOF(INT32))); + + for (i = 0; i <= MAXJSAMPLE; i++) { + rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i; + rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i; + rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF; + rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i; + rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i; + /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr. + * This ensures that the maximum output will round to MAXJSAMPLE + * not MAXJSAMPLE+1, and thus that we don't have to range-limit. + */ + rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1; +/* B=>Cb and R=>Cr tables are the same + rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1; +*/ + rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i; + rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i; + } +} + + +/* + * Convert some rows of samples to the JPEG colorspace. + * + * Note that we change from the application's interleaved-pixel format + * to our internal noninterleaved, one-plane-per-component format. + * The input buffer is therefore three times as wide as the output buffer. + * + * A starting row offset is provided only for the output buffer. The caller + * can easily adjust the passed input_buf value to accommodate any row + * offset required on that side. + */ + +METHODDEF(void) +rgb_ycc_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int r, g, b; + register INT32 * ctab = cconvert->rgb_ycc_tab; + register JSAMPROW inptr; + register JSAMPROW outptr0, outptr1, outptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->image_width; + + while (--num_rows >= 0) { + inptr = *input_buf++; + outptr0 = output_buf[0][output_row]; + outptr1 = output_buf[1][output_row]; + outptr2 = output_buf[2][output_row]; + output_row++; + for (col = 0; col < num_cols; col++) { + r = GETJSAMPLE(inptr[RGB_RED]); + g = GETJSAMPLE(inptr[RGB_GREEN]); + b = GETJSAMPLE(inptr[RGB_BLUE]); + inptr += RGB_PIXELSIZE; + /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations + * must be too; we do not need an explicit range-limiting operation. + * Hence the value being shifted is never negative, and we don't + * need the general RIGHT_SHIFT macro. + */ + /* Y */ + outptr0[col] = (JSAMPLE) + ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) + >> SCALEBITS); + /* Cb */ + outptr1[col] = (JSAMPLE) + ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF]) + >> SCALEBITS); + /* Cr */ + outptr2[col] = (JSAMPLE) + ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF]) + >> SCALEBITS); + } + } +} + + +/**************** Cases other than RGB -> YCbCr **************/ + + +/* + * Convert some rows of samples to the JPEG colorspace. + * This version handles RGB->grayscale conversion, which is the same + * as the RGB->Y portion of RGB->YCbCr. + * We assume rgb_ycc_start has been called (we only use the Y tables). + */ + +METHODDEF(void) +rgb_gray_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int r, g, b; + register INT32 * ctab = cconvert->rgb_ycc_tab; + register JSAMPROW inptr; + register JSAMPROW outptr; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->image_width; + + while (--num_rows >= 0) { + inptr = *input_buf++; + outptr = output_buf[0][output_row]; + output_row++; + for (col = 0; col < num_cols; col++) { + r = GETJSAMPLE(inptr[RGB_RED]); + g = GETJSAMPLE(inptr[RGB_GREEN]); + b = GETJSAMPLE(inptr[RGB_BLUE]); + inptr += RGB_PIXELSIZE; + /* Y */ + outptr[col] = (JSAMPLE) + ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) + >> SCALEBITS); + } + } +} + + +/* + * Convert some rows of samples to the JPEG colorspace. + * This version handles Adobe-style CMYK->YCCK conversion, + * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same + * conversion as above, while passing K (black) unchanged. + * We assume rgb_ycc_start has been called. + */ + +METHODDEF(void) +cmyk_ycck_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int r, g, b; + register INT32 * ctab = cconvert->rgb_ycc_tab; + register JSAMPROW inptr; + register JSAMPROW outptr0, outptr1, outptr2, outptr3; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->image_width; + + while (--num_rows >= 0) { + inptr = *input_buf++; + outptr0 = output_buf[0][output_row]; + outptr1 = output_buf[1][output_row]; + outptr2 = output_buf[2][output_row]; + outptr3 = output_buf[3][output_row]; + output_row++; + for (col = 0; col < num_cols; col++) { + r = MAXJSAMPLE - GETJSAMPLE(inptr[0]); + g = MAXJSAMPLE - GETJSAMPLE(inptr[1]); + b = MAXJSAMPLE - GETJSAMPLE(inptr[2]); + /* K passes through as-is */ + outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */ + inptr += 4; + /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations + * must be too; we do not need an explicit range-limiting operation. + * Hence the value being shifted is never negative, and we don't + * need the general RIGHT_SHIFT macro. + */ + /* Y */ + outptr0[col] = (JSAMPLE) + ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) + >> SCALEBITS); + /* Cb */ + outptr1[col] = (JSAMPLE) + ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF]) + >> SCALEBITS); + /* Cr */ + outptr2[col] = (JSAMPLE) + ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF]) + >> SCALEBITS); + } + } +} + + +/* + * Convert some rows of samples to the JPEG colorspace. + * This version handles grayscale output with no conversion. + * The source can be either plain grayscale or YCbCr (since Y == gray). + */ + +METHODDEF(void) +grayscale_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ + register JSAMPROW inptr; + register JSAMPROW outptr; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->image_width; + int instride = cinfo->input_components; + + while (--num_rows >= 0) { + inptr = *input_buf++; + outptr = output_buf[0][output_row]; + output_row++; + for (col = 0; col < num_cols; col++) { + outptr[col] = inptr[0]; /* don't need GETJSAMPLE() here */ + inptr += instride; + } + } +} + +#ifdef ENABLE_ANDROID_NULL_CONVERT + +typedef unsigned long UINT32; + +#define B0(n) ((n) & 0xFF) +#define B1(n) (((n) >> 8) & 0xFF) +#define B2(n) (((n) >> 16) & 0xFF) +#define B3(n) ((n) >> 24) + +#define PACK(a, b, c, d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) + +static int ptr_is_quad(const void* p) +{ + return (((const char*)p - (const char*)0) & 3) == 0; +} + +static void copyquads(const UINT32 in[], UINT32 out0[], UINT32 out1[], UINT32 out2[], int col4) +{ + do { + UINT32 src0 = *in++; + UINT32 src1 = *in++; + UINT32 src2 = *in++; + // LEndian + *out0++ = PACK(B0(src0), B3(src0), B2(src1), B1(src2)); + *out1++ = PACK(B1(src0), B0(src1), B3(src1), B2(src2)); + *out2++ = PACK(B2(src0), B1(src1), B0(src2), B3(src2)); + } while (--col4 != 0); +} + +#endif + +/* + * Convert some rows of samples to the JPEG colorspace. + * This version handles multi-component colorspaces without conversion. + * We assume input_components == num_components. + */ + +METHODDEF(void) +null_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ + register JSAMPROW inptr; + register JSAMPROW outptr; + register JDIMENSION col; + register int ci; + int nc = cinfo->num_components; + JDIMENSION num_cols = cinfo->image_width; + +#ifdef ENABLE_ANDROID_NULL_CONVERT + if (1 == num_rows && 3 == nc && num_cols > 0) { + JSAMPROW inptr = *input_buf; + JSAMPROW outptr0 = output_buf[0][output_row]; + JSAMPROW outptr1 = output_buf[1][output_row]; + JSAMPROW outptr2 = output_buf[2][output_row]; + + int col = num_cols; + int col4 = col >> 2; + if (col4 > 0 && ptr_is_quad(inptr) && ptr_is_quad(outptr0) && + ptr_is_quad(outptr1) && ptr_is_quad(outptr2)) { + + const UINT32* in = (const UINT32*)inptr; + UINT32* out0 = (UINT32*)outptr0; + UINT32* out1 = (UINT32*)outptr1; + UINT32* out2 = (UINT32*)outptr2; + copyquads(in, out0, out1, out2, col4); + col &= 3; + if (0 == col) + return; + col4 <<= 2; + inptr += col4 * 3; /* we read this 3 times per in copyquads */ + outptr0 += col4; + outptr1 += col4; + outptr2 += col4; + /* fall through to while-loop */ + } + do { + *outptr0++ = *inptr++; + *outptr1++ = *inptr++; + *outptr2++ = *inptr++; + } while (--col != 0); + return; + } +SLOW: +#endif + while (--num_rows >= 0) { + /* It seems fastest to make a separate pass for each component. */ + for (ci = 0; ci < nc; ci++) { + inptr = *input_buf; + outptr = output_buf[ci][output_row]; + for (col = 0; col < num_cols; col++) { + outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */ + inptr += nc; + } + } + input_buf++; + output_row++; + } +} + + +/* + * Empty method for start_pass. + */ + +METHODDEF(void) +null_method (j_compress_ptr cinfo) +{ + /* no work needed */ +} + + +/* + * Module initialization routine for input colorspace conversion. + */ + +GLOBAL(void) +jinit_color_converter (j_compress_ptr cinfo) +{ + my_cconvert_ptr cconvert; + + cconvert = (my_cconvert_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_color_converter)); + cinfo->cconvert = (struct jpeg_color_converter *) cconvert; + /* set start_pass to null method until we find out differently */ + cconvert->pub.start_pass = null_method; + + /* Make sure input_components agrees with in_color_space */ + switch (cinfo->in_color_space) { + case JCS_GRAYSCALE: + if (cinfo->input_components != 1) + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + break; + + case JCS_RGB: +#if RGB_PIXELSIZE != 3 + if (cinfo->input_components != RGB_PIXELSIZE) + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + break; +#endif /* else share code with YCbCr */ + + case JCS_YCbCr: + if (cinfo->input_components != 3) + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + break; + + case JCS_CMYK: + case JCS_YCCK: + if (cinfo->input_components != 4) + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + break; + + default: /* JCS_UNKNOWN can be anything */ + if (cinfo->input_components < 1) + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + break; + } + + /* Check num_components, set conversion method based on requested space */ + switch (cinfo->jpeg_color_space) { + case JCS_GRAYSCALE: + if (cinfo->num_components != 1) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + if (cinfo->in_color_space == JCS_GRAYSCALE) + cconvert->pub.color_convert = grayscale_convert; + else if (cinfo->in_color_space == JCS_RGB) { + cconvert->pub.start_pass = rgb_ycc_start; + cconvert->pub.color_convert = rgb_gray_convert; + } else if (cinfo->in_color_space == JCS_YCbCr) + cconvert->pub.color_convert = grayscale_convert; + else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_RGB: + if (cinfo->num_components != 3) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3) + cconvert->pub.color_convert = null_convert; + else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_YCbCr: + if (cinfo->num_components != 3) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + if (cinfo->in_color_space == JCS_RGB) { + cconvert->pub.start_pass = rgb_ycc_start; + cconvert->pub.color_convert = rgb_ycc_convert; + } else if (cinfo->in_color_space == JCS_YCbCr) + cconvert->pub.color_convert = null_convert; + else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_CMYK: + if (cinfo->num_components != 4) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + if (cinfo->in_color_space == JCS_CMYK) + cconvert->pub.color_convert = null_convert; + else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_YCCK: + if (cinfo->num_components != 4) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + if (cinfo->in_color_space == JCS_CMYK) { + cconvert->pub.start_pass = rgb_ycc_start; + cconvert->pub.color_convert = cmyk_ycck_convert; + } else if (cinfo->in_color_space == JCS_YCCK) + cconvert->pub.color_convert = null_convert; + else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + default: /* allow null conversion of JCS_UNKNOWN */ + if (cinfo->jpeg_color_space != cinfo->in_color_space || + cinfo->num_components != cinfo->input_components) + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + cconvert->pub.color_convert = null_convert; + break; + } +} diff --git a/TMessagesProj/jni/libjpeg/jcdctmgr.c b/TMessagesProj/jni/libjpeg/jcdctmgr.c new file mode 100755 index 000000000..61fa79b9e --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcdctmgr.c @@ -0,0 +1,387 @@ +/* + * jcdctmgr.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the forward-DCT management logic. + * This code selects a particular DCT implementation to be used, + * and it performs related housekeeping chores including coefficient + * quantization. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + + +/* Private subobject for this module */ + +typedef struct { + struct jpeg_forward_dct pub; /* public fields */ + + /* Pointer to the DCT routine actually in use */ + forward_DCT_method_ptr do_dct; + + /* The actual post-DCT divisors --- not identical to the quant table + * entries, because of scaling (especially for an unnormalized DCT). + * Each table is given in normal array order. + */ + DCTELEM * divisors[NUM_QUANT_TBLS]; + +#ifdef DCT_FLOAT_SUPPORTED + /* Same as above for the floating-point case. */ + float_DCT_method_ptr do_float_dct; + FAST_FLOAT * float_divisors[NUM_QUANT_TBLS]; +#endif +} my_fdct_controller; + +typedef my_fdct_controller * my_fdct_ptr; + + +/* + * Initialize for a processing pass. + * Verify that all referenced Q-tables are present, and set up + * the divisor table for each one. + * In the current implementation, DCT of all components is done during + * the first pass, even if only some components will be output in the + * first scan. Hence all components should be examined here. + */ + +METHODDEF(void) +start_pass_fdctmgr (j_compress_ptr cinfo) +{ + my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; + int ci, qtblno, i; + jpeg_component_info *compptr; + JQUANT_TBL * qtbl; + DCTELEM * dtbl; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + qtblno = compptr->quant_tbl_no; + /* Make sure specified quantization table is present */ + if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || + cinfo->quant_tbl_ptrs[qtblno] == NULL) + ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); + qtbl = cinfo->quant_tbl_ptrs[qtblno]; + /* Compute divisors for this quant table */ + /* We may do this more than once for same table, but it's not a big deal */ + switch (cinfo->dct_method) { +#ifdef DCT_ISLOW_SUPPORTED + case JDCT_ISLOW: + /* For LL&M IDCT method, divisors are equal to raw quantization + * coefficients multiplied by 8 (to counteract scaling). + */ + if (fdct->divisors[qtblno] == NULL) { + fdct->divisors[qtblno] = (DCTELEM *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + DCTSIZE2 * SIZEOF(DCTELEM)); + } + dtbl = fdct->divisors[qtblno]; + for (i = 0; i < DCTSIZE2; i++) { + dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3; + } + break; +#endif +#ifdef DCT_IFAST_SUPPORTED + case JDCT_IFAST: + { + /* For AA&N IDCT method, divisors are equal to quantization + * coefficients scaled by scalefactor[row]*scalefactor[col], where + * scalefactor[0] = 1 + * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 + * We apply a further scale factor of 8. + */ +#define CONST_BITS 14 + static const INT16 aanscales[DCTSIZE2] = { + /* precomputed values scaled up by 14 bits */ + 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, + 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, + 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, + 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, + 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, + 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, + 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, + 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 + }; + SHIFT_TEMPS + + if (fdct->divisors[qtblno] == NULL) { + fdct->divisors[qtblno] = (DCTELEM *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + DCTSIZE2 * SIZEOF(DCTELEM)); + } + dtbl = fdct->divisors[qtblno]; + for (i = 0; i < DCTSIZE2; i++) { + dtbl[i] = (DCTELEM) + DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i], + (INT32) aanscales[i]), + CONST_BITS-3); + } + } + break; +#endif +#ifdef DCT_FLOAT_SUPPORTED + case JDCT_FLOAT: + { + /* For float AA&N IDCT method, divisors are equal to quantization + * coefficients scaled by scalefactor[row]*scalefactor[col], where + * scalefactor[0] = 1 + * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 + * We apply a further scale factor of 8. + * What's actually stored is 1/divisor so that the inner loop can + * use a multiplication rather than a division. + */ + FAST_FLOAT * fdtbl; + int row, col; + static const double aanscalefactor[DCTSIZE] = { + 1.0, 1.387039845, 1.306562965, 1.175875602, + 1.0, 0.785694958, 0.541196100, 0.275899379 + }; + + if (fdct->float_divisors[qtblno] == NULL) { + fdct->float_divisors[qtblno] = (FAST_FLOAT *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + DCTSIZE2 * SIZEOF(FAST_FLOAT)); + } + fdtbl = fdct->float_divisors[qtblno]; + i = 0; + for (row = 0; row < DCTSIZE; row++) { + for (col = 0; col < DCTSIZE; col++) { + fdtbl[i] = (FAST_FLOAT) + (1.0 / (((double) qtbl->quantval[i] * + aanscalefactor[row] * aanscalefactor[col] * 8.0))); + i++; + } + } + } + break; +#endif + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + break; + } + } +} + + +/* + * Perform forward DCT on one or more blocks of a component. + * + * The input samples are taken from the sample_data[] array starting at + * position start_row/start_col, and moving to the right for any additional + * blocks. The quantized coefficients are returned in coef_blocks[]. + */ + +METHODDEF(void) +forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY sample_data, JBLOCKROW coef_blocks, + JDIMENSION start_row, JDIMENSION start_col, + JDIMENSION num_blocks) +/* This version is used for integer DCT implementations. */ +{ + /* This routine is heavily used, so it's worth coding it tightly. */ + my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; + forward_DCT_method_ptr do_dct = fdct->do_dct; + DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no]; + DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */ + JDIMENSION bi; + + sample_data += start_row; /* fold in the vertical offset once */ + + for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) { + /* Load data into workspace, applying unsigned->signed conversion */ + { register DCTELEM *workspaceptr; + register JSAMPROW elemptr; + register int elemr; + + workspaceptr = workspace; + for (elemr = 0; elemr < DCTSIZE; elemr++) { + elemptr = sample_data[elemr] + start_col; +#if DCTSIZE == 8 /* unroll the inner loop */ + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; +#else + { register int elemc; + for (elemc = DCTSIZE; elemc > 0; elemc--) { + *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; + } + } +#endif + } + } + + /* Perform the DCT */ + (*do_dct) (workspace); + + /* Quantize/descale the coefficients, and store into coef_blocks[] */ + { register DCTELEM temp, qval; + register int i; + register JCOEFPTR output_ptr = coef_blocks[bi]; + + for (i = 0; i < DCTSIZE2; i++) { + qval = divisors[i]; + temp = workspace[i]; + /* Divide the coefficient value by qval, ensuring proper rounding. + * Since C does not specify the direction of rounding for negative + * quotients, we have to force the dividend positive for portability. + * + * In most files, at least half of the output values will be zero + * (at default quantization settings, more like three-quarters...) + * so we should ensure that this case is fast. On many machines, + * a comparison is enough cheaper than a divide to make a special test + * a win. Since both inputs will be nonnegative, we need only test + * for a < b to discover whether a/b is 0. + * If your machine's division is fast enough, define FAST_DIVIDE. + */ +#ifdef FAST_DIVIDE +#define DIVIDE_BY(a,b) a /= b +#else +#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0 +#endif + if (temp < 0) { + temp = -temp; + temp += qval>>1; /* for rounding */ + DIVIDE_BY(temp, qval); + temp = -temp; + } else { + temp += qval>>1; /* for rounding */ + DIVIDE_BY(temp, qval); + } + output_ptr[i] = (JCOEF) temp; + } + } + } +} + + +#ifdef DCT_FLOAT_SUPPORTED + +METHODDEF(void) +forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY sample_data, JBLOCKROW coef_blocks, + JDIMENSION start_row, JDIMENSION start_col, + JDIMENSION num_blocks) +/* This version is used for floating-point DCT implementations. */ +{ + /* This routine is heavily used, so it's worth coding it tightly. */ + my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; + float_DCT_method_ptr do_dct = fdct->do_float_dct; + FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no]; + FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */ + JDIMENSION bi; + + sample_data += start_row; /* fold in the vertical offset once */ + + for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) { + /* Load data into workspace, applying unsigned->signed conversion */ + { register FAST_FLOAT *workspaceptr; + register JSAMPROW elemptr; + register int elemr; + + workspaceptr = workspace; + for (elemr = 0; elemr < DCTSIZE; elemr++) { + elemptr = sample_data[elemr] + start_col; +#if DCTSIZE == 8 /* unroll the inner loop */ + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); +#else + { register int elemc; + for (elemc = DCTSIZE; elemc > 0; elemc--) { + *workspaceptr++ = (FAST_FLOAT) + (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); + } + } +#endif + } + } + + /* Perform the DCT */ + (*do_dct) (workspace); + + /* Quantize/descale the coefficients, and store into coef_blocks[] */ + { register FAST_FLOAT temp; + register int i; + register JCOEFPTR output_ptr = coef_blocks[bi]; + + for (i = 0; i < DCTSIZE2; i++) { + /* Apply the quantization and scaling factor */ + temp = workspace[i] * divisors[i]; + /* Round to nearest integer. + * Since C does not specify the direction of rounding for negative + * quotients, we have to force the dividend positive for portability. + * The maximum coefficient size is +-16K (for 12-bit data), so this + * code should work for either 16-bit or 32-bit ints. + */ + output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384); + } + } + } +} + +#endif /* DCT_FLOAT_SUPPORTED */ + + +/* + * Initialize FDCT manager. + */ + +GLOBAL(void) +jinit_forward_dct (j_compress_ptr cinfo) +{ + my_fdct_ptr fdct; + int i; + + fdct = (my_fdct_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_fdct_controller)); + cinfo->fdct = (struct jpeg_forward_dct *) fdct; + fdct->pub.start_pass = start_pass_fdctmgr; + + switch (cinfo->dct_method) { +#ifdef DCT_ISLOW_SUPPORTED + case JDCT_ISLOW: + fdct->pub.forward_DCT = forward_DCT; + fdct->do_dct = jpeg_fdct_islow; + break; +#endif +#ifdef DCT_IFAST_SUPPORTED + case JDCT_IFAST: + fdct->pub.forward_DCT = forward_DCT; + fdct->do_dct = jpeg_fdct_ifast; + break; +#endif +#ifdef DCT_FLOAT_SUPPORTED + case JDCT_FLOAT: + fdct->pub.forward_DCT = forward_DCT_float; + fdct->do_float_dct = jpeg_fdct_float; + break; +#endif + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + break; + } + + /* Mark divisor tables unallocated */ + for (i = 0; i < NUM_QUANT_TBLS; i++) { + fdct->divisors[i] = NULL; +#ifdef DCT_FLOAT_SUPPORTED + fdct->float_divisors[i] = NULL; +#endif + } +} diff --git a/TMessagesProj/jni/libjpeg/jchuff.c b/TMessagesProj/jni/libjpeg/jchuff.c new file mode 100755 index 000000000..f23525054 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jchuff.c @@ -0,0 +1,909 @@ +/* + * jchuff.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains Huffman entropy encoding routines. + * + * Much of the complexity here has to do with supporting output suspension. + * If the data destination module demands suspension, we want to be able to + * back up to the start of the current MCU. To do this, we copy state + * variables into local working storage, and update them back to the + * permanent JPEG objects only upon successful completion of an MCU. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jchuff.h" /* Declarations shared with jcphuff.c */ + + +/* Expanded entropy encoder object for Huffman encoding. + * + * The savable_state subrecord contains fields that change within an MCU, + * but must not be updated permanently until we complete the MCU. + */ + +typedef struct { + INT32 put_buffer; /* current bit-accumulation buffer */ + int put_bits; /* # of bits now in it */ + int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ +} savable_state; + +/* This macro is to work around compilers with missing or broken + * structure assignment. You'll need to fix this code if you have + * such a compiler and you change MAX_COMPS_IN_SCAN. + */ + +#ifndef NO_STRUCT_ASSIGN +#define ASSIGN_STATE(dest,src) ((dest) = (src)) +#else +#if MAX_COMPS_IN_SCAN == 4 +#define ASSIGN_STATE(dest,src) \ + ((dest).put_buffer = (src).put_buffer, \ + (dest).put_bits = (src).put_bits, \ + (dest).last_dc_val[0] = (src).last_dc_val[0], \ + (dest).last_dc_val[1] = (src).last_dc_val[1], \ + (dest).last_dc_val[2] = (src).last_dc_val[2], \ + (dest).last_dc_val[3] = (src).last_dc_val[3]) +#endif +#endif + + +typedef struct { + struct jpeg_entropy_encoder pub; /* public fields */ + + savable_state saved; /* Bit buffer & DC state at start of MCU */ + + /* These fields are NOT loaded into local working state. */ + unsigned int restarts_to_go; /* MCUs left in this restart interval */ + int next_restart_num; /* next restart number to write (0-7) */ + + /* Pointers to derived tables (these workspaces have image lifespan) */ + c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]; + c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]; + +#ifdef ENTROPY_OPT_SUPPORTED /* Statistics tables for optimization */ + long * dc_count_ptrs[NUM_HUFF_TBLS]; + long * ac_count_ptrs[NUM_HUFF_TBLS]; +#endif +} huff_entropy_encoder; + +typedef huff_entropy_encoder * huff_entropy_ptr; + +/* Working state while writing an MCU. + * This struct contains all the fields that are needed by subroutines. + */ + +typedef struct { + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + savable_state cur; /* Current bit buffer & DC state */ + j_compress_ptr cinfo; /* dump_buffer needs access to this */ +} working_state; + + +/* Forward declarations */ +METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo)); +#ifdef ENTROPY_OPT_SUPPORTED +METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo)); +#endif + + +/* + * Initialize for a Huffman-compressed scan. + * If gather_statistics is TRUE, we do not output anything during the scan, + * just count the Huffman symbols used and generate Huffman code tables. + */ + +METHODDEF(void) +start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int ci, dctbl, actbl; + jpeg_component_info * compptr; + + if (gather_statistics) { +#ifdef ENTROPY_OPT_SUPPORTED + entropy->pub.encode_mcu = encode_mcu_gather; + entropy->pub.finish_pass = finish_pass_gather; +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + entropy->pub.encode_mcu = encode_mcu_huff; + entropy->pub.finish_pass = finish_pass_huff; + } + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + dctbl = compptr->dc_tbl_no; + actbl = compptr->ac_tbl_no; + if (gather_statistics) { +#ifdef ENTROPY_OPT_SUPPORTED + /* Check for invalid table indexes */ + /* (make_c_derived_tbl does this in the other path) */ + if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl); + if (actbl < 0 || actbl >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl); + /* Allocate and zero the statistics tables */ + /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ + if (entropy->dc_count_ptrs[dctbl] == NULL) + entropy->dc_count_ptrs[dctbl] = (long *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + 257 * SIZEOF(long)); + MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long)); + if (entropy->ac_count_ptrs[actbl] == NULL) + entropy->ac_count_ptrs[actbl] = (long *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + 257 * SIZEOF(long)); + MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long)); +#endif + } else { + /* Compute derived values for Huffman tables */ + /* We may do this more than once for a table, but it's not expensive */ + jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl, + & entropy->dc_derived_tbls[dctbl]); + jpeg_make_c_derived_tbl(cinfo, FALSE, actbl, + & entropy->ac_derived_tbls[actbl]); + } + /* Initialize DC predictions to 0 */ + entropy->saved.last_dc_val[ci] = 0; + } + + /* Initialize bit buffer to empty */ + entropy->saved.put_buffer = 0; + entropy->saved.put_bits = 0; + + /* Initialize restart stuff */ + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num = 0; +} + + +/* + * Compute the derived values for a Huffman table. + * This routine also performs some validation checks on the table. + * + * Note this is also used by jcphuff.c. + */ + +GLOBAL(void) +jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno, + c_derived_tbl ** pdtbl) +{ + JHUFF_TBL *htbl; + c_derived_tbl *dtbl; + int p, i, l, lastp, si, maxsymbol; + char huffsize[257]; + unsigned int huffcode[257]; + unsigned int code; + + /* Note that huffsize[] and huffcode[] are filled in code-length order, + * paralleling the order of the symbols themselves in htbl->huffval[]. + */ + + /* Find the input Huffman table */ + if (tblno < 0 || tblno >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); + htbl = + isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno]; + if (htbl == NULL) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); + + /* Allocate a workspace if we haven't already done so. */ + if (*pdtbl == NULL) + *pdtbl = (c_derived_tbl *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(c_derived_tbl)); + dtbl = *pdtbl; + + /* Figure C.1: make table of Huffman code length for each symbol */ + + p = 0; + for (l = 1; l <= 16; l++) { + i = (int) htbl->bits[l]; + if (i < 0 || p + i > 256) /* protect against table overrun */ + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + while (i--) + huffsize[p++] = (char) l; + } + huffsize[p] = 0; + lastp = p; + + /* Figure C.2: generate the codes themselves */ + /* We also validate that the counts represent a legal Huffman code tree. */ + + code = 0; + si = huffsize[0]; + p = 0; + while (huffsize[p]) { + while (((int) huffsize[p]) == si) { + huffcode[p++] = code; + code++; + } + /* code is now 1 more than the last code used for codelength si; but + * it must still fit in si bits, since no code is allowed to be all ones. + */ + if (((INT32) code) >= (((INT32) 1) << si)) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + code <<= 1; + si++; + } + + /* Figure C.3: generate encoding tables */ + /* These are code and size indexed by symbol value */ + + /* Set all codeless symbols to have code length 0; + * this lets us detect duplicate VAL entries here, and later + * allows emit_bits to detect any attempt to emit such symbols. + */ + MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi)); + + /* This is also a convenient place to check for out-of-range + * and duplicated VAL entries. We allow 0..255 for AC symbols + * but only 0..15 for DC. (We could constrain them further + * based on data depth and mode, but this seems enough.) + */ + maxsymbol = isDC ? 15 : 255; + + for (p = 0; p < lastp; p++) { + i = htbl->huffval[p]; + if (i < 0 || i > maxsymbol || dtbl->ehufsi[i]) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + dtbl->ehufco[i] = huffcode[p]; + dtbl->ehufsi[i] = huffsize[p]; + } +} + + +/* Outputting bytes to the file */ + +/* Emit a byte, taking 'action' if must suspend. */ +#define emit_byte(state,val,action) \ + { *(state)->next_output_byte++ = (JOCTET) (val); \ + if (--(state)->free_in_buffer == 0) \ + if (! dump_buffer(state)) \ + { action; } } + + +LOCAL(boolean) +dump_buffer (working_state * state) +/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */ +{ + struct jpeg_destination_mgr * dest = state->cinfo->dest; + + if (! (*dest->empty_output_buffer) (state->cinfo)) + return FALSE; + /* After a successful buffer dump, must reset buffer pointers */ + state->next_output_byte = dest->next_output_byte; + state->free_in_buffer = dest->free_in_buffer; + return TRUE; +} + + +/* Outputting bits to the file */ + +/* Only the right 24 bits of put_buffer are used; the valid bits are + * left-justified in this part. At most 16 bits can be passed to emit_bits + * in one call, and we never retain more than 7 bits in put_buffer + * between calls, so 24 bits are sufficient. + */ + +INLINE +LOCAL(boolean) +emit_bits (working_state * state, unsigned int code, int size) +/* Emit some bits; return TRUE if successful, FALSE if must suspend */ +{ + /* This routine is heavily used, so it's worth coding tightly. */ + register INT32 put_buffer = (INT32) code; + register int put_bits = state->cur.put_bits; + + /* if size is 0, caller used an invalid Huffman table entry */ + if (size == 0) + ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE); + + put_buffer &= (((INT32) 1)<cur.put_buffer; /* and merge with old buffer contents */ + + while (put_bits >= 8) { + int c = (int) ((put_buffer >> 16) & 0xFF); + + emit_byte(state, c, return FALSE); + if (c == 0xFF) { /* need to stuff a zero byte? */ + emit_byte(state, 0, return FALSE); + } + put_buffer <<= 8; + put_bits -= 8; + } + + state->cur.put_buffer = put_buffer; /* update state variables */ + state->cur.put_bits = put_bits; + + return TRUE; +} + + +LOCAL(boolean) +flush_bits (working_state * state) +{ + if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */ + return FALSE; + state->cur.put_buffer = 0; /* and reset bit-buffer to empty */ + state->cur.put_bits = 0; + return TRUE; +} + + +/* Encode a single block's worth of coefficients */ + +LOCAL(boolean) +encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val, + c_derived_tbl *dctbl, c_derived_tbl *actbl) +{ + register int temp, temp2; + register int nbits; + register int k, r, i; + + /* Encode the DC coefficient difference per section F.1.2.1 */ + + temp = temp2 = block[0] - last_dc_val; + + if (temp < 0) { + temp = -temp; /* temp is abs value of input */ + /* For a negative input, want temp2 = bitwise complement of abs(input) */ + /* This code assumes we are on a two's complement machine */ + temp2--; + } + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 0; + while (temp) { + nbits++; + temp >>= 1; + } + /* Check for out-of-range coefficient values. + * Since we're encoding a difference, the range limit is twice as much. + */ + if (nbits > MAX_COEF_BITS+1) + ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); + + /* Emit the Huffman-coded symbol for the number of bits */ + if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits])) + return FALSE; + + /* Emit that number of bits of the value, if positive, */ + /* or the complement of its magnitude, if negative. */ + if (nbits) /* emit_bits rejects calls with size 0 */ + if (! emit_bits(state, (unsigned int) temp2, nbits)) + return FALSE; + + /* Encode the AC coefficients per section F.1.2.2 */ + + r = 0; /* r = run length of zeros */ + + for (k = 1; k < DCTSIZE2; k++) { + if ((temp = block[jpeg_natural_order[k]]) == 0) { + r++; + } else { + /* if run length > 15, must emit special run-length-16 codes (0xF0) */ + while (r > 15) { + if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0])) + return FALSE; + r -= 16; + } + + temp2 = temp; + if (temp < 0) { + temp = -temp; /* temp is abs value of input */ + /* This code assumes we are on a two's complement machine */ + temp2--; + } + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 1; /* there must be at least one 1 bit */ + while ((temp >>= 1)) + nbits++; + /* Check for out-of-range coefficient values */ + if (nbits > MAX_COEF_BITS) + ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); + + /* Emit Huffman symbol for run length / number of bits */ + i = (r << 4) + nbits; + if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i])) + return FALSE; + + /* Emit that number of bits of the value, if positive, */ + /* or the complement of its magnitude, if negative. */ + if (! emit_bits(state, (unsigned int) temp2, nbits)) + return FALSE; + + r = 0; + } + } + + /* If the last coef(s) were zero, emit an end-of-block code */ + if (r > 0) + if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0])) + return FALSE; + + return TRUE; +} + + +/* + * Emit a restart marker & resynchronize predictions. + */ + +LOCAL(boolean) +emit_restart (working_state * state, int restart_num) +{ + int ci; + + if (! flush_bits(state)) + return FALSE; + + emit_byte(state, 0xFF, return FALSE); + emit_byte(state, JPEG_RST0 + restart_num, return FALSE); + + /* Re-initialize DC predictions to 0 */ + for (ci = 0; ci < state->cinfo->comps_in_scan; ci++) + state->cur.last_dc_val[ci] = 0; + + /* The restart counter is not updated until we successfully write the MCU. */ + + return TRUE; +} + + +/* + * Encode and output one MCU's worth of Huffman-compressed coefficients. + */ + +METHODDEF(boolean) +encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + working_state state; + int blkn, ci; + jpeg_component_info * compptr; + + /* Load up working state */ + state.next_output_byte = cinfo->dest->next_output_byte; + state.free_in_buffer = cinfo->dest->free_in_buffer; + ASSIGN_STATE(state.cur, entropy->saved); + state.cinfo = cinfo; + + /* Emit restart marker if needed */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! emit_restart(&state, entropy->next_restart_num)) + return FALSE; + } + + /* Encode the MCU data blocks */ + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + ci = cinfo->MCU_membership[blkn]; + compptr = cinfo->cur_comp_info[ci]; + if (! encode_one_block(&state, + MCU_data[blkn][0], state.cur.last_dc_val[ci], + entropy->dc_derived_tbls[compptr->dc_tbl_no], + entropy->ac_derived_tbls[compptr->ac_tbl_no])) + return FALSE; + /* Update last_dc_val */ + state.cur.last_dc_val[ci] = MCU_data[blkn][0][0]; + } + + /* Completed MCU, so update state */ + cinfo->dest->next_output_byte = state.next_output_byte; + cinfo->dest->free_in_buffer = state.free_in_buffer; + ASSIGN_STATE(entropy->saved, state.cur); + + /* Update restart-interval state too */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num++; + entropy->next_restart_num &= 7; + } + entropy->restarts_to_go--; + } + + return TRUE; +} + + +/* + * Finish up at the end of a Huffman-compressed scan. + */ + +METHODDEF(void) +finish_pass_huff (j_compress_ptr cinfo) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + working_state state; + + /* Load up working state ... flush_bits needs it */ + state.next_output_byte = cinfo->dest->next_output_byte; + state.free_in_buffer = cinfo->dest->free_in_buffer; + ASSIGN_STATE(state.cur, entropy->saved); + state.cinfo = cinfo; + + /* Flush out the last data */ + if (! flush_bits(&state)) + ERREXIT(cinfo, JERR_CANT_SUSPEND); + + /* Update state */ + cinfo->dest->next_output_byte = state.next_output_byte; + cinfo->dest->free_in_buffer = state.free_in_buffer; + ASSIGN_STATE(entropy->saved, state.cur); +} + + +/* + * Huffman coding optimization. + * + * We first scan the supplied data and count the number of uses of each symbol + * that is to be Huffman-coded. (This process MUST agree with the code above.) + * Then we build a Huffman coding tree for the observed counts. + * Symbols which are not needed at all for the particular image are not + * assigned any code, which saves space in the DHT marker as well as in + * the compressed data. + */ + +#ifdef ENTROPY_OPT_SUPPORTED + + +/* Process a single block's worth of coefficients */ + +LOCAL(void) +htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val, + long dc_counts[], long ac_counts[]) +{ + register int temp; + register int nbits; + register int k, r; + + /* Encode the DC coefficient difference per section F.1.2.1 */ + + temp = block[0] - last_dc_val; + if (temp < 0) + temp = -temp; + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 0; + while (temp) { + nbits++; + temp >>= 1; + } + /* Check for out-of-range coefficient values. + * Since we're encoding a difference, the range limit is twice as much. + */ + if (nbits > MAX_COEF_BITS+1) + ERREXIT(cinfo, JERR_BAD_DCT_COEF); + + /* Count the Huffman symbol for the number of bits */ + dc_counts[nbits]++; + + /* Encode the AC coefficients per section F.1.2.2 */ + + r = 0; /* r = run length of zeros */ + + for (k = 1; k < DCTSIZE2; k++) { + if ((temp = block[jpeg_natural_order[k]]) == 0) { + r++; + } else { + /* if run length > 15, must emit special run-length-16 codes (0xF0) */ + while (r > 15) { + ac_counts[0xF0]++; + r -= 16; + } + + /* Find the number of bits needed for the magnitude of the coefficient */ + if (temp < 0) + temp = -temp; + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 1; /* there must be at least one 1 bit */ + while ((temp >>= 1)) + nbits++; + /* Check for out-of-range coefficient values */ + if (nbits > MAX_COEF_BITS) + ERREXIT(cinfo, JERR_BAD_DCT_COEF); + + /* Count Huffman symbol for run length / number of bits */ + ac_counts[(r << 4) + nbits]++; + + r = 0; + } + } + + /* If the last coef(s) were zero, emit an end-of-block code */ + if (r > 0) + ac_counts[0]++; +} + + +/* + * Trial-encode one MCU's worth of Huffman-compressed coefficients. + * No data is actually output, so no suspension return is possible. + */ + +METHODDEF(boolean) +encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int blkn, ci; + jpeg_component_info * compptr; + + /* Take care of restart intervals if needed */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + /* Re-initialize DC predictions to 0 */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) + entropy->saved.last_dc_val[ci] = 0; + /* Update restart state */ + entropy->restarts_to_go = cinfo->restart_interval; + } + entropy->restarts_to_go--; + } + + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + ci = cinfo->MCU_membership[blkn]; + compptr = cinfo->cur_comp_info[ci]; + htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci], + entropy->dc_count_ptrs[compptr->dc_tbl_no], + entropy->ac_count_ptrs[compptr->ac_tbl_no]); + entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0]; + } + + return TRUE; +} + + +/* + * Generate the best Huffman code table for the given counts, fill htbl. + * Note this is also used by jcphuff.c. + * + * The JPEG standard requires that no symbol be assigned a codeword of all + * one bits (so that padding bits added at the end of a compressed segment + * can't look like a valid code). Because of the canonical ordering of + * codewords, this just means that there must be an unused slot in the + * longest codeword length category. Section K.2 of the JPEG spec suggests + * reserving such a slot by pretending that symbol 256 is a valid symbol + * with count 1. In theory that's not optimal; giving it count zero but + * including it in the symbol set anyway should give a better Huffman code. + * But the theoretically better code actually seems to come out worse in + * practice, because it produces more all-ones bytes (which incur stuffed + * zero bytes in the final file). In any case the difference is tiny. + * + * The JPEG standard requires Huffman codes to be no more than 16 bits long. + * If some symbols have a very small but nonzero probability, the Huffman tree + * must be adjusted to meet the code length restriction. We currently use + * the adjustment method suggested in JPEG section K.2. This method is *not* + * optimal; it may not choose the best possible limited-length code. But + * typically only very-low-frequency symbols will be given less-than-optimal + * lengths, so the code is almost optimal. Experimental comparisons against + * an optimal limited-length-code algorithm indicate that the difference is + * microscopic --- usually less than a hundredth of a percent of total size. + * So the extra complexity of an optimal algorithm doesn't seem worthwhile. + */ + +GLOBAL(void) +jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]) +{ +#define MAX_CLEN 32 /* assumed maximum initial code length */ + UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */ + int codesize[257]; /* codesize[k] = code length of symbol k */ + int others[257]; /* next symbol in current branch of tree */ + int c1, c2; + int p, i, j; + long v; + + /* This algorithm is explained in section K.2 of the JPEG standard */ + + MEMZERO(bits, SIZEOF(bits)); + MEMZERO(codesize, SIZEOF(codesize)); + for (i = 0; i < 257; i++) + others[i] = -1; /* init links to empty */ + + freq[256] = 1; /* make sure 256 has a nonzero count */ + /* Including the pseudo-symbol 256 in the Huffman procedure guarantees + * that no real symbol is given code-value of all ones, because 256 + * will be placed last in the largest codeword category. + */ + + /* Huffman's basic algorithm to assign optimal code lengths to symbols */ + + for (;;) { + /* Find the smallest nonzero frequency, set c1 = its symbol */ + /* In case of ties, take the larger symbol number */ + c1 = -1; + v = 1000000000L; + for (i = 0; i <= 256; i++) { + if (freq[i] && freq[i] <= v) { + v = freq[i]; + c1 = i; + } + } + + /* Find the next smallest nonzero frequency, set c2 = its symbol */ + /* In case of ties, take the larger symbol number */ + c2 = -1; + v = 1000000000L; + for (i = 0; i <= 256; i++) { + if (freq[i] && freq[i] <= v && i != c1) { + v = freq[i]; + c2 = i; + } + } + + /* Done if we've merged everything into one frequency */ + if (c2 < 0) + break; + + /* Else merge the two counts/trees */ + freq[c1] += freq[c2]; + freq[c2] = 0; + + /* Increment the codesize of everything in c1's tree branch */ + codesize[c1]++; + while (others[c1] >= 0) { + c1 = others[c1]; + codesize[c1]++; + } + + others[c1] = c2; /* chain c2 onto c1's tree branch */ + + /* Increment the codesize of everything in c2's tree branch */ + codesize[c2]++; + while (others[c2] >= 0) { + c2 = others[c2]; + codesize[c2]++; + } + } + + /* Now count the number of symbols of each code length */ + for (i = 0; i <= 256; i++) { + if (codesize[i]) { + /* The JPEG standard seems to think that this can't happen, */ + /* but I'm paranoid... */ + if (codesize[i] > MAX_CLEN) + ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW); + + bits[codesize[i]]++; + } + } + + /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure + * Huffman procedure assigned any such lengths, we must adjust the coding. + * Here is what the JPEG spec says about how this next bit works: + * Since symbols are paired for the longest Huffman code, the symbols are + * removed from this length category two at a time. The prefix for the pair + * (which is one bit shorter) is allocated to one of the pair; then, + * skipping the BITS entry for that prefix length, a code word from the next + * shortest nonzero BITS entry is converted into a prefix for two code words + * one bit longer. + */ + + for (i = MAX_CLEN; i > 16; i--) { + while (bits[i] > 0) { + j = i - 2; /* find length of new prefix to be used */ + while (bits[j] == 0) + j--; + + bits[i] -= 2; /* remove two symbols */ + bits[i-1]++; /* one goes in this length */ + bits[j+1] += 2; /* two new symbols in this length */ + bits[j]--; /* symbol of this length is now a prefix */ + } + } + + /* Remove the count for the pseudo-symbol 256 from the largest codelength */ + while (bits[i] == 0) /* find largest codelength still in use */ + i--; + bits[i]--; + + /* Return final symbol counts (only for lengths 0..16) */ + MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits)); + + /* Return a list of the symbols sorted by code length */ + /* It's not real clear to me why we don't need to consider the codelength + * changes made above, but the JPEG spec seems to think this works. + */ + p = 0; + for (i = 1; i <= MAX_CLEN; i++) { + for (j = 0; j <= 255; j++) { + if (codesize[j] == i) { + htbl->huffval[p] = (UINT8) j; + p++; + } + } + } + + /* Set sent_table FALSE so updated table will be written to JPEG file. */ + htbl->sent_table = FALSE; +} + + +/* + * Finish up a statistics-gathering pass and create the new Huffman tables. + */ + +METHODDEF(void) +finish_pass_gather (j_compress_ptr cinfo) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int ci, dctbl, actbl; + jpeg_component_info * compptr; + JHUFF_TBL **htblptr; + boolean did_dc[NUM_HUFF_TBLS]; + boolean did_ac[NUM_HUFF_TBLS]; + + /* It's important not to apply jpeg_gen_optimal_table more than once + * per table, because it clobbers the input frequency counts! + */ + MEMZERO(did_dc, SIZEOF(did_dc)); + MEMZERO(did_ac, SIZEOF(did_ac)); + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + dctbl = compptr->dc_tbl_no; + actbl = compptr->ac_tbl_no; + if (! did_dc[dctbl]) { + htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl]; + if (*htblptr == NULL) + *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); + jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]); + did_dc[dctbl] = TRUE; + } + if (! did_ac[actbl]) { + htblptr = & cinfo->ac_huff_tbl_ptrs[actbl]; + if (*htblptr == NULL) + *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); + jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]); + did_ac[actbl] = TRUE; + } + } +} + + +#endif /* ENTROPY_OPT_SUPPORTED */ + + +/* + * Module initialization routine for Huffman entropy encoding. + */ + +GLOBAL(void) +jinit_huff_encoder (j_compress_ptr cinfo) +{ + huff_entropy_ptr entropy; + int i; + + entropy = (huff_entropy_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(huff_entropy_encoder)); + cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; + entropy->pub.start_pass = start_pass_huff; + + /* Mark tables unallocated */ + for (i = 0; i < NUM_HUFF_TBLS; i++) { + entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; +#ifdef ENTROPY_OPT_SUPPORTED + entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL; +#endif + } +} diff --git a/TMessagesProj/jni/libjpeg/jchuff.h b/TMessagesProj/jni/libjpeg/jchuff.h new file mode 100755 index 000000000..a9599fc1e --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jchuff.h @@ -0,0 +1,47 @@ +/* + * jchuff.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains declarations for Huffman entropy encoding routines + * that are shared between the sequential encoder (jchuff.c) and the + * progressive encoder (jcphuff.c). No other modules need to see these. + */ + +/* The legal range of a DCT coefficient is + * -1024 .. +1023 for 8-bit data; + * -16384 .. +16383 for 12-bit data. + * Hence the magnitude should always fit in 10 or 14 bits respectively. + */ + +#if BITS_IN_JSAMPLE == 8 +#define MAX_COEF_BITS 10 +#else +#define MAX_COEF_BITS 14 +#endif + +/* Derived data constructed for each Huffman table */ + +typedef struct { + unsigned int ehufco[256]; /* code for each symbol */ + char ehufsi[256]; /* length of code for each symbol */ + /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */ +} c_derived_tbl; + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_make_c_derived_tbl jMkCDerived +#define jpeg_gen_optimal_table jGenOptTbl +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + +/* Expand a Huffman table definition into the derived format */ +EXTERN(void) jpeg_make_c_derived_tbl + JPP((j_compress_ptr cinfo, boolean isDC, int tblno, + c_derived_tbl ** pdtbl)); + +/* Generate an optimal table definition given the specified counts */ +EXTERN(void) jpeg_gen_optimal_table + JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])); diff --git a/TMessagesProj/jni/libjpeg/jcinit.c b/TMessagesProj/jni/libjpeg/jcinit.c new file mode 100755 index 000000000..5efffe331 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcinit.c @@ -0,0 +1,72 @@ +/* + * jcinit.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains initialization logic for the JPEG compressor. + * This routine is in charge of selecting the modules to be executed and + * making an initialization call to each one. + * + * Logically, this code belongs in jcmaster.c. It's split out because + * linking this routine implies linking the entire compression library. + * For a transcoding-only application, we want to be able to use jcmaster.c + * without linking in the whole library. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Master selection of compression modules. + * This is done once at the start of processing an image. We determine + * which modules will be used and give them appropriate initialization calls. + */ + +GLOBAL(void) +jinit_compress_master (j_compress_ptr cinfo) +{ + /* Initialize master control (includes parameter checking/processing) */ + jinit_c_master_control(cinfo, FALSE /* full compression */); + + /* Preprocessing */ + if (! cinfo->raw_data_in) { + jinit_color_converter(cinfo); + jinit_downsampler(cinfo); + jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */); + } + /* Forward DCT */ + jinit_forward_dct(cinfo); + /* Entropy encoding: either Huffman or arithmetic coding. */ + if (cinfo->arith_code) { + ERREXIT(cinfo, JERR_ARITH_NOTIMPL); + } else { + if (cinfo->progressive_mode) { +#ifdef C_PROGRESSIVE_SUPPORTED + jinit_phuff_encoder(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else + jinit_huff_encoder(cinfo); + } + + /* Need a full-image coefficient buffer in any multi-pass mode. */ + jinit_c_coef_controller(cinfo, + (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding)); + jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */); + + jinit_marker_writer(cinfo); + + /* We can now tell the memory manager to allocate virtual arrays. */ + (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); + + /* Write the datastream header (SOI) immediately. + * Frame and scan headers are postponed till later. + * This lets application insert special markers after the SOI. + */ + (*cinfo->marker->write_file_header) (cinfo); +} diff --git a/TMessagesProj/jni/libjpeg/jcmainct.c b/TMessagesProj/jni/libjpeg/jcmainct.c new file mode 100755 index 000000000..e0279a7e0 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcmainct.c @@ -0,0 +1,293 @@ +/* + * jcmainct.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the main buffer controller for compression. + * The main buffer lies between the pre-processor and the JPEG + * compressor proper; it holds downsampled data in the JPEG colorspace. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Note: currently, there is no operating mode in which a full-image buffer + * is needed at this step. If there were, that mode could not be used with + * "raw data" input, since this module is bypassed in that case. However, + * we've left the code here for possible use in special applications. + */ +#undef FULL_MAIN_BUFFER_SUPPORTED + + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_c_main_controller pub; /* public fields */ + + JDIMENSION cur_iMCU_row; /* number of current iMCU row */ + JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */ + boolean suspended; /* remember if we suspended output */ + J_BUF_MODE pass_mode; /* current operating mode */ + + /* If using just a strip buffer, this points to the entire set of buffers + * (we allocate one for each component). In the full-image case, this + * points to the currently accessible strips of the virtual arrays. + */ + JSAMPARRAY buffer[MAX_COMPONENTS]; + +#ifdef FULL_MAIN_BUFFER_SUPPORTED + /* If using full-image storage, this array holds pointers to virtual-array + * control blocks for each component. Unused if not full-image storage. + */ + jvirt_sarray_ptr whole_image[MAX_COMPONENTS]; +#endif +} my_main_controller; + +typedef my_main_controller * my_main_ptr; + + +/* Forward declarations */ +METHODDEF(void) process_data_simple_main + JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, + JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); +#ifdef FULL_MAIN_BUFFER_SUPPORTED +METHODDEF(void) process_data_buffer_main + JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, + JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); +#endif + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + + /* Do nothing in raw-data mode. */ + if (cinfo->raw_data_in) + return; + + main->cur_iMCU_row = 0; /* initialize counters */ + main->rowgroup_ctr = 0; + main->suspended = FALSE; + main->pass_mode = pass_mode; /* save mode for use by process_data */ + + switch (pass_mode) { + case JBUF_PASS_THRU: +#ifdef FULL_MAIN_BUFFER_SUPPORTED + if (main->whole_image[0] != NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); +#endif + main->pub.process_data = process_data_simple_main; + break; +#ifdef FULL_MAIN_BUFFER_SUPPORTED + case JBUF_SAVE_SOURCE: + case JBUF_CRANK_DEST: + case JBUF_SAVE_AND_PASS: + if (main->whole_image[0] == NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + main->pub.process_data = process_data_buffer_main; + break; +#endif + default: + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + break; + } +} + + +/* + * Process some data. + * This routine handles the simple pass-through mode, + * where we have only a strip buffer. + */ + +METHODDEF(void) +process_data_simple_main (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + + while (main->cur_iMCU_row < cinfo->total_iMCU_rows) { + /* Read input data if we haven't filled the main buffer yet */ + if (main->rowgroup_ctr < DCTSIZE) + (*cinfo->prep->pre_process_data) (cinfo, + input_buf, in_row_ctr, in_rows_avail, + main->buffer, &main->rowgroup_ctr, + (JDIMENSION) DCTSIZE); + + /* If we don't have a full iMCU row buffered, return to application for + * more data. Note that preprocessor will always pad to fill the iMCU row + * at the bottom of the image. + */ + if (main->rowgroup_ctr != DCTSIZE) + return; + + /* Send the completed row to the compressor */ + if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) { + /* If compressor did not consume the whole row, then we must need to + * suspend processing and return to the application. In this situation + * we pretend we didn't yet consume the last input row; otherwise, if + * it happened to be the last row of the image, the application would + * think we were done. + */ + if (! main->suspended) { + (*in_row_ctr)--; + main->suspended = TRUE; + } + return; + } + /* We did finish the row. Undo our little suspension hack if a previous + * call suspended; then mark the main buffer empty. + */ + if (main->suspended) { + (*in_row_ctr)++; + main->suspended = FALSE; + } + main->rowgroup_ctr = 0; + main->cur_iMCU_row++; + } +} + + +#ifdef FULL_MAIN_BUFFER_SUPPORTED + +/* + * Process some data. + * This routine handles all of the modes that use a full-size buffer. + */ + +METHODDEF(void) +process_data_buffer_main (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + int ci; + jpeg_component_info *compptr; + boolean writing = (main->pass_mode != JBUF_CRANK_DEST); + + while (main->cur_iMCU_row < cinfo->total_iMCU_rows) { + /* Realign the virtual buffers if at the start of an iMCU row. */ + if (main->rowgroup_ctr == 0) { + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + main->buffer[ci] = (*cinfo->mem->access_virt_sarray) + ((j_common_ptr) cinfo, main->whole_image[ci], + main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE), + (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing); + } + /* In a read pass, pretend we just read some source data. */ + if (! writing) { + *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE; + main->rowgroup_ctr = DCTSIZE; + } + } + + /* If a write pass, read input data until the current iMCU row is full. */ + /* Note: preprocessor will pad if necessary to fill the last iMCU row. */ + if (writing) { + (*cinfo->prep->pre_process_data) (cinfo, + input_buf, in_row_ctr, in_rows_avail, + main->buffer, &main->rowgroup_ctr, + (JDIMENSION) DCTSIZE); + /* Return to application if we need more data to fill the iMCU row. */ + if (main->rowgroup_ctr < DCTSIZE) + return; + } + + /* Emit data, unless this is a sink-only pass. */ + if (main->pass_mode != JBUF_SAVE_SOURCE) { + if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) { + /* If compressor did not consume the whole row, then we must need to + * suspend processing and return to the application. In this situation + * we pretend we didn't yet consume the last input row; otherwise, if + * it happened to be the last row of the image, the application would + * think we were done. + */ + if (! main->suspended) { + (*in_row_ctr)--; + main->suspended = TRUE; + } + return; + } + /* We did finish the row. Undo our little suspension hack if a previous + * call suspended; then mark the main buffer empty. + */ + if (main->suspended) { + (*in_row_ctr)++; + main->suspended = FALSE; + } + } + + /* If get here, we are done with this iMCU row. Mark buffer empty. */ + main->rowgroup_ctr = 0; + main->cur_iMCU_row++; + } +} + +#endif /* FULL_MAIN_BUFFER_SUPPORTED */ + + +/* + * Initialize main buffer controller. + */ + +GLOBAL(void) +jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer) +{ + my_main_ptr main; + int ci; + jpeg_component_info *compptr; + + main = (my_main_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_main_controller)); + cinfo->main = (struct jpeg_c_main_controller *) main; + main->pub.start_pass = start_pass_main; + + /* We don't need to create a buffer in raw-data mode. */ + if (cinfo->raw_data_in) + return; + + /* Create the buffer. It holds downsampled data, so each component + * may be of a different size. + */ + if (need_full_buffer) { +#ifdef FULL_MAIN_BUFFER_SUPPORTED + /* Allocate a full-image virtual array for each component */ + /* Note we pad the bottom to a multiple of the iMCU height */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + main->whole_image[ci] = (*cinfo->mem->request_virt_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, + compptr->width_in_blocks * DCTSIZE, + (JDIMENSION) jround_up((long) compptr->height_in_blocks, + (long) compptr->v_samp_factor) * DCTSIZE, + (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); + } +#else + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); +#endif + } else { +#ifdef FULL_MAIN_BUFFER_SUPPORTED + main->whole_image[0] = NULL; /* flag for no virtual arrays */ +#endif + /* Allocate a strip buffer for each component */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + main->buffer[ci] = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + compptr->width_in_blocks * DCTSIZE, + (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); + } + } +} diff --git a/TMessagesProj/jni/libjpeg/jcmarker.c b/TMessagesProj/jni/libjpeg/jcmarker.c new file mode 100755 index 000000000..3d1e6c6d5 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcmarker.c @@ -0,0 +1,664 @@ +/* + * jcmarker.c + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains routines to write JPEG datastream markers. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +typedef enum { /* JPEG marker codes */ + M_SOF0 = 0xc0, + M_SOF1 = 0xc1, + M_SOF2 = 0xc2, + M_SOF3 = 0xc3, + + M_SOF5 = 0xc5, + M_SOF6 = 0xc6, + M_SOF7 = 0xc7, + + M_JPG = 0xc8, + M_SOF9 = 0xc9, + M_SOF10 = 0xca, + M_SOF11 = 0xcb, + + M_SOF13 = 0xcd, + M_SOF14 = 0xce, + M_SOF15 = 0xcf, + + M_DHT = 0xc4, + + M_DAC = 0xcc, + + M_RST0 = 0xd0, + M_RST1 = 0xd1, + M_RST2 = 0xd2, + M_RST3 = 0xd3, + M_RST4 = 0xd4, + M_RST5 = 0xd5, + M_RST6 = 0xd6, + M_RST7 = 0xd7, + + M_SOI = 0xd8, + M_EOI = 0xd9, + M_SOS = 0xda, + M_DQT = 0xdb, + M_DNL = 0xdc, + M_DRI = 0xdd, + M_DHP = 0xde, + M_EXP = 0xdf, + + M_APP0 = 0xe0, + M_APP1 = 0xe1, + M_APP2 = 0xe2, + M_APP3 = 0xe3, + M_APP4 = 0xe4, + M_APP5 = 0xe5, + M_APP6 = 0xe6, + M_APP7 = 0xe7, + M_APP8 = 0xe8, + M_APP9 = 0xe9, + M_APP10 = 0xea, + M_APP11 = 0xeb, + M_APP12 = 0xec, + M_APP13 = 0xed, + M_APP14 = 0xee, + M_APP15 = 0xef, + + M_JPG0 = 0xf0, + M_JPG13 = 0xfd, + M_COM = 0xfe, + + M_TEM = 0x01, + + M_ERROR = 0x100 +} JPEG_MARKER; + + +/* Private state */ + +typedef struct { + struct jpeg_marker_writer pub; /* public fields */ + + unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */ +} my_marker_writer; + +typedef my_marker_writer * my_marker_ptr; + + +/* + * Basic output routines. + * + * Note that we do not support suspension while writing a marker. + * Therefore, an application using suspension must ensure that there is + * enough buffer space for the initial markers (typ. 600-700 bytes) before + * calling jpeg_start_compress, and enough space to write the trailing EOI + * (a few bytes) before calling jpeg_finish_compress. Multipass compression + * modes are not supported at all with suspension, so those two are the only + * points where markers will be written. + */ + +LOCAL(void) +emit_byte (j_compress_ptr cinfo, int val) +/* Emit a byte */ +{ + struct jpeg_destination_mgr * dest = cinfo->dest; + + *(dest->next_output_byte)++ = (JOCTET) val; + if (--dest->free_in_buffer == 0) { + if (! (*dest->empty_output_buffer) (cinfo)) + ERREXIT(cinfo, JERR_CANT_SUSPEND); + } +} + + +LOCAL(void) +emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark) +/* Emit a marker code */ +{ + emit_byte(cinfo, 0xFF); + emit_byte(cinfo, (int) mark); +} + + +LOCAL(void) +emit_2bytes (j_compress_ptr cinfo, int value) +/* Emit a 2-byte integer; these are always MSB first in JPEG files */ +{ + emit_byte(cinfo, (value >> 8) & 0xFF); + emit_byte(cinfo, value & 0xFF); +} + + +/* + * Routines to write specific marker types. + */ + +LOCAL(int) +emit_dqt (j_compress_ptr cinfo, int index) +/* Emit a DQT marker */ +/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */ +{ + JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index]; + int prec; + int i; + + if (qtbl == NULL) + ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index); + + prec = 0; + for (i = 0; i < DCTSIZE2; i++) { + if (qtbl->quantval[i] > 255) + prec = 1; + } + + if (! qtbl->sent_table) { + emit_marker(cinfo, M_DQT); + + emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2); + + emit_byte(cinfo, index + (prec<<4)); + + for (i = 0; i < DCTSIZE2; i++) { + /* The table entries must be emitted in zigzag order. */ + unsigned int qval = qtbl->quantval[jpeg_natural_order[i]]; + if (prec) + emit_byte(cinfo, (int) (qval >> 8)); + emit_byte(cinfo, (int) (qval & 0xFF)); + } + + qtbl->sent_table = TRUE; + } + + return prec; +} + + +LOCAL(void) +emit_dht (j_compress_ptr cinfo, int index, boolean is_ac) +/* Emit a DHT marker */ +{ + JHUFF_TBL * htbl; + int length, i; + + if (is_ac) { + htbl = cinfo->ac_huff_tbl_ptrs[index]; + index += 0x10; /* output index has AC bit set */ + } else { + htbl = cinfo->dc_huff_tbl_ptrs[index]; + } + + if (htbl == NULL) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index); + + if (! htbl->sent_table) { + emit_marker(cinfo, M_DHT); + + length = 0; + for (i = 1; i <= 16; i++) + length += htbl->bits[i]; + + emit_2bytes(cinfo, length + 2 + 1 + 16); + emit_byte(cinfo, index); + + for (i = 1; i <= 16; i++) + emit_byte(cinfo, htbl->bits[i]); + + for (i = 0; i < length; i++) + emit_byte(cinfo, htbl->huffval[i]); + + htbl->sent_table = TRUE; + } +} + + +LOCAL(void) +emit_dac (j_compress_ptr cinfo) +/* Emit a DAC marker */ +/* Since the useful info is so small, we want to emit all the tables in */ +/* one DAC marker. Therefore this routine does its own scan of the table. */ +{ +#ifdef C_ARITH_CODING_SUPPORTED + char dc_in_use[NUM_ARITH_TBLS]; + char ac_in_use[NUM_ARITH_TBLS]; + int length, i; + jpeg_component_info *compptr; + + for (i = 0; i < NUM_ARITH_TBLS; i++) + dc_in_use[i] = ac_in_use[i] = 0; + + for (i = 0; i < cinfo->comps_in_scan; i++) { + compptr = cinfo->cur_comp_info[i]; + dc_in_use[compptr->dc_tbl_no] = 1; + ac_in_use[compptr->ac_tbl_no] = 1; + } + + length = 0; + for (i = 0; i < NUM_ARITH_TBLS; i++) + length += dc_in_use[i] + ac_in_use[i]; + + emit_marker(cinfo, M_DAC); + + emit_2bytes(cinfo, length*2 + 2); + + for (i = 0; i < NUM_ARITH_TBLS; i++) { + if (dc_in_use[i]) { + emit_byte(cinfo, i); + emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4)); + } + if (ac_in_use[i]) { + emit_byte(cinfo, i + 0x10); + emit_byte(cinfo, cinfo->arith_ac_K[i]); + } + } +#endif /* C_ARITH_CODING_SUPPORTED */ +} + + +LOCAL(void) +emit_dri (j_compress_ptr cinfo) +/* Emit a DRI marker */ +{ + emit_marker(cinfo, M_DRI); + + emit_2bytes(cinfo, 4); /* fixed length */ + + emit_2bytes(cinfo, (int) cinfo->restart_interval); +} + + +LOCAL(void) +emit_sof (j_compress_ptr cinfo, JPEG_MARKER code) +/* Emit a SOF marker */ +{ + int ci; + jpeg_component_info *compptr; + + emit_marker(cinfo, code); + + emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */ + + /* Make sure image isn't bigger than SOF field can handle */ + if ((long) cinfo->image_height > 65535L || + (long) cinfo->image_width > 65535L) + ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535); + + emit_byte(cinfo, cinfo->data_precision); + emit_2bytes(cinfo, (int) cinfo->image_height); + emit_2bytes(cinfo, (int) cinfo->image_width); + + emit_byte(cinfo, cinfo->num_components); + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + emit_byte(cinfo, compptr->component_id); + emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor); + emit_byte(cinfo, compptr->quant_tbl_no); + } +} + + +LOCAL(void) +emit_sos (j_compress_ptr cinfo) +/* Emit a SOS marker */ +{ + int i, td, ta; + jpeg_component_info *compptr; + + emit_marker(cinfo, M_SOS); + + emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */ + + emit_byte(cinfo, cinfo->comps_in_scan); + + for (i = 0; i < cinfo->comps_in_scan; i++) { + compptr = cinfo->cur_comp_info[i]; + emit_byte(cinfo, compptr->component_id); + td = compptr->dc_tbl_no; + ta = compptr->ac_tbl_no; + if (cinfo->progressive_mode) { + /* Progressive mode: only DC or only AC tables are used in one scan; + * furthermore, Huffman coding of DC refinement uses no table at all. + * We emit 0 for unused field(s); this is recommended by the P&M text + * but does not seem to be specified in the standard. + */ + if (cinfo->Ss == 0) { + ta = 0; /* DC scan */ + if (cinfo->Ah != 0 && !cinfo->arith_code) + td = 0; /* no DC table either */ + } else { + td = 0; /* AC scan */ + } + } + emit_byte(cinfo, (td << 4) + ta); + } + + emit_byte(cinfo, cinfo->Ss); + emit_byte(cinfo, cinfo->Se); + emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al); +} + + +LOCAL(void) +emit_jfif_app0 (j_compress_ptr cinfo) +/* Emit a JFIF-compliant APP0 marker */ +{ + /* + * Length of APP0 block (2 bytes) + * Block ID (4 bytes - ASCII "JFIF") + * Zero byte (1 byte to terminate the ID string) + * Version Major, Minor (2 bytes - major first) + * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm) + * Xdpu (2 bytes - dots per unit horizontal) + * Ydpu (2 bytes - dots per unit vertical) + * Thumbnail X size (1 byte) + * Thumbnail Y size (1 byte) + */ + + emit_marker(cinfo, M_APP0); + + emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */ + + emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */ + emit_byte(cinfo, 0x46); + emit_byte(cinfo, 0x49); + emit_byte(cinfo, 0x46); + emit_byte(cinfo, 0); + emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */ + emit_byte(cinfo, cinfo->JFIF_minor_version); + emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */ + emit_2bytes(cinfo, (int) cinfo->X_density); + emit_2bytes(cinfo, (int) cinfo->Y_density); + emit_byte(cinfo, 0); /* No thumbnail image */ + emit_byte(cinfo, 0); +} + + +LOCAL(void) +emit_adobe_app14 (j_compress_ptr cinfo) +/* Emit an Adobe APP14 marker */ +{ + /* + * Length of APP14 block (2 bytes) + * Block ID (5 bytes - ASCII "Adobe") + * Version Number (2 bytes - currently 100) + * Flags0 (2 bytes - currently 0) + * Flags1 (2 bytes - currently 0) + * Color transform (1 byte) + * + * Although Adobe TN 5116 mentions Version = 101, all the Adobe files + * now in circulation seem to use Version = 100, so that's what we write. + * + * We write the color transform byte as 1 if the JPEG color space is + * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with + * whether the encoder performed a transformation, which is pretty useless. + */ + + emit_marker(cinfo, M_APP14); + + emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */ + + emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */ + emit_byte(cinfo, 0x64); + emit_byte(cinfo, 0x6F); + emit_byte(cinfo, 0x62); + emit_byte(cinfo, 0x65); + emit_2bytes(cinfo, 100); /* Version */ + emit_2bytes(cinfo, 0); /* Flags0 */ + emit_2bytes(cinfo, 0); /* Flags1 */ + switch (cinfo->jpeg_color_space) { + case JCS_YCbCr: + emit_byte(cinfo, 1); /* Color transform = 1 */ + break; + case JCS_YCCK: + emit_byte(cinfo, 2); /* Color transform = 2 */ + break; + default: + emit_byte(cinfo, 0); /* Color transform = 0 */ + break; + } +} + + +/* + * These routines allow writing an arbitrary marker with parameters. + * The only intended use is to emit COM or APPn markers after calling + * write_file_header and before calling write_frame_header. + * Other uses are not guaranteed to produce desirable results. + * Counting the parameter bytes properly is the caller's responsibility. + */ + +METHODDEF(void) +write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen) +/* Emit an arbitrary marker header */ +{ + if (datalen > (unsigned int) 65533) /* safety check */ + ERREXIT(cinfo, JERR_BAD_LENGTH); + + emit_marker(cinfo, (JPEG_MARKER) marker); + + emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */ +} + +METHODDEF(void) +write_marker_byte (j_compress_ptr cinfo, int val) +/* Emit one byte of marker parameters following write_marker_header */ +{ + emit_byte(cinfo, val); +} + + +/* + * Write datastream header. + * This consists of an SOI and optional APPn markers. + * We recommend use of the JFIF marker, but not the Adobe marker, + * when using YCbCr or grayscale data. The JFIF marker should NOT + * be used for any other JPEG colorspace. The Adobe marker is helpful + * to distinguish RGB, CMYK, and YCCK colorspaces. + * Note that an application can write additional header markers after + * jpeg_start_compress returns. + */ + +METHODDEF(void) +write_file_header (j_compress_ptr cinfo) +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + + emit_marker(cinfo, M_SOI); /* first the SOI */ + + /* SOI is defined to reset restart interval to 0 */ + marker->last_restart_interval = 0; + + if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */ + emit_jfif_app0(cinfo); + if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */ + emit_adobe_app14(cinfo); +} + + +/* + * Write frame header. + * This consists of DQT and SOFn markers. + * Note that we do not emit the SOF until we have emitted the DQT(s). + * This avoids compatibility problems with incorrect implementations that + * try to error-check the quant table numbers as soon as they see the SOF. + */ + +METHODDEF(void) +write_frame_header (j_compress_ptr cinfo) +{ + int ci, prec; + boolean is_baseline; + jpeg_component_info *compptr; + + /* Emit DQT for each quantization table. + * Note that emit_dqt() suppresses any duplicate tables. + */ + prec = 0; + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + prec += emit_dqt(cinfo, compptr->quant_tbl_no); + } + /* now prec is nonzero iff there are any 16-bit quant tables. */ + + /* Check for a non-baseline specification. + * Note we assume that Huffman table numbers won't be changed later. + */ + if (cinfo->arith_code || cinfo->progressive_mode || + cinfo->data_precision != 8) { + is_baseline = FALSE; + } else { + is_baseline = TRUE; + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1) + is_baseline = FALSE; + } + if (prec && is_baseline) { + is_baseline = FALSE; + /* If it's baseline except for quantizer size, warn the user */ + TRACEMS(cinfo, 0, JTRC_16BIT_TABLES); + } + } + + /* Emit the proper SOF marker */ + if (cinfo->arith_code) { + emit_sof(cinfo, M_SOF9); /* SOF code for arithmetic coding */ + } else { + if (cinfo->progressive_mode) + emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */ + else if (is_baseline) + emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */ + else + emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */ + } +} + + +/* + * Write scan header. + * This consists of DHT or DAC markers, optional DRI, and SOS. + * Compressed data will be written following the SOS. + */ + +METHODDEF(void) +write_scan_header (j_compress_ptr cinfo) +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + int i; + jpeg_component_info *compptr; + + if (cinfo->arith_code) { + /* Emit arith conditioning info. We may have some duplication + * if the file has multiple scans, but it's so small it's hardly + * worth worrying about. + */ + emit_dac(cinfo); + } else { + /* Emit Huffman tables. + * Note that emit_dht() suppresses any duplicate tables. + */ + for (i = 0; i < cinfo->comps_in_scan; i++) { + compptr = cinfo->cur_comp_info[i]; + if (cinfo->progressive_mode) { + /* Progressive mode: only DC or only AC tables are used in one scan */ + if (cinfo->Ss == 0) { + if (cinfo->Ah == 0) /* DC needs no table for refinement scan */ + emit_dht(cinfo, compptr->dc_tbl_no, FALSE); + } else { + emit_dht(cinfo, compptr->ac_tbl_no, TRUE); + } + } else { + /* Sequential mode: need both DC and AC tables */ + emit_dht(cinfo, compptr->dc_tbl_no, FALSE); + emit_dht(cinfo, compptr->ac_tbl_no, TRUE); + } + } + } + + /* Emit DRI if required --- note that DRI value could change for each scan. + * We avoid wasting space with unnecessary DRIs, however. + */ + if (cinfo->restart_interval != marker->last_restart_interval) { + emit_dri(cinfo); + marker->last_restart_interval = cinfo->restart_interval; + } + + emit_sos(cinfo); +} + + +/* + * Write datastream trailer. + */ + +METHODDEF(void) +write_file_trailer (j_compress_ptr cinfo) +{ + emit_marker(cinfo, M_EOI); +} + + +/* + * Write an abbreviated table-specification datastream. + * This consists of SOI, DQT and DHT tables, and EOI. + * Any table that is defined and not marked sent_table = TRUE will be + * emitted. Note that all tables will be marked sent_table = TRUE at exit. + */ + +METHODDEF(void) +write_tables_only (j_compress_ptr cinfo) +{ + int i; + + emit_marker(cinfo, M_SOI); + + for (i = 0; i < NUM_QUANT_TBLS; i++) { + if (cinfo->quant_tbl_ptrs[i] != NULL) + (void) emit_dqt(cinfo, i); + } + + if (! cinfo->arith_code) { + for (i = 0; i < NUM_HUFF_TBLS; i++) { + if (cinfo->dc_huff_tbl_ptrs[i] != NULL) + emit_dht(cinfo, i, FALSE); + if (cinfo->ac_huff_tbl_ptrs[i] != NULL) + emit_dht(cinfo, i, TRUE); + } + } + + emit_marker(cinfo, M_EOI); +} + + +/* + * Initialize the marker writer module. + */ + +GLOBAL(void) +jinit_marker_writer (j_compress_ptr cinfo) +{ + my_marker_ptr marker; + + /* Create the subobject */ + marker = (my_marker_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_marker_writer)); + cinfo->marker = (struct jpeg_marker_writer *) marker; + /* Initialize method pointers */ + marker->pub.write_file_header = write_file_header; + marker->pub.write_frame_header = write_frame_header; + marker->pub.write_scan_header = write_scan_header; + marker->pub.write_file_trailer = write_file_trailer; + marker->pub.write_tables_only = write_tables_only; + marker->pub.write_marker_header = write_marker_header; + marker->pub.write_marker_byte = write_marker_byte; + /* Initialize private state */ + marker->last_restart_interval = 0; +} diff --git a/TMessagesProj/jni/libjpeg/jcmaster.c b/TMessagesProj/jni/libjpeg/jcmaster.c new file mode 100755 index 000000000..aab4020b8 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcmaster.c @@ -0,0 +1,590 @@ +/* + * jcmaster.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains master control logic for the JPEG compressor. + * These routines are concerned with parameter validation, initial setup, + * and inter-pass control (determining the number of passes and the work + * to be done in each pass). + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Private state */ + +typedef enum { + main_pass, /* input data, also do first output step */ + huff_opt_pass, /* Huffman code optimization pass */ + output_pass /* data output pass */ +} c_pass_type; + +typedef struct { + struct jpeg_comp_master pub; /* public fields */ + + c_pass_type pass_type; /* the type of the current pass */ + + int pass_number; /* # of passes completed */ + int total_passes; /* total # of passes needed */ + + int scan_number; /* current index in scan_info[] */ +} my_comp_master; + +typedef my_comp_master * my_master_ptr; + + +/* + * Support routines that do various essential calculations. + */ + +LOCAL(void) +initial_setup (j_compress_ptr cinfo) +/* Do computations that are needed before master selection phase */ +{ + int ci; + jpeg_component_info *compptr; + long samplesperrow; + JDIMENSION jd_samplesperrow; + + /* Sanity check on image dimensions */ + if (cinfo->image_height <= 0 || cinfo->image_width <= 0 + || cinfo->num_components <= 0 || cinfo->input_components <= 0) + ERREXIT(cinfo, JERR_EMPTY_IMAGE); + + /* Make sure image isn't bigger than I can handle */ + if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || + (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) + ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); + + /* Width of an input scanline must be representable as JDIMENSION. */ + samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components; + jd_samplesperrow = (JDIMENSION) samplesperrow; + if ((long) jd_samplesperrow != samplesperrow) + ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); + + /* For now, precision must match compiled-in value... */ + if (cinfo->data_precision != BITS_IN_JSAMPLE) + ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); + + /* Check that number of components won't exceed internal array sizes */ + if (cinfo->num_components > MAX_COMPONENTS) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, + MAX_COMPONENTS); + + /* Compute maximum sampling factors; check factor validity */ + cinfo->max_h_samp_factor = 1; + cinfo->max_v_samp_factor = 1; + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || + compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) + ERREXIT(cinfo, JERR_BAD_SAMPLING); + cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, + compptr->h_samp_factor); + cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, + compptr->v_samp_factor); + } + + /* Compute dimensions of components */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Fill in the correct component_index value; don't rely on application */ + compptr->component_index = ci; + /* For compression, we never do DCT scaling. */ + compptr->DCT_scaled_size = DCTSIZE; + /* Size in DCT blocks */ + compptr->width_in_blocks = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, + (long) (cinfo->max_h_samp_factor * DCTSIZE)); + compptr->height_in_blocks = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, + (long) (cinfo->max_v_samp_factor * DCTSIZE)); + /* Size in samples */ + compptr->downsampled_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, + (long) cinfo->max_h_samp_factor); + compptr->downsampled_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, + (long) cinfo->max_v_samp_factor); + /* Mark component needed (this flag isn't actually used for compression) */ + compptr->component_needed = TRUE; + } + + /* Compute number of fully interleaved MCU rows (number of times that + * main controller will call coefficient controller). + */ + cinfo->total_iMCU_rows = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, + (long) (cinfo->max_v_samp_factor*DCTSIZE)); +} + + +#ifdef C_MULTISCAN_FILES_SUPPORTED + +LOCAL(void) +validate_script (j_compress_ptr cinfo) +/* Verify that the scan script in cinfo->scan_info[] is valid; also + * determine whether it uses progressive JPEG, and set cinfo->progressive_mode. + */ +{ + const jpeg_scan_info * scanptr; + int scanno, ncomps, ci, coefi, thisi; + int Ss, Se, Ah, Al; + boolean component_sent[MAX_COMPONENTS]; +#ifdef C_PROGRESSIVE_SUPPORTED + int * last_bitpos_ptr; + int last_bitpos[MAX_COMPONENTS][DCTSIZE2]; + /* -1 until that coefficient has been seen; then last Al for it */ +#endif + + if (cinfo->num_scans <= 0) + ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0); + + /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1; + * for progressive JPEG, no scan can have this. + */ + scanptr = cinfo->scan_info; + if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) { +#ifdef C_PROGRESSIVE_SUPPORTED + cinfo->progressive_mode = TRUE; + last_bitpos_ptr = & last_bitpos[0][0]; + for (ci = 0; ci < cinfo->num_components; ci++) + for (coefi = 0; coefi < DCTSIZE2; coefi++) + *last_bitpos_ptr++ = -1; +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + cinfo->progressive_mode = FALSE; + for (ci = 0; ci < cinfo->num_components; ci++) + component_sent[ci] = FALSE; + } + + for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) { + /* Validate component indexes */ + ncomps = scanptr->comps_in_scan; + if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN); + for (ci = 0; ci < ncomps; ci++) { + thisi = scanptr->component_index[ci]; + if (thisi < 0 || thisi >= cinfo->num_components) + ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); + /* Components must appear in SOF order within each scan */ + if (ci > 0 && thisi <= scanptr->component_index[ci-1]) + ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); + } + /* Validate progression parameters */ + Ss = scanptr->Ss; + Se = scanptr->Se; + Ah = scanptr->Ah; + Al = scanptr->Al; + if (cinfo->progressive_mode) { +#ifdef C_PROGRESSIVE_SUPPORTED + /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that + * seems wrong: the upper bound ought to depend on data precision. + * Perhaps they really meant 0..N+1 for N-bit precision. + * Here we allow 0..10 for 8-bit data; Al larger than 10 results in + * out-of-range reconstructed DC values during the first DC scan, + * which might cause problems for some decoders. + */ +#if BITS_IN_JSAMPLE == 8 +#define MAX_AH_AL 10 +#else +#define MAX_AH_AL 13 +#endif + if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 || + Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL) + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + if (Ss == 0) { + if (Se != 0) /* DC and AC together not OK */ + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + } else { + if (ncomps != 1) /* AC scans must be for only one component */ + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + } + for (ci = 0; ci < ncomps; ci++) { + last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0]; + if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */ + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + for (coefi = Ss; coefi <= Se; coefi++) { + if (last_bitpos_ptr[coefi] < 0) { + /* first scan of this coefficient */ + if (Ah != 0) + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + } else { + /* not first scan */ + if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1) + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + } + last_bitpos_ptr[coefi] = Al; + } + } +#endif + } else { + /* For sequential JPEG, all progression parameters must be these: */ + if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0) + ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); + /* Make sure components are not sent twice */ + for (ci = 0; ci < ncomps; ci++) { + thisi = scanptr->component_index[ci]; + if (component_sent[thisi]) + ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); + component_sent[thisi] = TRUE; + } + } + } + + /* Now verify that everything got sent. */ + if (cinfo->progressive_mode) { +#ifdef C_PROGRESSIVE_SUPPORTED + /* For progressive mode, we only check that at least some DC data + * got sent for each component; the spec does not require that all bits + * of all coefficients be transmitted. Would it be wiser to enforce + * transmission of all coefficient bits?? + */ + for (ci = 0; ci < cinfo->num_components; ci++) { + if (last_bitpos[ci][0] < 0) + ERREXIT(cinfo, JERR_MISSING_DATA); + } +#endif + } else { + for (ci = 0; ci < cinfo->num_components; ci++) { + if (! component_sent[ci]) + ERREXIT(cinfo, JERR_MISSING_DATA); + } + } +} + +#endif /* C_MULTISCAN_FILES_SUPPORTED */ + + +LOCAL(void) +select_scan_parameters (j_compress_ptr cinfo) +/* Set up the scan parameters for the current scan */ +{ + int ci; + +#ifdef C_MULTISCAN_FILES_SUPPORTED + if (cinfo->scan_info != NULL) { + /* Prepare for current scan --- the script is already validated */ + my_master_ptr master = (my_master_ptr) cinfo->master; + const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number; + + cinfo->comps_in_scan = scanptr->comps_in_scan; + for (ci = 0; ci < scanptr->comps_in_scan; ci++) { + cinfo->cur_comp_info[ci] = + &cinfo->comp_info[scanptr->component_index[ci]]; + } + cinfo->Ss = scanptr->Ss; + cinfo->Se = scanptr->Se; + cinfo->Ah = scanptr->Ah; + cinfo->Al = scanptr->Al; + } + else +#endif + { + /* Prepare for single sequential-JPEG scan containing all components */ + if (cinfo->num_components > MAX_COMPS_IN_SCAN) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, + MAX_COMPS_IN_SCAN); + cinfo->comps_in_scan = cinfo->num_components; + for (ci = 0; ci < cinfo->num_components; ci++) { + cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci]; + } + cinfo->Ss = 0; + cinfo->Se = DCTSIZE2-1; + cinfo->Ah = 0; + cinfo->Al = 0; + } +} + + +LOCAL(void) +per_scan_setup (j_compress_ptr cinfo) +/* Do computations that are needed before processing a JPEG scan */ +/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */ +{ + int ci, mcublks, tmp; + jpeg_component_info *compptr; + + if (cinfo->comps_in_scan == 1) { + + /* Noninterleaved (single-component) scan */ + compptr = cinfo->cur_comp_info[0]; + + /* Overall image size in MCUs */ + cinfo->MCUs_per_row = compptr->width_in_blocks; + cinfo->MCU_rows_in_scan = compptr->height_in_blocks; + + /* For noninterleaved scan, always one block per MCU */ + compptr->MCU_width = 1; + compptr->MCU_height = 1; + compptr->MCU_blocks = 1; + compptr->MCU_sample_width = DCTSIZE; + compptr->last_col_width = 1; + /* For noninterleaved scans, it is convenient to define last_row_height + * as the number of block rows present in the last iMCU row. + */ + tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); + if (tmp == 0) tmp = compptr->v_samp_factor; + compptr->last_row_height = tmp; + + /* Prepare array describing MCU composition */ + cinfo->blocks_in_MCU = 1; + cinfo->MCU_membership[0] = 0; + + } else { + + /* Interleaved (multi-component) scan */ + if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, + MAX_COMPS_IN_SCAN); + + /* Overall image size in MCUs */ + cinfo->MCUs_per_row = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width, + (long) (cinfo->max_h_samp_factor*DCTSIZE)); + cinfo->MCU_rows_in_scan = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, + (long) (cinfo->max_v_samp_factor*DCTSIZE)); + + cinfo->blocks_in_MCU = 0; + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* Sampling factors give # of blocks of component in each MCU */ + compptr->MCU_width = compptr->h_samp_factor; + compptr->MCU_height = compptr->v_samp_factor; + compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; + compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE; + /* Figure number of non-dummy blocks in last MCU column & row */ + tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); + if (tmp == 0) tmp = compptr->MCU_width; + compptr->last_col_width = tmp; + tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); + if (tmp == 0) tmp = compptr->MCU_height; + compptr->last_row_height = tmp; + /* Prepare array describing MCU composition */ + mcublks = compptr->MCU_blocks; + if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU) + ERREXIT(cinfo, JERR_BAD_MCU_SIZE); + while (mcublks-- > 0) { + cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; + } + } + + } + + /* Convert restart specified in rows to actual MCU count. */ + /* Note that count must fit in 16 bits, so we provide limiting. */ + if (cinfo->restart_in_rows > 0) { + long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row; + cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L); + } +} + + +/* + * Per-pass setup. + * This is called at the beginning of each pass. We determine which modules + * will be active during this pass and give them appropriate start_pass calls. + * We also set is_last_pass to indicate whether any more passes will be + * required. + */ + +METHODDEF(void) +prepare_for_pass (j_compress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + + switch (master->pass_type) { + case main_pass: + /* Initial pass: will collect input data, and do either Huffman + * optimization or data output for the first scan. + */ + select_scan_parameters(cinfo); + per_scan_setup(cinfo); + if (! cinfo->raw_data_in) { + (*cinfo->cconvert->start_pass) (cinfo); + (*cinfo->downsample->start_pass) (cinfo); + (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU); + } + (*cinfo->fdct->start_pass) (cinfo); + (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding); + (*cinfo->coef->start_pass) (cinfo, + (master->total_passes > 1 ? + JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); + (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); + if (cinfo->optimize_coding) { + /* No immediate data output; postpone writing frame/scan headers */ + master->pub.call_pass_startup = FALSE; + } else { + /* Will write frame/scan headers at first jpeg_write_scanlines call */ + master->pub.call_pass_startup = TRUE; + } + break; +#ifdef ENTROPY_OPT_SUPPORTED + case huff_opt_pass: + /* Do Huffman optimization for a scan after the first one. */ + select_scan_parameters(cinfo); + per_scan_setup(cinfo); + if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) { + (*cinfo->entropy->start_pass) (cinfo, TRUE); + (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); + master->pub.call_pass_startup = FALSE; + break; + } + /* Special case: Huffman DC refinement scans need no Huffman table + * and therefore we can skip the optimization pass for them. + */ + master->pass_type = output_pass; + master->pass_number++; + /*FALLTHROUGH*/ +#endif + case output_pass: + /* Do a data-output pass. */ + /* We need not repeat per-scan setup if prior optimization pass did it. */ + if (! cinfo->optimize_coding) { + select_scan_parameters(cinfo); + per_scan_setup(cinfo); + } + (*cinfo->entropy->start_pass) (cinfo, FALSE); + (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); + /* We emit frame/scan headers now */ + if (master->scan_number == 0) + (*cinfo->marker->write_frame_header) (cinfo); + (*cinfo->marker->write_scan_header) (cinfo); + master->pub.call_pass_startup = FALSE; + break; + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + } + + master->pub.is_last_pass = (master->pass_number == master->total_passes-1); + + /* Set up progress monitor's pass info if present */ + if (cinfo->progress != NULL) { + cinfo->progress->completed_passes = master->pass_number; + cinfo->progress->total_passes = master->total_passes; + } +} + + +/* + * Special start-of-pass hook. + * This is called by jpeg_write_scanlines if call_pass_startup is TRUE. + * In single-pass processing, we need this hook because we don't want to + * write frame/scan headers during jpeg_start_compress; we want to let the + * application write COM markers etc. between jpeg_start_compress and the + * jpeg_write_scanlines loop. + * In multi-pass processing, this routine is not used. + */ + +METHODDEF(void) +pass_startup (j_compress_ptr cinfo) +{ + cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */ + + (*cinfo->marker->write_frame_header) (cinfo); + (*cinfo->marker->write_scan_header) (cinfo); +} + + +/* + * Finish up at end of pass. + */ + +METHODDEF(void) +finish_pass_master (j_compress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + + /* The entropy coder always needs an end-of-pass call, + * either to analyze statistics or to flush its output buffer. + */ + (*cinfo->entropy->finish_pass) (cinfo); + + /* Update state for next pass */ + switch (master->pass_type) { + case main_pass: + /* next pass is either output of scan 0 (after optimization) + * or output of scan 1 (if no optimization). + */ + master->pass_type = output_pass; + if (! cinfo->optimize_coding) + master->scan_number++; + break; + case huff_opt_pass: + /* next pass is always output of current scan */ + master->pass_type = output_pass; + break; + case output_pass: + /* next pass is either optimization or output of next scan */ + if (cinfo->optimize_coding) + master->pass_type = huff_opt_pass; + master->scan_number++; + break; + } + + master->pass_number++; +} + + +/* + * Initialize master compression control. + */ + +GLOBAL(void) +jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only) +{ + my_master_ptr master; + + master = (my_master_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_comp_master)); + cinfo->master = (struct jpeg_comp_master *) master; + master->pub.prepare_for_pass = prepare_for_pass; + master->pub.pass_startup = pass_startup; + master->pub.finish_pass = finish_pass_master; + master->pub.is_last_pass = FALSE; + + /* Validate parameters, determine derived values */ + initial_setup(cinfo); + + if (cinfo->scan_info != NULL) { +#ifdef C_MULTISCAN_FILES_SUPPORTED + validate_script(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + cinfo->progressive_mode = FALSE; + cinfo->num_scans = 1; + } + + if (cinfo->progressive_mode) /* TEMPORARY HACK ??? */ + cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */ + + /* Initialize my private state */ + if (transcode_only) { + /* no main pass in transcoding */ + if (cinfo->optimize_coding) + master->pass_type = huff_opt_pass; + else + master->pass_type = output_pass; + } else { + /* for normal compression, first pass is always this type: */ + master->pass_type = main_pass; + } + master->scan_number = 0; + master->pass_number = 0; + if (cinfo->optimize_coding) + master->total_passes = cinfo->num_scans * 2; + else + master->total_passes = cinfo->num_scans; +} diff --git a/TMessagesProj/jni/libjpeg/jcomapi.c b/TMessagesProj/jni/libjpeg/jcomapi.c new file mode 100755 index 000000000..9b1fa7568 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcomapi.c @@ -0,0 +1,106 @@ +/* + * jcomapi.c + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains application interface routines that are used for both + * compression and decompression. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Abort processing of a JPEG compression or decompression operation, + * but don't destroy the object itself. + * + * For this, we merely clean up all the nonpermanent memory pools. + * Note that temp files (virtual arrays) are not allowed to belong to + * the permanent pool, so we will be able to close all temp files here. + * Closing a data source or destination, if necessary, is the application's + * responsibility. + */ + +GLOBAL(void) +jpeg_abort (j_common_ptr cinfo) +{ + int pool; + + /* Do nothing if called on a not-initialized or destroyed JPEG object. */ + if (cinfo->mem == NULL) + return; + + /* Releasing pools in reverse order might help avoid fragmentation + * with some (brain-damaged) malloc libraries. + */ + for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) { + (*cinfo->mem->free_pool) (cinfo, pool); + } + + /* Reset overall state for possible reuse of object */ + if (cinfo->is_decompressor) { + cinfo->global_state = DSTATE_START; + /* Try to keep application from accessing now-deleted marker list. + * A bit kludgy to do it here, but this is the most central place. + */ + ((j_decompress_ptr) cinfo)->marker_list = NULL; + } else { + cinfo->global_state = CSTATE_START; + } +} + + +/* + * Destruction of a JPEG object. + * + * Everything gets deallocated except the master jpeg_compress_struct itself + * and the error manager struct. Both of these are supplied by the application + * and must be freed, if necessary, by the application. (Often they are on + * the stack and so don't need to be freed anyway.) + * Closing a data source or destination, if necessary, is the application's + * responsibility. + */ + +GLOBAL(void) +jpeg_destroy (j_common_ptr cinfo) +{ + /* We need only tell the memory manager to release everything. */ + /* NB: mem pointer is NULL if memory mgr failed to initialize. */ + if (cinfo->mem != NULL) + (*cinfo->mem->self_destruct) (cinfo); + cinfo->mem = NULL; /* be safe if jpeg_destroy is called twice */ + cinfo->global_state = 0; /* mark it destroyed */ +} + + +/* + * Convenience routines for allocating quantization and Huffman tables. + * (Would jutils.c be a more reasonable place to put these?) + */ + +GLOBAL(JQUANT_TBL *) +jpeg_alloc_quant_table (j_common_ptr cinfo) +{ + JQUANT_TBL *tbl; + + tbl = (JQUANT_TBL *) + (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL)); + tbl->sent_table = FALSE; /* make sure this is false in any new table */ + return tbl; +} + + +GLOBAL(JHUFF_TBL *) +jpeg_alloc_huff_table (j_common_ptr cinfo) +{ + JHUFF_TBL *tbl; + + tbl = (JHUFF_TBL *) + (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL)); + tbl->sent_table = FALSE; /* make sure this is false in any new table */ + return tbl; +} diff --git a/TMessagesProj/jni/libjpeg/jconfig.h b/TMessagesProj/jni/libjpeg/jconfig.h new file mode 100755 index 000000000..15a98177b --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jconfig.h @@ -0,0 +1,156 @@ +/* android jconfig.h */ +/* + * jconfig.doc + * + * Copyright (C) 1991-1994, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file documents the configuration options that are required to + * customize the JPEG software for a particular system. + * + * The actual configuration options for a particular installation are stored + * in jconfig.h. On many machines, jconfig.h can be generated automatically + * or copied from one of the "canned" jconfig files that we supply. But if + * you need to generate a jconfig.h file by hand, this file tells you how. + * + * DO NOT EDIT THIS FILE --- IT WON'T ACCOMPLISH ANYTHING. + * EDIT A COPY NAMED JCONFIG.H. + */ + + +/* + * These symbols indicate the properties of your machine or compiler. + * #define the symbol if yes, #undef it if no. + */ + +/* Does your compiler support function prototypes? + * (If not, you also need to use ansi2knr, see install.doc) + */ +#define HAVE_PROTOTYPES + +/* Does your compiler support the declaration "unsigned char" ? + * How about "unsigned short" ? + */ +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT + +/* Define "void" as "char" if your compiler doesn't know about type void. + * NOTE: be sure to define void such that "void *" represents the most general + * pointer type, e.g., that returned by malloc(). + */ +/* #define void char */ + +/* Define "const" as empty if your compiler doesn't know the "const" keyword. + */ +/* #define const */ + +/* Define this if an ordinary "char" type is unsigned. + * If you're not sure, leaving it undefined will work at some cost in speed. + * If you defined HAVE_UNSIGNED_CHAR then the speed difference is minimal. + */ +#undef CHAR_IS_UNSIGNED + +/* Define this if your system has an ANSI-conforming file. + */ +#define HAVE_STDDEF_H + +/* Define this if your system has an ANSI-conforming file. + */ +#define HAVE_STDLIB_H + +/* Define this if your system does not have an ANSI/SysV , + * but does have a BSD-style . + */ +#undef NEED_BSD_STRINGS + +/* Define this if your system does not provide typedef size_t in any of the + * ANSI-standard places (stddef.h, stdlib.h, or stdio.h), but places it in + * instead. + */ +#undef NEED_SYS_TYPES_H + +/* For 80x86 machines, you need to define NEED_FAR_POINTERS, + * unless you are using a large-data memory model or 80386 flat-memory mode. + * On less brain-damaged CPUs this symbol must not be defined. + * (Defining this symbol causes large data structures to be referenced through + * "far" pointers and to be allocated with a special version of malloc.) + */ +#undef NEED_FAR_POINTERS + +/* Define this if your linker needs global names to be unique in less + * than the first 15 characters. + */ +#undef NEED_SHORT_EXTERNAL_NAMES + +/* Although a real ANSI C compiler can deal perfectly well with pointers to + * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI + * and pseudo-ANSI compilers get confused. To keep one of these bozos happy, + * define INCOMPLETE_TYPES_BROKEN. This is not recommended unless you + * actually get "missing structure definition" warnings or errors while + * compiling the JPEG code. + */ +#undef INCOMPLETE_TYPES_BROKEN + + +/* + * The following options affect code selection within the JPEG library, + * but they don't need to be visible to applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS has been defined. + */ + +#ifdef JPEG_INTERNALS + +/* Define this if your compiler implements ">>" on signed values as a logical + * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift, + * which is the normal and rational definition. + */ +#undef RIGHT_SHIFT_IS_UNSIGNED + + +#endif /* JPEG_INTERNALS */ + + +/* + * The remaining options do not affect the JPEG library proper, + * but only the sample applications cjpeg/djpeg (see cjpeg.c, djpeg.c). + * Other applications can ignore these. + */ + +#ifdef JPEG_CJPEG_DJPEG + +/* These defines indicate which image (non-JPEG) file formats are allowed. */ + +#define BMP_SUPPORTED /* BMP image file format */ +#define GIF_SUPPORTED /* GIF image file format */ +#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ +#undef RLE_SUPPORTED /* Utah RLE image file format */ +#define TARGA_SUPPORTED /* Targa image file format */ + +/* Define this if you want to name both input and output files on the command + * line, rather than using stdout and optionally stdin. You MUST do this if + * your system can't cope with binary I/O to stdin/stdout. See comments at + * head of cjpeg.c or djpeg.c. + */ +#undef TWO_FILE_COMMANDLINE + +/* Define this if your system needs explicit cleanup of temporary files. + * This is crucial under MS-DOS, where the temporary "files" may be areas + * of extended memory; on most other systems it's not as important. + */ +#undef NEED_SIGNAL_CATCHER + +/* By default, we open image files with fopen(...,"rb") or fopen(...,"wb"). + * This is necessary on systems that distinguish text files from binary files, + * and is harmless on most systems that don't. If you have one of the rare + * systems that complains about the "b" spec, define this symbol. + */ +#undef DONT_USE_B_MODE + +/* Define this if you want percent-done progress reports from cjpeg/djpeg. + */ +#undef PROGRESS_REPORT + + +#endif /* JPEG_CJPEG_DJPEG */ diff --git a/TMessagesProj/jni/libjpeg/jcparam.c b/TMessagesProj/jni/libjpeg/jcparam.c new file mode 100755 index 000000000..6fc48f536 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcparam.c @@ -0,0 +1,610 @@ +/* + * jcparam.c + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains optional default-setting code for the JPEG compressor. + * Applications do not have to use this file, but those that don't use it + * must know a lot more about the innards of the JPEG code. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Quantization table setup routines + */ + +GLOBAL(void) +jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, boolean force_baseline) +/* Define a quantization table equal to the basic_table times + * a scale factor (given as a percentage). + * If force_baseline is TRUE, the computed quantization table entries + * are limited to 1..255 for JPEG baseline compatibility. + */ +{ + JQUANT_TBL ** qtblptr; + int i; + long temp; + + /* Safety check to ensure start_compress not called yet. */ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS) + ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl); + + qtblptr = & cinfo->quant_tbl_ptrs[which_tbl]; + + if (*qtblptr == NULL) + *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo); + + for (i = 0; i < DCTSIZE2; i++) { + temp = ((long) basic_table[i] * scale_factor + 50L) / 100L; + /* limit the values to the valid range */ + if (temp <= 0L) temp = 1L; + if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */ + if (force_baseline && temp > 255L) + temp = 255L; /* limit to baseline range if requested */ + (*qtblptr)->quantval[i] = (UINT16) temp; + } + + /* Initialize sent_table FALSE so table will be written to JPEG file. */ + (*qtblptr)->sent_table = FALSE; +} + + +GLOBAL(void) +jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor, + boolean force_baseline) +/* Set or change the 'quality' (quantization) setting, using default tables + * and a straight percentage-scaling quality scale. In most cases it's better + * to use jpeg_set_quality (below); this entry point is provided for + * applications that insist on a linear percentage scaling. + */ +{ + /* These are the sample quantization tables given in JPEG spec section K.1. + * The spec says that the values given produce "good" quality, and + * when divided by 2, "very good" quality. + */ + static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = { + 16, 11, 10, 16, 24, 40, 51, 61, + 12, 12, 14, 19, 26, 58, 60, 55, + 14, 13, 16, 24, 40, 57, 69, 56, + 14, 17, 22, 29, 51, 87, 80, 62, + 18, 22, 37, 56, 68, 109, 103, 77, + 24, 35, 55, 64, 81, 104, 113, 92, + 49, 64, 78, 87, 103, 121, 120, 101, + 72, 92, 95, 98, 112, 100, 103, 99 + }; + static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = { + 17, 18, 24, 47, 99, 99, 99, 99, + 18, 21, 26, 66, 99, 99, 99, 99, + 24, 26, 56, 99, 99, 99, 99, 99, + 47, 66, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99 + }; + + /* Set up two quantization tables using the specified scaling */ + jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, + scale_factor, force_baseline); + jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, + scale_factor, force_baseline); +} + + +GLOBAL(int) +jpeg_quality_scaling (int quality) +/* Convert a user-specified quality rating to a percentage scaling factor + * for an underlying quantization table, using our recommended scaling curve. + * The input 'quality' factor should be 0 (terrible) to 100 (very good). + */ +{ + /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */ + if (quality <= 0) quality = 1; + if (quality > 100) quality = 100; + + /* The basic table is used as-is (scaling 100) for a quality of 50. + * Qualities 50..100 are converted to scaling percentage 200 - 2*Q; + * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table + * to make all the table entries 1 (hence, minimum quantization loss). + * Qualities 1..50 are converted to scaling percentage 5000/Q. + */ + if (quality < 50) + quality = 5000 / quality; + else + quality = 200 - quality*2; + + return quality; +} + + +GLOBAL(void) +jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline) +/* Set or change the 'quality' (quantization) setting, using default tables. + * This is the standard quality-adjusting entry point for typical user + * interfaces; only those who want detailed control over quantization tables + * would use the preceding three routines directly. + */ +{ + /* Convert user 0-100 rating to percentage scaling */ + quality = jpeg_quality_scaling(quality); + + /* Set up standard quality tables */ + jpeg_set_linear_quality(cinfo, quality, force_baseline); +} + + +/* + * Huffman table setup routines + */ + +LOCAL(void) +add_huff_table (j_compress_ptr cinfo, + JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val) +/* Define a Huffman table */ +{ + int nsymbols, len; + + if (*htblptr == NULL) + *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); + + /* Copy the number-of-symbols-of-each-code-length counts */ + MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); + + /* Validate the counts. We do this here mainly so we can copy the right + * number of symbols from the val[] array, without risking marching off + * the end of memory. jchuff.c will do a more thorough test later. + */ + nsymbols = 0; + for (len = 1; len <= 16; len++) + nsymbols += bits[len]; + if (nsymbols < 1 || nsymbols > 256) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + + MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8)); + + /* Initialize sent_table FALSE so table will be written to JPEG file. */ + (*htblptr)->sent_table = FALSE; +} + + +LOCAL(void) +std_huff_tables (j_compress_ptr cinfo) +/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */ +/* IMPORTANT: these are only valid for 8-bit data precision! */ +{ + static const UINT8 bits_dc_luminance[17] = + { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; + static const UINT8 val_dc_luminance[] = + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + + static const UINT8 bits_dc_chrominance[17] = + { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; + static const UINT8 val_dc_chrominance[] = + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + + static const UINT8 bits_ac_luminance[17] = + { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d }; + static const UINT8 val_ac_luminance[] = + { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, + 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, + 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, + 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, + 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, + 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, + 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, + 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, + 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, + 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, + 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, + 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, + 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, + 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, + 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, + 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, + 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, + 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa }; + + static const UINT8 bits_ac_chrominance[17] = + { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 }; + static const UINT8 val_ac_chrominance[] = + { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, + 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, + 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, + 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, + 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, + 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, + 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, + 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, + 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, + 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, + 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, + 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, + 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, + 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, + 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, + 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, + 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, + 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa }; + + add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0], + bits_dc_luminance, val_dc_luminance); + add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0], + bits_ac_luminance, val_ac_luminance); + add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1], + bits_dc_chrominance, val_dc_chrominance); + add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1], + bits_ac_chrominance, val_ac_chrominance); +} + + +/* + * Default parameter setup for compression. + * + * Applications that don't choose to use this routine must do their + * own setup of all these parameters. Alternately, you can call this + * to establish defaults and then alter parameters selectively. This + * is the recommended approach since, if we add any new parameters, + * your code will still work (they'll be set to reasonable defaults). + */ + +GLOBAL(void) +jpeg_set_defaults (j_compress_ptr cinfo) +{ + int i; + + /* Safety check to ensure start_compress not called yet. */ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + /* Allocate comp_info array large enough for maximum component count. + * Array is made permanent in case application wants to compress + * multiple images at same param settings. + */ + if (cinfo->comp_info == NULL) + cinfo->comp_info = (jpeg_component_info *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + MAX_COMPONENTS * SIZEOF(jpeg_component_info)); + + /* Initialize everything not dependent on the color space */ + + cinfo->data_precision = BITS_IN_JSAMPLE; + /* Set up two quantization tables using default quality of 75 */ + jpeg_set_quality(cinfo, 75, TRUE); + /* Set up two Huffman tables */ + std_huff_tables(cinfo); + + /* Initialize default arithmetic coding conditioning */ + for (i = 0; i < NUM_ARITH_TBLS; i++) { + cinfo->arith_dc_L[i] = 0; + cinfo->arith_dc_U[i] = 1; + cinfo->arith_ac_K[i] = 5; + } + + /* Default is no multiple-scan output */ + cinfo->scan_info = NULL; + cinfo->num_scans = 0; + + /* Expect normal source image, not raw downsampled data */ + cinfo->raw_data_in = FALSE; + + /* Use Huffman coding, not arithmetic coding, by default */ + cinfo->arith_code = FALSE; + + /* By default, don't do extra passes to optimize entropy coding */ + cinfo->optimize_coding = FALSE; + /* The standard Huffman tables are only valid for 8-bit data precision. + * If the precision is higher, force optimization on so that usable + * tables will be computed. This test can be removed if default tables + * are supplied that are valid for the desired precision. + */ + if (cinfo->data_precision > 8) + cinfo->optimize_coding = TRUE; + + /* By default, use the simpler non-cosited sampling alignment */ + cinfo->CCIR601_sampling = FALSE; + + /* No input smoothing */ + cinfo->smoothing_factor = 0; + + /* DCT algorithm preference */ + cinfo->dct_method = JDCT_DEFAULT; + + /* No restart markers */ + cinfo->restart_interval = 0; + cinfo->restart_in_rows = 0; + + /* Fill in default JFIF marker parameters. Note that whether the marker + * will actually be written is determined by jpeg_set_colorspace. + * + * By default, the library emits JFIF version code 1.01. + * An application that wants to emit JFIF 1.02 extension markers should set + * JFIF_minor_version to 2. We could probably get away with just defaulting + * to 1.02, but there may still be some decoders in use that will complain + * about that; saying 1.01 should minimize compatibility problems. + */ + cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */ + cinfo->JFIF_minor_version = 1; + cinfo->density_unit = 0; /* Pixel size is unknown by default */ + cinfo->X_density = 1; /* Pixel aspect ratio is square by default */ + cinfo->Y_density = 1; + + /* Choose JPEG colorspace based on input space, set defaults accordingly */ + + jpeg_default_colorspace(cinfo); +} + + +/* + * Select an appropriate JPEG colorspace for in_color_space. + */ + +GLOBAL(void) +jpeg_default_colorspace (j_compress_ptr cinfo) +{ + switch (cinfo->in_color_space) { + case JCS_GRAYSCALE: + jpeg_set_colorspace(cinfo, JCS_GRAYSCALE); + break; + case JCS_RGB: + jpeg_set_colorspace(cinfo, JCS_YCbCr); + break; + case JCS_YCbCr: + jpeg_set_colorspace(cinfo, JCS_YCbCr); + break; + case JCS_CMYK: + jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */ + break; + case JCS_YCCK: + jpeg_set_colorspace(cinfo, JCS_YCCK); + break; + case JCS_UNKNOWN: + jpeg_set_colorspace(cinfo, JCS_UNKNOWN); + break; + default: + ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); + } +} + + +/* + * Set the JPEG colorspace, and choose colorspace-dependent default values. + */ + +GLOBAL(void) +jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace) +{ + jpeg_component_info * compptr; + int ci; + +#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \ + (compptr = &cinfo->comp_info[index], \ + compptr->component_id = (id), \ + compptr->h_samp_factor = (hsamp), \ + compptr->v_samp_factor = (vsamp), \ + compptr->quant_tbl_no = (quant), \ + compptr->dc_tbl_no = (dctbl), \ + compptr->ac_tbl_no = (actbl) ) + + /* Safety check to ensure start_compress not called yet. */ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + /* For all colorspaces, we use Q and Huff tables 0 for luminance components, + * tables 1 for chrominance components. + */ + + cinfo->jpeg_color_space = colorspace; + + cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */ + cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */ + + switch (colorspace) { + case JCS_GRAYSCALE: + cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ + cinfo->num_components = 1; + /* JFIF specifies component ID 1 */ + SET_COMP(0, 1, 1,1, 0, 0,0); + break; + case JCS_RGB: + cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */ + cinfo->num_components = 3; + SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0); + SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0); + SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0); + break; + case JCS_YCbCr: + cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ + cinfo->num_components = 3; + /* JFIF specifies component IDs 1,2,3 */ + /* We default to 2x2 subsamples of chrominance */ + SET_COMP(0, 1, 2,2, 0, 0,0); + SET_COMP(1, 2, 1,1, 1, 1,1); + SET_COMP(2, 3, 1,1, 1, 1,1); + break; + case JCS_CMYK: + cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */ + cinfo->num_components = 4; + SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0); + SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0); + SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0); + SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0); + break; + case JCS_YCCK: + cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */ + cinfo->num_components = 4; + SET_COMP(0, 1, 2,2, 0, 0,0); + SET_COMP(1, 2, 1,1, 1, 1,1); + SET_COMP(2, 3, 1,1, 1, 1,1); + SET_COMP(3, 4, 2,2, 0, 0,0); + break; + case JCS_UNKNOWN: + cinfo->num_components = cinfo->input_components; + if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, + MAX_COMPONENTS); + for (ci = 0; ci < cinfo->num_components; ci++) { + SET_COMP(ci, ci, 1,1, 0, 0,0); + } + break; + default: + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + } +} + + +#ifdef C_PROGRESSIVE_SUPPORTED + +LOCAL(jpeg_scan_info *) +fill_a_scan (jpeg_scan_info * scanptr, int ci, + int Ss, int Se, int Ah, int Al) +/* Support routine: generate one scan for specified component */ +{ + scanptr->comps_in_scan = 1; + scanptr->component_index[0] = ci; + scanptr->Ss = Ss; + scanptr->Se = Se; + scanptr->Ah = Ah; + scanptr->Al = Al; + scanptr++; + return scanptr; +} + +LOCAL(jpeg_scan_info *) +fill_scans (jpeg_scan_info * scanptr, int ncomps, + int Ss, int Se, int Ah, int Al) +/* Support routine: generate one scan for each component */ +{ + int ci; + + for (ci = 0; ci < ncomps; ci++) { + scanptr->comps_in_scan = 1; + scanptr->component_index[0] = ci; + scanptr->Ss = Ss; + scanptr->Se = Se; + scanptr->Ah = Ah; + scanptr->Al = Al; + scanptr++; + } + return scanptr; +} + +LOCAL(jpeg_scan_info *) +fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al) +/* Support routine: generate interleaved DC scan if possible, else N scans */ +{ + int ci; + + if (ncomps <= MAX_COMPS_IN_SCAN) { + /* Single interleaved DC scan */ + scanptr->comps_in_scan = ncomps; + for (ci = 0; ci < ncomps; ci++) + scanptr->component_index[ci] = ci; + scanptr->Ss = scanptr->Se = 0; + scanptr->Ah = Ah; + scanptr->Al = Al; + scanptr++; + } else { + /* Noninterleaved DC scan for each component */ + scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al); + } + return scanptr; +} + + +/* + * Create a recommended progressive-JPEG script. + * cinfo->num_components and cinfo->jpeg_color_space must be correct. + */ + +GLOBAL(void) +jpeg_simple_progression (j_compress_ptr cinfo) +{ + int ncomps = cinfo->num_components; + int nscans; + jpeg_scan_info * scanptr; + + /* Safety check to ensure start_compress not called yet. */ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + /* Figure space needed for script. Calculation must match code below! */ + if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { + /* Custom script for YCbCr color images. */ + nscans = 10; + } else { + /* All-purpose script for other color spaces. */ + if (ncomps > MAX_COMPS_IN_SCAN) + nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */ + else + nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */ + } + + /* Allocate space for script. + * We need to put it in the permanent pool in case the application performs + * multiple compressions without changing the settings. To avoid a memory + * leak if jpeg_simple_progression is called repeatedly for the same JPEG + * object, we try to re-use previously allocated space, and we allocate + * enough space to handle YCbCr even if initially asked for grayscale. + */ + if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) { + cinfo->script_space_size = MAX(nscans, 10); + cinfo->script_space = (jpeg_scan_info *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + cinfo->script_space_size * SIZEOF(jpeg_scan_info)); + } + scanptr = cinfo->script_space; + cinfo->scan_info = scanptr; + cinfo->num_scans = nscans; + + if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { + /* Custom script for YCbCr color images. */ + /* Initial DC scan */ + scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); + /* Initial AC scan: get some luma data out in a hurry */ + scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2); + /* Chroma data is too small to be worth expending many scans on */ + scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1); + scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1); + /* Complete spectral selection for luma AC */ + scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2); + /* Refine next bit of luma AC */ + scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1); + /* Finish DC successive approximation */ + scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); + /* Finish AC successive approximation */ + scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0); + scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0); + /* Luma bottom bit comes last since it's usually largest scan */ + scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0); + } else { + /* All-purpose script for other color spaces. */ + /* Successive approximation first pass */ + scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); + scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2); + scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2); + /* Successive approximation second pass */ + scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1); + /* Successive approximation final pass */ + scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); + scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0); + } +} + +#endif /* C_PROGRESSIVE_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jcphuff.c b/TMessagesProj/jni/libjpeg/jcphuff.c new file mode 100755 index 000000000..07f9178b0 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcphuff.c @@ -0,0 +1,833 @@ +/* + * jcphuff.c + * + * Copyright (C) 1995-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains Huffman entropy encoding routines for progressive JPEG. + * + * We do not support output suspension in this module, since the library + * currently does not allow multiple-scan files to be written with output + * suspension. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jchuff.h" /* Declarations shared with jchuff.c */ + +#ifdef C_PROGRESSIVE_SUPPORTED + +/* Expanded entropy encoder object for progressive Huffman encoding. */ + +typedef struct { + struct jpeg_entropy_encoder pub; /* public fields */ + + /* Mode flag: TRUE for optimization, FALSE for actual data output */ + boolean gather_statistics; + + /* Bit-level coding status. + * next_output_byte/free_in_buffer are local copies of cinfo->dest fields. + */ + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + INT32 put_buffer; /* current bit-accumulation buffer */ + int put_bits; /* # of bits now in it */ + j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */ + + /* Coding status for DC components */ + int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ + + /* Coding status for AC components */ + int ac_tbl_no; /* the table number of the single component */ + unsigned int EOBRUN; /* run length of EOBs */ + unsigned int BE; /* # of buffered correction bits before MCU */ + char * bit_buffer; /* buffer for correction bits (1 per char) */ + /* packing correction bits tightly would save some space but cost time... */ + + unsigned int restarts_to_go; /* MCUs left in this restart interval */ + int next_restart_num; /* next restart number to write (0-7) */ + + /* Pointers to derived tables (these workspaces have image lifespan). + * Since any one scan codes only DC or only AC, we only need one set + * of tables, not one for DC and one for AC. + */ + c_derived_tbl * derived_tbls[NUM_HUFF_TBLS]; + + /* Statistics tables for optimization; again, one set is enough */ + long * count_ptrs[NUM_HUFF_TBLS]; +} phuff_entropy_encoder; + +typedef phuff_entropy_encoder * phuff_entropy_ptr; + +/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit + * buffer can hold. Larger sizes may slightly improve compression, but + * 1000 is already well into the realm of overkill. + * The minimum safe size is 64 bits. + */ + +#define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */ + +/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. + * We assume that int right shift is unsigned if INT32 right shift is, + * which should be safe. + */ + +#ifdef RIGHT_SHIFT_IS_UNSIGNED +#define ISHIFT_TEMPS int ishift_temp; +#define IRIGHT_SHIFT(x,shft) \ + ((ishift_temp = (x)) < 0 ? \ + (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \ + (ishift_temp >> (shft))) +#else +#define ISHIFT_TEMPS +#define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) +#endif + +/* Forward declarations */ +METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo)); +METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo)); + + +/* + * Initialize for a Huffman-compressed scan using progressive JPEG. + */ + +METHODDEF(void) +start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + boolean is_DC_band; + int ci, tbl; + jpeg_component_info * compptr; + + entropy->cinfo = cinfo; + entropy->gather_statistics = gather_statistics; + + is_DC_band = (cinfo->Ss == 0); + + /* We assume jcmaster.c already validated the scan parameters. */ + + /* Select execution routines */ + if (cinfo->Ah == 0) { + if (is_DC_band) + entropy->pub.encode_mcu = encode_mcu_DC_first; + else + entropy->pub.encode_mcu = encode_mcu_AC_first; + } else { + if (is_DC_band) + entropy->pub.encode_mcu = encode_mcu_DC_refine; + else { + entropy->pub.encode_mcu = encode_mcu_AC_refine; + /* AC refinement needs a correction bit buffer */ + if (entropy->bit_buffer == NULL) + entropy->bit_buffer = (char *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + MAX_CORR_BITS * SIZEOF(char)); + } + } + if (gather_statistics) + entropy->pub.finish_pass = finish_pass_gather_phuff; + else + entropy->pub.finish_pass = finish_pass_phuff; + + /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1 + * for AC coefficients. + */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* Initialize DC predictions to 0 */ + entropy->last_dc_val[ci] = 0; + /* Get table index */ + if (is_DC_band) { + if (cinfo->Ah != 0) /* DC refinement needs no table */ + continue; + tbl = compptr->dc_tbl_no; + } else { + entropy->ac_tbl_no = tbl = compptr->ac_tbl_no; + } + if (gather_statistics) { + /* Check for invalid table index */ + /* (make_c_derived_tbl does this in the other path) */ + if (tbl < 0 || tbl >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl); + /* Allocate and zero the statistics tables */ + /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ + if (entropy->count_ptrs[tbl] == NULL) + entropy->count_ptrs[tbl] = (long *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + 257 * SIZEOF(long)); + MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long)); + } else { + /* Compute derived values for Huffman table */ + /* We may do this more than once for a table, but it's not expensive */ + jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl, + & entropy->derived_tbls[tbl]); + } + } + + /* Initialize AC stuff */ + entropy->EOBRUN = 0; + entropy->BE = 0; + + /* Initialize bit buffer to empty */ + entropy->put_buffer = 0; + entropy->put_bits = 0; + + /* Initialize restart stuff */ + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num = 0; +} + + +/* Outputting bytes to the file. + * NB: these must be called only when actually outputting, + * that is, entropy->gather_statistics == FALSE. + */ + +/* Emit a byte */ +#define emit_byte(entropy,val) \ + { *(entropy)->next_output_byte++ = (JOCTET) (val); \ + if (--(entropy)->free_in_buffer == 0) \ + dump_buffer(entropy); } + + +LOCAL(void) +dump_buffer (phuff_entropy_ptr entropy) +/* Empty the output buffer; we do not support suspension in this module. */ +{ + struct jpeg_destination_mgr * dest = entropy->cinfo->dest; + + if (! (*dest->empty_output_buffer) (entropy->cinfo)) + ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND); + /* After a successful buffer dump, must reset buffer pointers */ + entropy->next_output_byte = dest->next_output_byte; + entropy->free_in_buffer = dest->free_in_buffer; +} + + +/* Outputting bits to the file */ + +/* Only the right 24 bits of put_buffer are used; the valid bits are + * left-justified in this part. At most 16 bits can be passed to emit_bits + * in one call, and we never retain more than 7 bits in put_buffer + * between calls, so 24 bits are sufficient. + */ + +INLINE +LOCAL(void) +emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size) +/* Emit some bits, unless we are in gather mode */ +{ + /* This routine is heavily used, so it's worth coding tightly. */ + register INT32 put_buffer = (INT32) code; + register int put_bits = entropy->put_bits; + + /* if size is 0, caller used an invalid Huffman table entry */ + if (size == 0) + ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE); + + if (entropy->gather_statistics) + return; /* do nothing if we're only getting stats */ + + put_buffer &= (((INT32) 1)<put_buffer; /* and merge with old buffer contents */ + + while (put_bits >= 8) { + int c = (int) ((put_buffer >> 16) & 0xFF); + + emit_byte(entropy, c); + if (c == 0xFF) { /* need to stuff a zero byte? */ + emit_byte(entropy, 0); + } + put_buffer <<= 8; + put_bits -= 8; + } + + entropy->put_buffer = put_buffer; /* update variables */ + entropy->put_bits = put_bits; +} + + +LOCAL(void) +flush_bits (phuff_entropy_ptr entropy) +{ + emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */ + entropy->put_buffer = 0; /* and reset bit-buffer to empty */ + entropy->put_bits = 0; +} + + +/* + * Emit (or just count) a Huffman symbol. + */ + +INLINE +LOCAL(void) +emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol) +{ + if (entropy->gather_statistics) + entropy->count_ptrs[tbl_no][symbol]++; + else { + c_derived_tbl * tbl = entropy->derived_tbls[tbl_no]; + emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]); + } +} + + +/* + * Emit bits from a correction bit buffer. + */ + +LOCAL(void) +emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart, + unsigned int nbits) +{ + if (entropy->gather_statistics) + return; /* no real work */ + + while (nbits > 0) { + emit_bits(entropy, (unsigned int) (*bufstart), 1); + bufstart++; + nbits--; + } +} + + +/* + * Emit any pending EOBRUN symbol. + */ + +LOCAL(void) +emit_eobrun (phuff_entropy_ptr entropy) +{ + register int temp, nbits; + + if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */ + temp = entropy->EOBRUN; + nbits = 0; + while ((temp >>= 1)) + nbits++; + /* safety check: shouldn't happen given limited correction-bit buffer */ + if (nbits > 14) + ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE); + + emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4); + if (nbits) + emit_bits(entropy, entropy->EOBRUN, nbits); + + entropy->EOBRUN = 0; + + /* Emit any buffered correction bits */ + emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE); + entropy->BE = 0; + } +} + + +/* + * Emit a restart marker & resynchronize predictions. + */ + +LOCAL(void) +emit_restart (phuff_entropy_ptr entropy, int restart_num) +{ + int ci; + + emit_eobrun(entropy); + + if (! entropy->gather_statistics) { + flush_bits(entropy); + emit_byte(entropy, 0xFF); + emit_byte(entropy, JPEG_RST0 + restart_num); + } + + if (entropy->cinfo->Ss == 0) { + /* Re-initialize DC predictions to 0 */ + for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++) + entropy->last_dc_val[ci] = 0; + } else { + /* Re-initialize all AC-related fields to 0 */ + entropy->EOBRUN = 0; + entropy->BE = 0; + } +} + + +/* + * MCU encoding for DC initial scan (either spectral selection, + * or first pass of successive approximation). + */ + +METHODDEF(boolean) +encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + register int temp, temp2; + register int nbits; + int blkn, ci; + int Al = cinfo->Al; + JBLOCKROW block; + jpeg_component_info * compptr; + ISHIFT_TEMPS + + entropy->next_output_byte = cinfo->dest->next_output_byte; + entropy->free_in_buffer = cinfo->dest->free_in_buffer; + + /* Emit restart marker if needed */ + if (cinfo->restart_interval) + if (entropy->restarts_to_go == 0) + emit_restart(entropy, entropy->next_restart_num); + + /* Encode the MCU data blocks */ + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + block = MCU_data[blkn]; + ci = cinfo->MCU_membership[blkn]; + compptr = cinfo->cur_comp_info[ci]; + + /* Compute the DC value after the required point transform by Al. + * This is simply an arithmetic right shift. + */ + temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al); + + /* DC differences are figured on the point-transformed values. */ + temp = temp2 - entropy->last_dc_val[ci]; + entropy->last_dc_val[ci] = temp2; + + /* Encode the DC coefficient difference per section G.1.2.1 */ + temp2 = temp; + if (temp < 0) { + temp = -temp; /* temp is abs value of input */ + /* For a negative input, want temp2 = bitwise complement of abs(input) */ + /* This code assumes we are on a two's complement machine */ + temp2--; + } + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 0; + while (temp) { + nbits++; + temp >>= 1; + } + /* Check for out-of-range coefficient values. + * Since we're encoding a difference, the range limit is twice as much. + */ + if (nbits > MAX_COEF_BITS+1) + ERREXIT(cinfo, JERR_BAD_DCT_COEF); + + /* Count/emit the Huffman-coded symbol for the number of bits */ + emit_symbol(entropy, compptr->dc_tbl_no, nbits); + + /* Emit that number of bits of the value, if positive, */ + /* or the complement of its magnitude, if negative. */ + if (nbits) /* emit_bits rejects calls with size 0 */ + emit_bits(entropy, (unsigned int) temp2, nbits); + } + + cinfo->dest->next_output_byte = entropy->next_output_byte; + cinfo->dest->free_in_buffer = entropy->free_in_buffer; + + /* Update restart-interval state too */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num++; + entropy->next_restart_num &= 7; + } + entropy->restarts_to_go--; + } + + return TRUE; +} + + +/* + * MCU encoding for AC initial scan (either spectral selection, + * or first pass of successive approximation). + */ + +METHODDEF(boolean) +encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + register int temp, temp2; + register int nbits; + register int r, k; + int Se = cinfo->Se; + int Al = cinfo->Al; + JBLOCKROW block; + + entropy->next_output_byte = cinfo->dest->next_output_byte; + entropy->free_in_buffer = cinfo->dest->free_in_buffer; + + /* Emit restart marker if needed */ + if (cinfo->restart_interval) + if (entropy->restarts_to_go == 0) + emit_restart(entropy, entropy->next_restart_num); + + /* Encode the MCU data block */ + block = MCU_data[0]; + + /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */ + + r = 0; /* r = run length of zeros */ + + for (k = cinfo->Ss; k <= Se; k++) { + if ((temp = (*block)[jpeg_natural_order[k]]) == 0) { + r++; + continue; + } + /* We must apply the point transform by Al. For AC coefficients this + * is an integer division with rounding towards 0. To do this portably + * in C, we shift after obtaining the absolute value; so the code is + * interwoven with finding the abs value (temp) and output bits (temp2). + */ + if (temp < 0) { + temp = -temp; /* temp is abs value of input */ + temp >>= Al; /* apply the point transform */ + /* For a negative coef, want temp2 = bitwise complement of abs(coef) */ + temp2 = ~temp; + } else { + temp >>= Al; /* apply the point transform */ + temp2 = temp; + } + /* Watch out for case that nonzero coef is zero after point transform */ + if (temp == 0) { + r++; + continue; + } + + /* Emit any pending EOBRUN */ + if (entropy->EOBRUN > 0) + emit_eobrun(entropy); + /* if run length > 15, must emit special run-length-16 codes (0xF0) */ + while (r > 15) { + emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); + r -= 16; + } + + /* Find the number of bits needed for the magnitude of the coefficient */ + nbits = 1; /* there must be at least one 1 bit */ + while ((temp >>= 1)) + nbits++; + /* Check for out-of-range coefficient values */ + if (nbits > MAX_COEF_BITS) + ERREXIT(cinfo, JERR_BAD_DCT_COEF); + + /* Count/emit Huffman symbol for run length / number of bits */ + emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits); + + /* Emit that number of bits of the value, if positive, */ + /* or the complement of its magnitude, if negative. */ + emit_bits(entropy, (unsigned int) temp2, nbits); + + r = 0; /* reset zero run length */ + } + + if (r > 0) { /* If there are trailing zeroes, */ + entropy->EOBRUN++; /* count an EOB */ + if (entropy->EOBRUN == 0x7FFF) + emit_eobrun(entropy); /* force it out to avoid overflow */ + } + + cinfo->dest->next_output_byte = entropy->next_output_byte; + cinfo->dest->free_in_buffer = entropy->free_in_buffer; + + /* Update restart-interval state too */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num++; + entropy->next_restart_num &= 7; + } + entropy->restarts_to_go--; + } + + return TRUE; +} + + +/* + * MCU encoding for DC successive approximation refinement scan. + * Note: we assume such scans can be multi-component, although the spec + * is not very clear on the point. + */ + +METHODDEF(boolean) +encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + register int temp; + int blkn; + int Al = cinfo->Al; + JBLOCKROW block; + + entropy->next_output_byte = cinfo->dest->next_output_byte; + entropy->free_in_buffer = cinfo->dest->free_in_buffer; + + /* Emit restart marker if needed */ + if (cinfo->restart_interval) + if (entropy->restarts_to_go == 0) + emit_restart(entropy, entropy->next_restart_num); + + /* Encode the MCU data blocks */ + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + block = MCU_data[blkn]; + + /* We simply emit the Al'th bit of the DC coefficient value. */ + temp = (*block)[0]; + emit_bits(entropy, (unsigned int) (temp >> Al), 1); + } + + cinfo->dest->next_output_byte = entropy->next_output_byte; + cinfo->dest->free_in_buffer = entropy->free_in_buffer; + + /* Update restart-interval state too */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num++; + entropy->next_restart_num &= 7; + } + entropy->restarts_to_go--; + } + + return TRUE; +} + + +/* + * MCU encoding for AC successive approximation refinement scan. + */ + +METHODDEF(boolean) +encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + register int temp; + register int r, k; + int EOB; + char *BR_buffer; + unsigned int BR; + int Se = cinfo->Se; + int Al = cinfo->Al; + JBLOCKROW block; + int absvalues[DCTSIZE2]; + + entropy->next_output_byte = cinfo->dest->next_output_byte; + entropy->free_in_buffer = cinfo->dest->free_in_buffer; + + /* Emit restart marker if needed */ + if (cinfo->restart_interval) + if (entropy->restarts_to_go == 0) + emit_restart(entropy, entropy->next_restart_num); + + /* Encode the MCU data block */ + block = MCU_data[0]; + + /* It is convenient to make a pre-pass to determine the transformed + * coefficients' absolute values and the EOB position. + */ + EOB = 0; + for (k = cinfo->Ss; k <= Se; k++) { + temp = (*block)[jpeg_natural_order[k]]; + /* We must apply the point transform by Al. For AC coefficients this + * is an integer division with rounding towards 0. To do this portably + * in C, we shift after obtaining the absolute value. + */ + if (temp < 0) + temp = -temp; /* temp is abs value of input */ + temp >>= Al; /* apply the point transform */ + absvalues[k] = temp; /* save abs value for main pass */ + if (temp == 1) + EOB = k; /* EOB = index of last newly-nonzero coef */ + } + + /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */ + + r = 0; /* r = run length of zeros */ + BR = 0; /* BR = count of buffered bits added now */ + BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */ + + for (k = cinfo->Ss; k <= Se; k++) { + if ((temp = absvalues[k]) == 0) { + r++; + continue; + } + + /* Emit any required ZRLs, but not if they can be folded into EOB */ + while (r > 15 && k <= EOB) { + /* emit any pending EOBRUN and the BE correction bits */ + emit_eobrun(entropy); + /* Emit ZRL */ + emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); + r -= 16; + /* Emit buffered correction bits that must be associated with ZRL */ + emit_buffered_bits(entropy, BR_buffer, BR); + BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ + BR = 0; + } + + /* If the coef was previously nonzero, it only needs a correction bit. + * NOTE: a straight translation of the spec's figure G.7 would suggest + * that we also need to test r > 15. But if r > 15, we can only get here + * if k > EOB, which implies that this coefficient is not 1. + */ + if (temp > 1) { + /* The correction bit is the next bit of the absolute value. */ + BR_buffer[BR++] = (char) (temp & 1); + continue; + } + + /* Emit any pending EOBRUN and the BE correction bits */ + emit_eobrun(entropy); + + /* Count/emit Huffman symbol for run length / number of bits */ + emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1); + + /* Emit output bit for newly-nonzero coef */ + temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1; + emit_bits(entropy, (unsigned int) temp, 1); + + /* Emit buffered correction bits that must be associated with this code */ + emit_buffered_bits(entropy, BR_buffer, BR); + BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ + BR = 0; + r = 0; /* reset zero run length */ + } + + if (r > 0 || BR > 0) { /* If there are trailing zeroes, */ + entropy->EOBRUN++; /* count an EOB */ + entropy->BE += BR; /* concat my correction bits to older ones */ + /* We force out the EOB if we risk either: + * 1. overflow of the EOB counter; + * 2. overflow of the correction bit buffer during the next MCU. + */ + if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1)) + emit_eobrun(entropy); + } + + cinfo->dest->next_output_byte = entropy->next_output_byte; + cinfo->dest->free_in_buffer = entropy->free_in_buffer; + + /* Update restart-interval state too */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) { + entropy->restarts_to_go = cinfo->restart_interval; + entropy->next_restart_num++; + entropy->next_restart_num &= 7; + } + entropy->restarts_to_go--; + } + + return TRUE; +} + + +/* + * Finish up at the end of a Huffman-compressed progressive scan. + */ + +METHODDEF(void) +finish_pass_phuff (j_compress_ptr cinfo) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + + entropy->next_output_byte = cinfo->dest->next_output_byte; + entropy->free_in_buffer = cinfo->dest->free_in_buffer; + + /* Flush out any buffered data */ + emit_eobrun(entropy); + flush_bits(entropy); + + cinfo->dest->next_output_byte = entropy->next_output_byte; + cinfo->dest->free_in_buffer = entropy->free_in_buffer; +} + + +/* + * Finish up a statistics-gathering pass and create the new Huffman tables. + */ + +METHODDEF(void) +finish_pass_gather_phuff (j_compress_ptr cinfo) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + boolean is_DC_band; + int ci, tbl; + jpeg_component_info * compptr; + JHUFF_TBL **htblptr; + boolean did[NUM_HUFF_TBLS]; + + /* Flush out buffered data (all we care about is counting the EOB symbol) */ + emit_eobrun(entropy); + + is_DC_band = (cinfo->Ss == 0); + + /* It's important not to apply jpeg_gen_optimal_table more than once + * per table, because it clobbers the input frequency counts! + */ + MEMZERO(did, SIZEOF(did)); + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + if (is_DC_band) { + if (cinfo->Ah != 0) /* DC refinement needs no table */ + continue; + tbl = compptr->dc_tbl_no; + } else { + tbl = compptr->ac_tbl_no; + } + if (! did[tbl]) { + if (is_DC_band) + htblptr = & cinfo->dc_huff_tbl_ptrs[tbl]; + else + htblptr = & cinfo->ac_huff_tbl_ptrs[tbl]; + if (*htblptr == NULL) + *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); + jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]); + did[tbl] = TRUE; + } + } +} + + +/* + * Module initialization routine for progressive Huffman entropy encoding. + */ + +GLOBAL(void) +jinit_phuff_encoder (j_compress_ptr cinfo) +{ + phuff_entropy_ptr entropy; + int i; + + entropy = (phuff_entropy_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(phuff_entropy_encoder)); + cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; + entropy->pub.start_pass = start_pass_phuff; + + /* Mark tables unallocated */ + for (i = 0; i < NUM_HUFF_TBLS; i++) { + entropy->derived_tbls[i] = NULL; + entropy->count_ptrs[i] = NULL; + } + entropy->bit_buffer = NULL; /* needed only in AC refinement scan */ +} + +#endif /* C_PROGRESSIVE_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jcprepct.c b/TMessagesProj/jni/libjpeg/jcprepct.c new file mode 100755 index 000000000..fa93333db --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcprepct.c @@ -0,0 +1,354 @@ +/* + * jcprepct.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the compression preprocessing controller. + * This controller manages the color conversion, downsampling, + * and edge expansion steps. + * + * Most of the complexity here is associated with buffering input rows + * as required by the downsampler. See the comments at the head of + * jcsample.c for the downsampler's needs. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* At present, jcsample.c can request context rows only for smoothing. + * In the future, we might also need context rows for CCIR601 sampling + * or other more-complex downsampling procedures. The code to support + * context rows should be compiled only if needed. + */ +#ifdef INPUT_SMOOTHING_SUPPORTED +#define CONTEXT_ROWS_SUPPORTED +#endif + + +/* + * For the simple (no-context-row) case, we just need to buffer one + * row group's worth of pixels for the downsampling step. At the bottom of + * the image, we pad to a full row group by replicating the last pixel row. + * The downsampler's last output row is then replicated if needed to pad + * out to a full iMCU row. + * + * When providing context rows, we must buffer three row groups' worth of + * pixels. Three row groups are physically allocated, but the row pointer + * arrays are made five row groups high, with the extra pointers above and + * below "wrapping around" to point to the last and first real row groups. + * This allows the downsampler to access the proper context rows. + * At the top and bottom of the image, we create dummy context rows by + * copying the first or last real pixel row. This copying could be avoided + * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the + * trouble on the compression side. + */ + + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_c_prep_controller pub; /* public fields */ + + /* Downsampling input buffer. This buffer holds color-converted data + * until we have enough to do a downsample step. + */ + JSAMPARRAY color_buf[MAX_COMPONENTS]; + + JDIMENSION rows_to_go; /* counts rows remaining in source image */ + int next_buf_row; /* index of next row to store in color_buf */ + +#ifdef CONTEXT_ROWS_SUPPORTED /* only needed for context case */ + int this_row_group; /* starting row index of group to process */ + int next_buf_stop; /* downsample when we reach this index */ +#endif +} my_prep_controller; + +typedef my_prep_controller * my_prep_ptr; + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_prep_ptr prep = (my_prep_ptr) cinfo->prep; + + if (pass_mode != JBUF_PASS_THRU) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + + /* Initialize total-height counter for detecting bottom of image */ + prep->rows_to_go = cinfo->image_height; + /* Mark the conversion buffer empty */ + prep->next_buf_row = 0; +#ifdef CONTEXT_ROWS_SUPPORTED + /* Preset additional state variables for context mode. + * These aren't used in non-context mode, so we needn't test which mode. + */ + prep->this_row_group = 0; + /* Set next_buf_stop to stop after two row groups have been read in. */ + prep->next_buf_stop = 2 * cinfo->max_v_samp_factor; +#endif +} + + +/* + * Expand an image vertically from height input_rows to height output_rows, + * by duplicating the bottom row. + */ + +LOCAL(void) +expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols, + int input_rows, int output_rows) +{ + register int row; + + for (row = input_rows; row < output_rows; row++) { + jcopy_sample_rows(image_data, input_rows-1, image_data, row, + 1, num_cols); + } +} + + +/* + * Process some data in the simple no-context case. + * + * Preprocessor output data is counted in "row groups". A row group + * is defined to be v_samp_factor sample rows of each component. + * Downsampling will produce this much data from each max_v_samp_factor + * input rows. + */ + +METHODDEF(void) +pre_process_data (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail, + JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, + JDIMENSION out_row_groups_avail) +{ + my_prep_ptr prep = (my_prep_ptr) cinfo->prep; + int numrows, ci; + JDIMENSION inrows; + jpeg_component_info * compptr; + + while (*in_row_ctr < in_rows_avail && + *out_row_group_ctr < out_row_groups_avail) { + /* Do color conversion to fill the conversion buffer. */ + inrows = in_rows_avail - *in_row_ctr; + numrows = cinfo->max_v_samp_factor - prep->next_buf_row; + numrows = (int) MIN((JDIMENSION) numrows, inrows); + (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr, + prep->color_buf, + (JDIMENSION) prep->next_buf_row, + numrows); + *in_row_ctr += numrows; + prep->next_buf_row += numrows; + prep->rows_to_go -= numrows; + /* If at bottom of image, pad to fill the conversion buffer. */ + if (prep->rows_to_go == 0 && + prep->next_buf_row < cinfo->max_v_samp_factor) { + for (ci = 0; ci < cinfo->num_components; ci++) { + expand_bottom_edge(prep->color_buf[ci], cinfo->image_width, + prep->next_buf_row, cinfo->max_v_samp_factor); + } + prep->next_buf_row = cinfo->max_v_samp_factor; + } + /* If we've filled the conversion buffer, empty it. */ + if (prep->next_buf_row == cinfo->max_v_samp_factor) { + (*cinfo->downsample->downsample) (cinfo, + prep->color_buf, (JDIMENSION) 0, + output_buf, *out_row_group_ctr); + prep->next_buf_row = 0; + (*out_row_group_ctr)++; + } + /* If at bottom of image, pad the output to a full iMCU height. + * Note we assume the caller is providing a one-iMCU-height output buffer! + */ + if (prep->rows_to_go == 0 && + *out_row_group_ctr < out_row_groups_avail) { + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + expand_bottom_edge(output_buf[ci], + compptr->width_in_blocks * DCTSIZE, + (int) (*out_row_group_ctr * compptr->v_samp_factor), + (int) (out_row_groups_avail * compptr->v_samp_factor)); + } + *out_row_group_ctr = out_row_groups_avail; + break; /* can exit outer loop without test */ + } + } +} + + +#ifdef CONTEXT_ROWS_SUPPORTED + +/* + * Process some data in the context case. + */ + +METHODDEF(void) +pre_process_context (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail, + JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, + JDIMENSION out_row_groups_avail) +{ + my_prep_ptr prep = (my_prep_ptr) cinfo->prep; + int numrows, ci; + int buf_height = cinfo->max_v_samp_factor * 3; + JDIMENSION inrows; + + while (*out_row_group_ctr < out_row_groups_avail) { + if (*in_row_ctr < in_rows_avail) { + /* Do color conversion to fill the conversion buffer. */ + inrows = in_rows_avail - *in_row_ctr; + numrows = prep->next_buf_stop - prep->next_buf_row; + numrows = (int) MIN((JDIMENSION) numrows, inrows); + (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr, + prep->color_buf, + (JDIMENSION) prep->next_buf_row, + numrows); + /* Pad at top of image, if first time through */ + if (prep->rows_to_go == cinfo->image_height) { + for (ci = 0; ci < cinfo->num_components; ci++) { + int row; + for (row = 1; row <= cinfo->max_v_samp_factor; row++) { + jcopy_sample_rows(prep->color_buf[ci], 0, + prep->color_buf[ci], -row, + 1, cinfo->image_width); + } + } + } + *in_row_ctr += numrows; + prep->next_buf_row += numrows; + prep->rows_to_go -= numrows; + } else { + /* Return for more data, unless we are at the bottom of the image. */ + if (prep->rows_to_go != 0) + break; + /* When at bottom of image, pad to fill the conversion buffer. */ + if (prep->next_buf_row < prep->next_buf_stop) { + for (ci = 0; ci < cinfo->num_components; ci++) { + expand_bottom_edge(prep->color_buf[ci], cinfo->image_width, + prep->next_buf_row, prep->next_buf_stop); + } + prep->next_buf_row = prep->next_buf_stop; + } + } + /* If we've gotten enough data, downsample a row group. */ + if (prep->next_buf_row == prep->next_buf_stop) { + (*cinfo->downsample->downsample) (cinfo, + prep->color_buf, + (JDIMENSION) prep->this_row_group, + output_buf, *out_row_group_ctr); + (*out_row_group_ctr)++; + /* Advance pointers with wraparound as necessary. */ + prep->this_row_group += cinfo->max_v_samp_factor; + if (prep->this_row_group >= buf_height) + prep->this_row_group = 0; + if (prep->next_buf_row >= buf_height) + prep->next_buf_row = 0; + prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor; + } + } +} + + +/* + * Create the wrapped-around downsampling input buffer needed for context mode. + */ + +LOCAL(void) +create_context_buffer (j_compress_ptr cinfo) +{ + my_prep_ptr prep = (my_prep_ptr) cinfo->prep; + int rgroup_height = cinfo->max_v_samp_factor; + int ci, i; + jpeg_component_info * compptr; + JSAMPARRAY true_buffer, fake_buffer; + + /* Grab enough space for fake row pointers for all the components; + * we need five row groups' worth of pointers for each component. + */ + fake_buffer = (JSAMPARRAY) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (cinfo->num_components * 5 * rgroup_height) * + SIZEOF(JSAMPROW)); + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Allocate the actual buffer space (3 row groups) for this component. + * We make the buffer wide enough to allow the downsampler to edge-expand + * horizontally within the buffer, if it so chooses. + */ + true_buffer = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE * + cinfo->max_h_samp_factor) / compptr->h_samp_factor), + (JDIMENSION) (3 * rgroup_height)); + /* Copy true buffer row pointers into the middle of the fake row array */ + MEMCOPY(fake_buffer + rgroup_height, true_buffer, + 3 * rgroup_height * SIZEOF(JSAMPROW)); + /* Fill in the above and below wraparound pointers */ + for (i = 0; i < rgroup_height; i++) { + fake_buffer[i] = true_buffer[2 * rgroup_height + i]; + fake_buffer[4 * rgroup_height + i] = true_buffer[i]; + } + prep->color_buf[ci] = fake_buffer + rgroup_height; + fake_buffer += 5 * rgroup_height; /* point to space for next component */ + } +} + +#endif /* CONTEXT_ROWS_SUPPORTED */ + + +/* + * Initialize preprocessing controller. + */ + +GLOBAL(void) +jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer) +{ + my_prep_ptr prep; + int ci; + jpeg_component_info * compptr; + + if (need_full_buffer) /* safety check */ + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + + prep = (my_prep_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_prep_controller)); + cinfo->prep = (struct jpeg_c_prep_controller *) prep; + prep->pub.start_pass = start_pass_prep; + + /* Allocate the color conversion buffer. + * We make the buffer wide enough to allow the downsampler to edge-expand + * horizontally within the buffer, if it so chooses. + */ + if (cinfo->downsample->need_context_rows) { + /* Set up to provide context rows */ +#ifdef CONTEXT_ROWS_SUPPORTED + prep->pub.pre_process_data = pre_process_context; + create_context_buffer(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + /* No context, just make it tall enough for one row group */ + prep->pub.pre_process_data = pre_process_data; + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + prep->color_buf[ci] = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE * + cinfo->max_h_samp_factor) / compptr->h_samp_factor), + (JDIMENSION) cinfo->max_v_samp_factor); + } + } +} diff --git a/TMessagesProj/jni/libjpeg/jcsample.c b/TMessagesProj/jni/libjpeg/jcsample.c new file mode 100755 index 000000000..212ec8757 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jcsample.c @@ -0,0 +1,519 @@ +/* + * jcsample.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains downsampling routines. + * + * Downsampling input data is counted in "row groups". A row group + * is defined to be max_v_samp_factor pixel rows of each component, + * from which the downsampler produces v_samp_factor sample rows. + * A single row group is processed in each call to the downsampler module. + * + * The downsampler is responsible for edge-expansion of its output data + * to fill an integral number of DCT blocks horizontally. The source buffer + * may be modified if it is helpful for this purpose (the source buffer is + * allocated wide enough to correspond to the desired output width). + * The caller (the prep controller) is responsible for vertical padding. + * + * The downsampler may request "context rows" by setting need_context_rows + * during startup. In this case, the input arrays will contain at least + * one row group's worth of pixels above and below the passed-in data; + * the caller will create dummy rows at image top and bottom by replicating + * the first or last real pixel row. + * + * An excellent reference for image resampling is + * Digital Image Warping, George Wolberg, 1990. + * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. + * + * The downsampling algorithm used here is a simple average of the source + * pixels covered by the output pixel. The hi-falutin sampling literature + * refers to this as a "box filter". In general the characteristics of a box + * filter are not very good, but for the specific cases we normally use (1:1 + * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not + * nearly so bad. If you intend to use other sampling ratios, you'd be well + * advised to improve this code. + * + * A simple input-smoothing capability is provided. This is mainly intended + * for cleaning up color-dithered GIF input files (if you find it inadequate, + * we suggest using an external filtering program such as pnmconvol). When + * enabled, each input pixel P is replaced by a weighted sum of itself and its + * eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF, + * where SF = (smoothing_factor / 1024). + * Currently, smoothing is only supported for 2h2v sampling factors. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Pointer to routine to downsample a single component */ +typedef JMETHOD(void, downsample1_ptr, + (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data)); + +/* Private subobject */ + +typedef struct { + struct jpeg_downsampler pub; /* public fields */ + + /* Downsampling method pointers, one per component */ + downsample1_ptr methods[MAX_COMPONENTS]; +} my_downsampler; + +typedef my_downsampler * my_downsample_ptr; + + +/* + * Initialize for a downsampling pass. + */ + +METHODDEF(void) +start_pass_downsample (j_compress_ptr cinfo) +{ + /* no work for now */ +} + + +/* + * Expand a component horizontally from width input_cols to width output_cols, + * by duplicating the rightmost samples. + */ + +LOCAL(void) +expand_right_edge (JSAMPARRAY image_data, int num_rows, + JDIMENSION input_cols, JDIMENSION output_cols) +{ + register JSAMPROW ptr; + register JSAMPLE pixval; + register int count; + int row; + int numcols = (int) (output_cols - input_cols); + + if (numcols > 0) { + for (row = 0; row < num_rows; row++) { + ptr = image_data[row] + input_cols; + pixval = ptr[-1]; /* don't need GETJSAMPLE() here */ + for (count = numcols; count > 0; count--) + *ptr++ = pixval; + } + } +} + + +/* + * Do downsampling for a whole row group (all components). + * + * In this version we simply downsample each component independently. + */ + +METHODDEF(void) +sep_downsample (j_compress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_index, + JSAMPIMAGE output_buf, JDIMENSION out_row_group_index) +{ + my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample; + int ci; + jpeg_component_info * compptr; + JSAMPARRAY in_ptr, out_ptr; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + in_ptr = input_buf[ci] + in_row_index; + out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor); + (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr); + } +} + + +/* + * Downsample pixel values of a single component. + * One row group is processed per call. + * This version handles arbitrary integral sampling ratios, without smoothing. + * Note that this version is not actually used for customary sampling ratios. + */ + +METHODDEF(void) +int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v; + JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */ + JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; + JSAMPROW inptr, outptr; + INT32 outvalue; + + h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor; + v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor; + numpix = h_expand * v_expand; + numpix2 = numpix/2; + + /* Expand input data enough to let all the output samples be generated + * by the standard loop. Special-casing padded output would be more + * efficient. + */ + expand_right_edge(input_data, cinfo->max_v_samp_factor, + cinfo->image_width, output_cols * h_expand); + + inrow = 0; + for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { + outptr = output_data[outrow]; + for (outcol = 0, outcol_h = 0; outcol < output_cols; + outcol++, outcol_h += h_expand) { + outvalue = 0; + for (v = 0; v < v_expand; v++) { + inptr = input_data[inrow+v] + outcol_h; + for (h = 0; h < h_expand; h++) { + outvalue += (INT32) GETJSAMPLE(*inptr++); + } + } + *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix); + } + inrow += v_expand; + } +} + + +/* + * Downsample pixel values of a single component. + * This version handles the special case of a full-size component, + * without smoothing. + */ + +METHODDEF(void) +fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + /* Copy the data */ + jcopy_sample_rows(input_data, 0, output_data, 0, + cinfo->max_v_samp_factor, cinfo->image_width); + /* Edge-expand */ + expand_right_edge(output_data, cinfo->max_v_samp_factor, + cinfo->image_width, compptr->width_in_blocks * DCTSIZE); +} + + +/* + * Downsample pixel values of a single component. + * This version handles the common case of 2:1 horizontal and 1:1 vertical, + * without smoothing. + * + * A note about the "bias" calculations: when rounding fractional values to + * integer, we do not want to always round 0.5 up to the next integer. + * If we did that, we'd introduce a noticeable bias towards larger values. + * Instead, this code is arranged so that 0.5 will be rounded up or down at + * alternate pixel locations (a simple ordered dither pattern). + */ + +METHODDEF(void) +h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + int outrow; + JDIMENSION outcol; + JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; + register JSAMPROW inptr, outptr; + register int bias; + + /* Expand input data enough to let all the output samples be generated + * by the standard loop. Special-casing padded output would be more + * efficient. + */ + expand_right_edge(input_data, cinfo->max_v_samp_factor, + cinfo->image_width, output_cols * 2); + + for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { + outptr = output_data[outrow]; + inptr = input_data[outrow]; + bias = 0; /* bias = 0,1,0,1,... for successive samples */ + for (outcol = 0; outcol < output_cols; outcol++) { + *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1]) + + bias) >> 1); + bias ^= 1; /* 0=>1, 1=>0 */ + inptr += 2; + } + } +} + + +/* + * Downsample pixel values of a single component. + * This version handles the standard case of 2:1 horizontal and 2:1 vertical, + * without smoothing. + */ + +METHODDEF(void) +h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + int inrow, outrow; + JDIMENSION outcol; + JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; + register JSAMPROW inptr0, inptr1, outptr; + register int bias; + + /* Expand input data enough to let all the output samples be generated + * by the standard loop. Special-casing padded output would be more + * efficient. + */ + expand_right_edge(input_data, cinfo->max_v_samp_factor, + cinfo->image_width, output_cols * 2); + + inrow = 0; + for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { + outptr = output_data[outrow]; + inptr0 = input_data[inrow]; + inptr1 = input_data[inrow+1]; + bias = 1; /* bias = 1,2,1,2,... for successive samples */ + for (outcol = 0; outcol < output_cols; outcol++) { + *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]) + + bias) >> 2); + bias ^= 3; /* 1=>2, 2=>1 */ + inptr0 += 2; inptr1 += 2; + } + inrow += 2; + } +} + + +#ifdef INPUT_SMOOTHING_SUPPORTED + +/* + * Downsample pixel values of a single component. + * This version handles the standard case of 2:1 horizontal and 2:1 vertical, + * with smoothing. One row of context is required. + */ + +METHODDEF(void) +h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + int inrow, outrow; + JDIMENSION colctr; + JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; + register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr; + INT32 membersum, neighsum, memberscale, neighscale; + + /* Expand input data enough to let all the output samples be generated + * by the standard loop. Special-casing padded output would be more + * efficient. + */ + expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, + cinfo->image_width, output_cols * 2); + + /* We don't bother to form the individual "smoothed" input pixel values; + * we can directly compute the output which is the average of the four + * smoothed values. Each of the four member pixels contributes a fraction + * (1-8*SF) to its own smoothed image and a fraction SF to each of the three + * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final + * output. The four corner-adjacent neighbor pixels contribute a fraction + * SF to just one smoothed pixel, or SF/4 to the final output; while the + * eight edge-adjacent neighbors contribute SF to each of two smoothed + * pixels, or SF/2 overall. In order to use integer arithmetic, these + * factors are scaled by 2^16 = 65536. + * Also recall that SF = smoothing_factor / 1024. + */ + + memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */ + neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */ + + inrow = 0; + for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { + outptr = output_data[outrow]; + inptr0 = input_data[inrow]; + inptr1 = input_data[inrow+1]; + above_ptr = input_data[inrow-1]; + below_ptr = input_data[inrow+2]; + + /* Special case for first column: pretend column -1 is same as column 0 */ + membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); + neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + + GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) + + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]); + neighsum += neighsum; + neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) + + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]); + membersum = membersum * memberscale + neighsum * neighscale; + *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); + inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; + + for (colctr = output_cols - 2; colctr > 0; colctr--) { + /* sum of pixels directly mapped to this output element */ + membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); + /* sum of edge-neighbor pixels */ + neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + + GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) + + GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]); + /* The edge-neighbors count twice as much as corner-neighbors */ + neighsum += neighsum; + /* Add in the corner-neighbors */ + neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) + + GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]); + /* form final output scaled up by 2^16 */ + membersum = membersum * memberscale + neighsum * neighscale; + /* round, descale and output it */ + *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); + inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; + } + + /* Special case for last column */ + membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); + neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + + GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) + + GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]); + neighsum += neighsum; + neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) + + GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]); + membersum = membersum * memberscale + neighsum * neighscale; + *outptr = (JSAMPLE) ((membersum + 32768) >> 16); + + inrow += 2; + } +} + + +/* + * Downsample pixel values of a single component. + * This version handles the special case of a full-size component, + * with smoothing. One row of context is required. + */ + +METHODDEF(void) +fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ + int outrow; + JDIMENSION colctr; + JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; + register JSAMPROW inptr, above_ptr, below_ptr, outptr; + INT32 membersum, neighsum, memberscale, neighscale; + int colsum, lastcolsum, nextcolsum; + + /* Expand input data enough to let all the output samples be generated + * by the standard loop. Special-casing padded output would be more + * efficient. + */ + expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, + cinfo->image_width, output_cols); + + /* Each of the eight neighbor pixels contributes a fraction SF to the + * smoothed pixel, while the main pixel contributes (1-8*SF). In order + * to use integer arithmetic, these factors are multiplied by 2^16 = 65536. + * Also recall that SF = smoothing_factor / 1024. + */ + + memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */ + neighscale = cinfo->smoothing_factor * 64; /* scaled SF */ + + for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { + outptr = output_data[outrow]; + inptr = input_data[outrow]; + above_ptr = input_data[outrow-1]; + below_ptr = input_data[outrow+1]; + + /* Special case for first column */ + colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) + + GETJSAMPLE(*inptr); + membersum = GETJSAMPLE(*inptr++); + nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + + GETJSAMPLE(*inptr); + neighsum = colsum + (colsum - membersum) + nextcolsum; + membersum = membersum * memberscale + neighsum * neighscale; + *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); + lastcolsum = colsum; colsum = nextcolsum; + + for (colctr = output_cols - 2; colctr > 0; colctr--) { + membersum = GETJSAMPLE(*inptr++); + above_ptr++; below_ptr++; + nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + + GETJSAMPLE(*inptr); + neighsum = lastcolsum + (colsum - membersum) + nextcolsum; + membersum = membersum * memberscale + neighsum * neighscale; + *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); + lastcolsum = colsum; colsum = nextcolsum; + } + + /* Special case for last column */ + membersum = GETJSAMPLE(*inptr); + neighsum = lastcolsum + (colsum - membersum) + colsum; + membersum = membersum * memberscale + neighsum * neighscale; + *outptr = (JSAMPLE) ((membersum + 32768) >> 16); + + } +} + +#endif /* INPUT_SMOOTHING_SUPPORTED */ + + +/* + * Module initialization routine for downsampling. + * Note that we must select a routine for each component. + */ + +GLOBAL(void) +jinit_downsampler (j_compress_ptr cinfo) +{ + my_downsample_ptr downsample; + int ci; + jpeg_component_info * compptr; + boolean smoothok = TRUE; + + downsample = (my_downsample_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_downsampler)); + cinfo->downsample = (struct jpeg_downsampler *) downsample; + downsample->pub.start_pass = start_pass_downsample; + downsample->pub.downsample = sep_downsample; + downsample->pub.need_context_rows = FALSE; + + if (cinfo->CCIR601_sampling) + ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); + + /* Verify we can handle the sampling factors, and set up method pointers */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (compptr->h_samp_factor == cinfo->max_h_samp_factor && + compptr->v_samp_factor == cinfo->max_v_samp_factor) { +#ifdef INPUT_SMOOTHING_SUPPORTED + if (cinfo->smoothing_factor) { + downsample->methods[ci] = fullsize_smooth_downsample; + downsample->pub.need_context_rows = TRUE; + } else +#endif + downsample->methods[ci] = fullsize_downsample; + } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && + compptr->v_samp_factor == cinfo->max_v_samp_factor) { + smoothok = FALSE; + downsample->methods[ci] = h2v1_downsample; + } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && + compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) { +#ifdef INPUT_SMOOTHING_SUPPORTED + if (cinfo->smoothing_factor) { + downsample->methods[ci] = h2v2_smooth_downsample; + downsample->pub.need_context_rows = TRUE; + } else +#endif + downsample->methods[ci] = h2v2_downsample; + } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 && + (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) { + smoothok = FALSE; + downsample->methods[ci] = int_downsample; + } else + ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); + } + +#ifdef INPUT_SMOOTHING_SUPPORTED + if (cinfo->smoothing_factor && !smoothok) + TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL); +#endif +} diff --git a/TMessagesProj/jni/libjpeg/jctrans.c b/TMessagesProj/jni/libjpeg/jctrans.c new file mode 100755 index 000000000..0e6d70769 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jctrans.c @@ -0,0 +1,388 @@ +/* + * jctrans.c + * + * Copyright (C) 1995-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains library routines for transcoding compression, + * that is, writing raw DCT coefficient arrays to an output JPEG file. + * The routines in jcapimin.c will also be needed by a transcoder. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Forward declarations */ +LOCAL(void) transencode_master_selection + JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); +LOCAL(void) transencode_coef_controller + JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); + + +/* + * Compression initialization for writing raw-coefficient data. + * Before calling this, all parameters and a data destination must be set up. + * Call jpeg_finish_compress() to actually write the data. + * + * The number of passed virtual arrays must match cinfo->num_components. + * Note that the virtual arrays need not be filled or even realized at + * the time write_coefficients is called; indeed, if the virtual arrays + * were requested from this compression object's memory manager, they + * typically will be realized during this routine and filled afterwards. + */ + +GLOBAL(void) +jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays) +{ + if (cinfo->global_state != CSTATE_START) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + /* Mark all tables to be written */ + jpeg_suppress_tables(cinfo, FALSE); + /* (Re)initialize error mgr and destination modules */ + (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); + (*cinfo->dest->init_destination) (cinfo); + /* Perform master selection of active modules */ + transencode_master_selection(cinfo, coef_arrays); + /* Wait for jpeg_finish_compress() call */ + cinfo->next_scanline = 0; /* so jpeg_write_marker works */ + cinfo->global_state = CSTATE_WRCOEFS; +} + + +/* + * Initialize the compression object with default parameters, + * then copy from the source object all parameters needed for lossless + * transcoding. Parameters that can be varied without loss (such as + * scan script and Huffman optimization) are left in their default states. + */ + +GLOBAL(void) +jpeg_copy_critical_parameters (j_decompress_ptr srcinfo, + j_compress_ptr dstinfo) +{ + JQUANT_TBL ** qtblptr; + jpeg_component_info *incomp, *outcomp; + JQUANT_TBL *c_quant, *slot_quant; + int tblno, ci, coefi; + + /* Safety check to ensure start_compress not called yet. */ + if (dstinfo->global_state != CSTATE_START) + ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state); + /* Copy fundamental image dimensions */ + dstinfo->image_width = srcinfo->image_width; + dstinfo->image_height = srcinfo->image_height; + dstinfo->input_components = srcinfo->num_components; + dstinfo->in_color_space = srcinfo->jpeg_color_space; + /* Initialize all parameters to default values */ + jpeg_set_defaults(dstinfo); + /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB. + * Fix it to get the right header markers for the image colorspace. + */ + jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space); + dstinfo->data_precision = srcinfo->data_precision; + dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling; + /* Copy the source's quantization tables. */ + for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) { + if (srcinfo->quant_tbl_ptrs[tblno] != NULL) { + qtblptr = & dstinfo->quant_tbl_ptrs[tblno]; + if (*qtblptr == NULL) + *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo); + MEMCOPY((*qtblptr)->quantval, + srcinfo->quant_tbl_ptrs[tblno]->quantval, + SIZEOF((*qtblptr)->quantval)); + (*qtblptr)->sent_table = FALSE; + } + } + /* Copy the source's per-component info. + * Note we assume jpeg_set_defaults has allocated the dest comp_info array. + */ + dstinfo->num_components = srcinfo->num_components; + if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS) + ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components, + MAX_COMPONENTS); + for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info; + ci < dstinfo->num_components; ci++, incomp++, outcomp++) { + outcomp->component_id = incomp->component_id; + outcomp->h_samp_factor = incomp->h_samp_factor; + outcomp->v_samp_factor = incomp->v_samp_factor; + outcomp->quant_tbl_no = incomp->quant_tbl_no; + /* Make sure saved quantization table for component matches the qtable + * slot. If not, the input file re-used this qtable slot. + * IJG encoder currently cannot duplicate this. + */ + tblno = outcomp->quant_tbl_no; + if (tblno < 0 || tblno >= NUM_QUANT_TBLS || + srcinfo->quant_tbl_ptrs[tblno] == NULL) + ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno); + slot_quant = srcinfo->quant_tbl_ptrs[tblno]; + c_quant = incomp->quant_table; + if (c_quant != NULL) { + for (coefi = 0; coefi < DCTSIZE2; coefi++) { + if (c_quant->quantval[coefi] != slot_quant->quantval[coefi]) + ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno); + } + } + /* Note: we do not copy the source's Huffman table assignments; + * instead we rely on jpeg_set_colorspace to have made a suitable choice. + */ + } + /* Also copy JFIF version and resolution information, if available. + * Strictly speaking this isn't "critical" info, but it's nearly + * always appropriate to copy it if available. In particular, + * if the application chooses to copy JFIF 1.02 extension markers from + * the source file, we need to copy the version to make sure we don't + * emit a file that has 1.02 extensions but a claimed version of 1.01. + * We will *not*, however, copy version info from mislabeled "2.01" files. + */ + if (srcinfo->saw_JFIF_marker) { + if (srcinfo->JFIF_major_version == 1) { + dstinfo->JFIF_major_version = srcinfo->JFIF_major_version; + dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version; + } + dstinfo->density_unit = srcinfo->density_unit; + dstinfo->X_density = srcinfo->X_density; + dstinfo->Y_density = srcinfo->Y_density; + } +} + + +/* + * Master selection of compression modules for transcoding. + * This substitutes for jcinit.c's initialization of the full compressor. + */ + +LOCAL(void) +transencode_master_selection (j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays) +{ + /* Although we don't actually use input_components for transcoding, + * jcmaster.c's initial_setup will complain if input_components is 0. + */ + cinfo->input_components = 1; + /* Initialize master control (includes parameter checking/processing) */ + jinit_c_master_control(cinfo, TRUE /* transcode only */); + + /* Entropy encoding: either Huffman or arithmetic coding. */ + if (cinfo->arith_code) { + ERREXIT(cinfo, JERR_ARITH_NOTIMPL); + } else { + if (cinfo->progressive_mode) { +#ifdef C_PROGRESSIVE_SUPPORTED + jinit_phuff_encoder(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else + jinit_huff_encoder(cinfo); + } + + /* We need a special coefficient buffer controller. */ + transencode_coef_controller(cinfo, coef_arrays); + + jinit_marker_writer(cinfo); + + /* We can now tell the memory manager to allocate virtual arrays. */ + (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); + + /* Write the datastream header (SOI, JFIF) immediately. + * Frame and scan headers are postponed till later. + * This lets application insert special markers after the SOI. + */ + (*cinfo->marker->write_file_header) (cinfo); +} + + +/* + * The rest of this file is a special implementation of the coefficient + * buffer controller. This is similar to jccoefct.c, but it handles only + * output from presupplied virtual arrays. Furthermore, we generate any + * dummy padding blocks on-the-fly rather than expecting them to be present + * in the arrays. + */ + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_c_coef_controller pub; /* public fields */ + + JDIMENSION iMCU_row_num; /* iMCU row # within image */ + JDIMENSION mcu_ctr; /* counts MCUs processed in current row */ + int MCU_vert_offset; /* counts MCU rows within iMCU row */ + int MCU_rows_per_iMCU_row; /* number of such rows needed */ + + /* Virtual block array for each component. */ + jvirt_barray_ptr * whole_image; + + /* Workspace for constructing dummy blocks at right/bottom edges. */ + JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU]; +} my_coef_controller; + +typedef my_coef_controller * my_coef_ptr; + + +LOCAL(void) +start_iMCU_row (j_compress_ptr cinfo) +/* Reset within-iMCU-row counters for a new row */ +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + /* In an interleaved scan, an MCU row is the same as an iMCU row. + * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. + * But at the bottom of the image, process only what's left. + */ + if (cinfo->comps_in_scan > 1) { + coef->MCU_rows_per_iMCU_row = 1; + } else { + if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1)) + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; + else + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; + } + + coef->mcu_ctr = 0; + coef->MCU_vert_offset = 0; +} + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + if (pass_mode != JBUF_CRANK_DEST) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + + coef->iMCU_row_num = 0; + start_iMCU_row(cinfo); +} + + +/* + * Process some data. + * We process the equivalent of one fully interleaved MCU row ("iMCU" row) + * per call, ie, v_samp_factor block rows for each component in the scan. + * The data is obtained from the virtual arrays and fed to the entropy coder. + * Returns TRUE if the iMCU row is completed, FALSE if suspended. + * + * NB: input_buf is ignored; it is likely to be a NULL pointer. + */ + +METHODDEF(boolean) +compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + int blkn, ci, xindex, yindex, yoffset, blockcnt; + JDIMENSION start_col; + JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; + JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU]; + JBLOCKROW buffer_ptr; + jpeg_component_info *compptr; + + /* Align the virtual buffers for the components used in this scan. */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + buffer[ci] = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], + coef->iMCU_row_num * compptr->v_samp_factor, + (JDIMENSION) compptr->v_samp_factor, FALSE); + } + + /* Loop to process one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row; + MCU_col_num++) { + /* Construct list of pointers to DCT blocks belonging to this MCU */ + blkn = 0; /* index of current DCT block within MCU */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + start_col = MCU_col_num * compptr->MCU_width; + blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width + : compptr->last_col_width; + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + if (coef->iMCU_row_num < last_iMCU_row || + yindex+yoffset < compptr->last_row_height) { + /* Fill in pointers to real blocks in this row */ + buffer_ptr = buffer[ci][yindex+yoffset] + start_col; + for (xindex = 0; xindex < blockcnt; xindex++) + MCU_buffer[blkn++] = buffer_ptr++; + } else { + /* At bottom of image, need a whole row of dummy blocks */ + xindex = 0; + } + /* Fill in any dummy blocks needed in this row. + * Dummy blocks are filled in the same way as in jccoefct.c: + * all zeroes in the AC entries, DC entries equal to previous + * block's DC value. The init routine has already zeroed the + * AC entries, so we need only set the DC entries correctly. + */ + for (; xindex < compptr->MCU_width; xindex++) { + MCU_buffer[blkn] = coef->dummy_buffer[blkn]; + MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0]; + blkn++; + } + } + } + /* Try to write the MCU. */ + if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->mcu_ctr = MCU_col_num; + return FALSE; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->mcu_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + coef->iMCU_row_num++; + start_iMCU_row(cinfo); + return TRUE; +} + + +/* + * Initialize coefficient buffer controller. + * + * Each passed coefficient array must be the right size for that + * coefficient: width_in_blocks wide and height_in_blocks high, + * with unitheight at least v_samp_factor. + */ + +LOCAL(void) +transencode_coef_controller (j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays) +{ + my_coef_ptr coef; + JBLOCKROW buffer; + int i; + + coef = (my_coef_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_coef_controller)); + cinfo->coef = (struct jpeg_c_coef_controller *) coef; + coef->pub.start_pass = start_pass_coef; + coef->pub.compress_data = compress_output; + + /* Save pointer to virtual arrays */ + coef->whole_image = coef_arrays; + + /* Allocate and pre-zero space for dummy DCT blocks. */ + buffer = (JBLOCKROW) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); + jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); + for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) { + coef->dummy_buffer[i] = buffer + i; + } +} diff --git a/TMessagesProj/jni/libjpeg/jdapimin.c b/TMessagesProj/jni/libjpeg/jdapimin.c new file mode 100755 index 000000000..5c9607ed5 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdapimin.c @@ -0,0 +1,401 @@ +/* + * jdapimin.c + * + * Copyright (C) 1994-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains application interface code for the decompression half + * of the JPEG library. These are the "minimum" API routines that may be + * needed in either the normal full-decompression case or the + * transcoding-only case. + * + * Most of the routines intended to be called directly by an application + * are in this file or in jdapistd.c. But also see jcomapi.c for routines + * shared by compression and decompression, and jdtrans.c for the transcoding + * case. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * Initialization of a JPEG decompression object. + * The error manager must already be set up (in case memory manager fails). + */ + +GLOBAL(void) +jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize) +{ + int i; + + /* Guard against version mismatches between library and caller. */ + cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */ + if (version != JPEG_LIB_VERSION) + ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version); + if (structsize != SIZEOF(struct jpeg_decompress_struct)) + ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, + (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize); + + /* For debugging purposes, we zero the whole master structure. + * But the application has already set the err pointer, and may have set + * client_data, so we have to save and restore those fields. + * Note: if application hasn't set client_data, tools like Purify may + * complain here. + */ + { + struct jpeg_error_mgr * err = cinfo->err; + void * client_data = cinfo->client_data; /* ignore Purify complaint here */ + MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct)); + cinfo->err = err; + cinfo->client_data = client_data; + } + cinfo->is_decompressor = TRUE; + cinfo->tile_decode = FALSE; + + /* Initialize a memory manager instance for this object */ + jinit_memory_mgr((j_common_ptr) cinfo); + + /* Zero out pointers to permanent structures. */ + cinfo->progress = NULL; + cinfo->src = NULL; + + for (i = 0; i < NUM_QUANT_TBLS; i++) + cinfo->quant_tbl_ptrs[i] = NULL; + + for (i = 0; i < NUM_HUFF_TBLS; i++) { + cinfo->dc_huff_tbl_ptrs[i] = NULL; + cinfo->ac_huff_tbl_ptrs[i] = NULL; + } + + /* Initialize marker processor so application can override methods + * for COM, APPn markers before calling jpeg_read_header. + */ + cinfo->marker_list = NULL; + jinit_marker_reader(cinfo); + + /* And initialize the overall input controller. */ + jinit_input_controller(cinfo); + + /* OK, I'm ready */ + cinfo->global_state = DSTATE_START; +} + + +/* + * Destruction of a JPEG decompression object + */ + +GLOBAL(void) +jpeg_destroy_decompress (j_decompress_ptr cinfo) +{ + jpeg_destroy((j_common_ptr) cinfo); /* use common routine */ +} + + +/* + * Abort processing of a JPEG decompression operation, + * but don't destroy the object itself. + */ + +GLOBAL(void) +jpeg_abort_decompress (j_decompress_ptr cinfo) +{ + jpeg_abort((j_common_ptr) cinfo); /* use common routine */ +} + + +/* + * Set default decompression parameters. + */ + +LOCAL(void) +default_decompress_parms (j_decompress_ptr cinfo) +{ + /* Guess the input colorspace, and set output colorspace accordingly. */ + /* (Wish JPEG committee had provided a real way to specify this...) */ + /* Note application may override our guesses. */ + switch (cinfo->num_components) { + case 1: + cinfo->jpeg_color_space = JCS_GRAYSCALE; + cinfo->out_color_space = JCS_GRAYSCALE; + break; + + case 3: + if (cinfo->saw_JFIF_marker) { + cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */ + } else if (cinfo->saw_Adobe_marker) { + switch (cinfo->Adobe_transform) { + case 0: + cinfo->jpeg_color_space = JCS_RGB; + break; + case 1: + cinfo->jpeg_color_space = JCS_YCbCr; + break; + default: + WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); + cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ + break; + } + } else { + /* Saw no special markers, try to guess from the component IDs */ + int cid0 = cinfo->comp_info[0].component_id; + int cid1 = cinfo->comp_info[1].component_id; + int cid2 = cinfo->comp_info[2].component_id; + + if (cid0 == 1 && cid1 == 2 && cid2 == 3) + cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */ + else if (cid0 == 82 && cid1 == 71 && cid2 == 66) + cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */ + else { + TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2); + cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ + } + } + /* Always guess RGB is proper output colorspace. */ + cinfo->out_color_space = JCS_RGB; + break; + + case 4: + if (cinfo->saw_Adobe_marker) { + switch (cinfo->Adobe_transform) { + case 0: + cinfo->jpeg_color_space = JCS_CMYK; + break; + case 2: + cinfo->jpeg_color_space = JCS_YCCK; + break; + default: + WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); + cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */ + break; + } + } else { + /* No special markers, assume straight CMYK. */ + cinfo->jpeg_color_space = JCS_CMYK; + } + cinfo->out_color_space = JCS_CMYK; + break; + + default: + cinfo->jpeg_color_space = JCS_UNKNOWN; + cinfo->out_color_space = JCS_UNKNOWN; + break; + } + + /* Set defaults for other decompression parameters. */ + cinfo->scale_num = 1; /* 1:1 scaling */ + cinfo->scale_denom = 1; + cinfo->output_gamma = 1.0; + cinfo->buffered_image = FALSE; + cinfo->raw_data_out = FALSE; + cinfo->dct_method = JDCT_DEFAULT; + cinfo->do_fancy_upsampling = TRUE; + cinfo->do_block_smoothing = TRUE; + cinfo->quantize_colors = FALSE; + /* We set these in case application only sets quantize_colors. */ + cinfo->dither_mode = JDITHER_FS; +#ifdef QUANT_2PASS_SUPPORTED + cinfo->two_pass_quantize = TRUE; +#else + cinfo->two_pass_quantize = FALSE; +#endif + cinfo->desired_number_of_colors = 256; + cinfo->colormap = NULL; + /* Initialize for no mode change in buffered-image mode. */ + cinfo->enable_1pass_quant = FALSE; + cinfo->enable_external_quant = FALSE; + cinfo->enable_2pass_quant = FALSE; +} + + +/* + * Decompression startup: read start of JPEG datastream to see what's there. + * Need only initialize JPEG object and supply a data source before calling. + * + * This routine will read as far as the first SOS marker (ie, actual start of + * compressed data), and will save all tables and parameters in the JPEG + * object. It will also initialize the decompression parameters to default + * values, and finally return JPEG_HEADER_OK. On return, the application may + * adjust the decompression parameters and then call jpeg_start_decompress. + * (Or, if the application only wanted to determine the image parameters, + * the data need not be decompressed. In that case, call jpeg_abort or + * jpeg_destroy to release any temporary space.) + * If an abbreviated (tables only) datastream is presented, the routine will + * return JPEG_HEADER_TABLES_ONLY upon reaching EOI. The application may then + * re-use the JPEG object to read the abbreviated image datastream(s). + * It is unnecessary (but OK) to call jpeg_abort in this case. + * The JPEG_SUSPENDED return code only occurs if the data source module + * requests suspension of the decompressor. In this case the application + * should load more source data and then re-call jpeg_read_header to resume + * processing. + * If a non-suspending data source is used and require_image is TRUE, then the + * return code need not be inspected since only JPEG_HEADER_OK is possible. + * + * This routine is now just a front end to jpeg_consume_input, with some + * extra error checking. + */ + +GLOBAL(int) +jpeg_read_header (j_decompress_ptr cinfo, boolean require_image) +{ + int retcode; + + if (cinfo->global_state != DSTATE_START && + cinfo->global_state != DSTATE_INHEADER) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + retcode = jpeg_consume_input(cinfo); + + switch (retcode) { + case JPEG_REACHED_SOS: + retcode = JPEG_HEADER_OK; + break; + case JPEG_REACHED_EOI: + if (require_image) /* Complain if application wanted an image */ + ERREXIT(cinfo, JERR_NO_IMAGE); + /* Reset to start state; it would be safer to require the application to + * call jpeg_abort, but we can't change it now for compatibility reasons. + * A side effect is to free any temporary memory (there shouldn't be any). + */ + jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */ + retcode = JPEG_HEADER_TABLES_ONLY; + break; + case JPEG_SUSPENDED: + /* no work */ + break; + } + + return retcode; +} + + +/* + * Consume data in advance of what the decompressor requires. + * This can be called at any time once the decompressor object has + * been created and a data source has been set up. + * + * This routine is essentially a state machine that handles a couple + * of critical state-transition actions, namely initial setup and + * transition from header scanning to ready-for-start_decompress. + * All the actual input is done via the input controller's consume_input + * method. + */ + +GLOBAL(int) +jpeg_consume_input (j_decompress_ptr cinfo) +{ + int retcode = JPEG_SUSPENDED; + + /* NB: every possible DSTATE value should be listed in this switch */ + switch (cinfo->global_state) { + case DSTATE_START: + /* Start-of-datastream actions: reset appropriate modules */ + (*cinfo->inputctl->reset_input_controller) (cinfo); + /* Initialize application's data source module */ + (*cinfo->src->init_source) (cinfo); + cinfo->global_state = DSTATE_INHEADER; + /*FALLTHROUGH*/ + case DSTATE_INHEADER: + retcode = (*cinfo->inputctl->consume_input) (cinfo); + if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */ + /* Set up default parameters based on header data */ + default_decompress_parms(cinfo); + /* Set global state: ready for start_decompress */ + cinfo->global_state = DSTATE_READY; + } + break; + case DSTATE_READY: + /* Can't advance past first SOS until start_decompress is called */ + retcode = JPEG_REACHED_SOS; + break; + case DSTATE_PRELOAD: + case DSTATE_PRESCAN: + case DSTATE_SCANNING: + case DSTATE_RAW_OK: + case DSTATE_BUFIMAGE: + case DSTATE_BUFPOST: + case DSTATE_STOPPING: + retcode = (*cinfo->inputctl->consume_input) (cinfo); + break; + default: + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + } + return retcode; +} + + +/* + * Have we finished reading the input file? + */ + +GLOBAL(boolean) +jpeg_input_complete (j_decompress_ptr cinfo) +{ + /* Check for valid jpeg object */ + if (cinfo->global_state < DSTATE_START || + cinfo->global_state > DSTATE_STOPPING) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + return cinfo->inputctl->eoi_reached; +} + + +/* + * Is there more than one scan? + */ + +GLOBAL(boolean) +jpeg_has_multiple_scans (j_decompress_ptr cinfo) +{ + /* Only valid after jpeg_read_header completes */ + if (cinfo->global_state < DSTATE_READY || + cinfo->global_state > DSTATE_STOPPING) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + return cinfo->inputctl->has_multiple_scans; +} + + +/* + * Finish JPEG decompression. + * + * This will normally just verify the file trailer and release temp storage. + * + * Returns FALSE if suspended. The return value need be inspected only if + * a suspending data source is used. + */ + +GLOBAL(boolean) +jpeg_finish_decompress (j_decompress_ptr cinfo) +{ + if ((cinfo->global_state == DSTATE_SCANNING || + cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) { + /* Terminate final pass of non-buffered mode */ +#ifdef ANDROID_TILE_BASED_DECODE + cinfo->output_scanline = cinfo->output_height; +#endif + if (cinfo->output_scanline < cinfo->output_height) + ERREXIT(cinfo, JERR_TOO_LITTLE_DATA); + (*cinfo->master->finish_output_pass) (cinfo); + cinfo->global_state = DSTATE_STOPPING; + } else if (cinfo->global_state == DSTATE_BUFIMAGE) { + /* Finishing after a buffered-image operation */ + cinfo->global_state = DSTATE_STOPPING; + } else if (cinfo->global_state != DSTATE_STOPPING) { + /* STOPPING = repeat call after a suspension, anything else is error */ + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + } + /* Read until EOI */ +#ifndef ANDROID_TILE_BASED_DECODE + while (! cinfo->inputctl->eoi_reached) { + if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) + return FALSE; /* Suspend, come back later */ + } +#endif + /* Do final cleanup */ + (*cinfo->src->term_source) (cinfo); + /* We can use jpeg_abort to release memory and reset global_state */ + jpeg_abort((j_common_ptr) cinfo); + return TRUE; +} diff --git a/TMessagesProj/jni/libjpeg/jdapistd.c b/TMessagesProj/jni/libjpeg/jdapistd.c new file mode 100755 index 000000000..e1233df36 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdapistd.c @@ -0,0 +1,397 @@ +/* + * jdapistd.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains application interface code for the decompression half + * of the JPEG library. These are the "standard" API routines that are + * used in the normal full-decompression case. They are not used by a + * transcoding-only application. Note that if an application links in + * jpeg_start_decompress, it will end up linking in the entire decompressor. + * We thus must separate this file from jdapimin.c to avoid linking the + * whole decompression library into a transcoder. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Forward declarations */ +LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo)); + + +/* + * Decompression initialization. + * jpeg_read_header must be completed before calling this. + * + * If a multipass operating mode was selected, this will do all but the + * last pass, and thus may take a great deal of time. + * + * Returns FALSE if suspended. The return value need be inspected only if + * a suspending data source is used. + */ + +GLOBAL(boolean) +jpeg_start_decompress (j_decompress_ptr cinfo) +{ + if (cinfo->global_state == DSTATE_READY) { + /* First call: initialize master control, select active modules */ + jinit_master_decompress(cinfo); + if (cinfo->buffered_image) { + /* No more work here; expecting jpeg_start_output next */ + cinfo->global_state = DSTATE_BUFIMAGE; + return TRUE; + } + cinfo->global_state = DSTATE_PRELOAD; + } + if (cinfo->global_state == DSTATE_PRELOAD) { + /* If file has multiple scans, absorb them all into the coef buffer */ + if (cinfo->inputctl->has_multiple_scans) { +#ifdef D_MULTISCAN_FILES_SUPPORTED + for (;;) { + int retcode; + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + /* Absorb some more input */ + retcode = (*cinfo->inputctl->consume_input) (cinfo); + if (retcode == JPEG_SUSPENDED) + return FALSE; + if (retcode == JPEG_REACHED_EOI) + break; + /* Advance progress counter if appropriate */ + if (cinfo->progress != NULL && + (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { + if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { + /* jdmaster underestimated number of scans; ratchet up one scan */ + cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; + } + } + } +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif /* D_MULTISCAN_FILES_SUPPORTED */ + } + cinfo->output_scan_number = cinfo->input_scan_number; + } else if (cinfo->global_state != DSTATE_PRESCAN) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + /* Perform any dummy output passes, and set up for the final pass */ + return output_pass_setup(cinfo); +} + +/* + * Tile decompression initialization. + * jpeg_read_header must be completed before calling this. + */ + +GLOBAL(boolean) +jpeg_start_tile_decompress (j_decompress_ptr cinfo) +{ + if (cinfo->global_state == DSTATE_READY) { + /* First call: initialize master control, select active modules */ + cinfo->tile_decode = TRUE; + jinit_master_decompress(cinfo); + if (cinfo->buffered_image) { + cinfo->global_state = DSTATE_BUFIMAGE; + return TRUE; + } + cinfo->global_state = DSTATE_PRELOAD; + } + if (cinfo->global_state == DSTATE_PRELOAD) { + cinfo->output_scan_number = cinfo->input_scan_number; + } else if (cinfo->global_state != DSTATE_PRESCAN) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + /* Perform any dummy output passes, and set up for the final pass */ + return output_pass_setup(cinfo); +} + + +/* + * Set up for an output pass, and perform any dummy pass(es) needed. + * Common subroutine for jpeg_start_decompress and jpeg_start_output. + * Entry: global_state = DSTATE_PRESCAN only if previously suspended. + * Exit: If done, returns TRUE and sets global_state for proper output mode. + * If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN. + */ + +LOCAL(boolean) +output_pass_setup (j_decompress_ptr cinfo) +{ + if (cinfo->global_state != DSTATE_PRESCAN) { + /* First call: do pass setup */ + (*cinfo->master->prepare_for_output_pass) (cinfo); + cinfo->output_scanline = 0; + cinfo->global_state = DSTATE_PRESCAN; + } + /* Loop over any required dummy passes */ + while (cinfo->master->is_dummy_pass) { +#ifdef QUANT_2PASS_SUPPORTED + /* Crank through the dummy pass */ + while (cinfo->output_scanline < cinfo->output_height) { + JDIMENSION last_scanline; + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) cinfo->output_scanline; + cinfo->progress->pass_limit = (long) cinfo->output_height; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + /* Process some data */ + last_scanline = cinfo->output_scanline; + (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL, + &cinfo->output_scanline, (JDIMENSION) 0); + if (cinfo->output_scanline == last_scanline) + return FALSE; /* No progress made, must suspend */ + } + /* Finish up dummy pass, and set up for another one */ + (*cinfo->master->finish_output_pass) (cinfo); + (*cinfo->master->prepare_for_output_pass) (cinfo); + cinfo->output_scanline = 0; +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif /* QUANT_2PASS_SUPPORTED */ + } + /* Ready for application to drive output pass through + * jpeg_read_scanlines or jpeg_read_raw_data. + */ + cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING; + return TRUE; +} + + +/* + * Read some scanlines of data from the JPEG decompressor. + * + * The return value will be the number of lines actually read. + * This may be less than the number requested in several cases, + * including bottom of image, data source suspension, and operating + * modes that emit multiple scanlines at a time. + * + * Note: we warn about excess calls to jpeg_read_scanlines() since + * this likely signals an application programmer error. However, + * an oversize buffer (max_lines > scanlines remaining) is not an error. + */ + +GLOBAL(JDIMENSION) +jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines, + JDIMENSION max_lines) +{ + JDIMENSION row_ctr; + + if (cinfo->global_state != DSTATE_SCANNING) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + if (cinfo->output_scanline >= cinfo->output_height) { + WARNMS(cinfo, JWRN_TOO_MUCH_DATA); + return 0; + } + + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) cinfo->output_scanline; + cinfo->progress->pass_limit = (long) cinfo->output_height; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + + /* Process some data */ + row_ctr = 0; + (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines); + cinfo->output_scanline += row_ctr; + return row_ctr; +} +/* + * Initialize the jpeg decoder to decompressing a rectangle with size of (width, height) + * and its upper-left corner located at (start_x, start_y). + * Align start_x and start_y to multiplies of iMCU width and height, respectively. + * Also, the new reader position and sampled image size will be returned in + * (start_x, start_y) and (width, height), respectively. + */ + +GLOBAL(void) +jpeg_init_read_tile_scanline(j_decompress_ptr cinfo, huffman_index *index, + int *start_x, int *start_y, int *width, int *height) +{ + // Calculates the boundary of iMCU + int lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE; + int lines_per_iMCU_col = cinfo->max_h_samp_factor * DCTSIZE; + int row_offset = *start_y / lines_per_iMCU_row; + int col_left_boundary = ((*start_x / lines_per_iMCU_col) + / index->MCU_sample_size) * index->MCU_sample_size; + int col_right_boundary = + jdiv_round_up(*start_x + *width, lines_per_iMCU_col); + + cinfo->coef->MCU_columns_to_skip = + *start_x / lines_per_iMCU_col - col_left_boundary; + + *height = (*start_y - row_offset * lines_per_iMCU_row) + *height; + *start_x = col_left_boundary * lines_per_iMCU_col; + *start_y = row_offset * lines_per_iMCU_row; + cinfo->image_width = jmin(cinfo->original_image_width, + col_right_boundary * lines_per_iMCU_col) - + col_left_boundary * lines_per_iMCU_col; + cinfo->input_iMCU_row = row_offset; + cinfo->output_iMCU_row = row_offset; + + // Updates JPEG decoder parameter + jinit_color_deconverter(cinfo); + jpeg_calc_output_dimensions(cinfo); + jinit_upsampler(cinfo); + (*cinfo->master->prepare_for_output_pass) (cinfo); + if (cinfo->progressive_mode) + (*cinfo->entropy->start_pass) (cinfo); + else + jpeg_decompress_per_scan_setup(cinfo); + + int sample_size = DCTSIZE / cinfo->min_DCT_scaled_size; + + *height = jdiv_round_up(*height, sample_size); + *width = cinfo->output_width; + cinfo->output_scanline = lines_per_iMCU_row * row_offset / sample_size; + cinfo->inputctl->consume_input = cinfo->coef->consume_data; + cinfo->inputctl->consume_input_build_huffman_index = + cinfo->coef->consume_data_build_huffman_index; + cinfo->entropy->index = index; + cinfo->input_iMCU_row = row_offset; + cinfo->output_iMCU_row = row_offset; + cinfo->coef->MCU_column_left_boundary = col_left_boundary; + cinfo->coef->MCU_column_right_boundary = col_right_boundary; + cinfo->coef->column_left_boundary = + col_left_boundary / index->MCU_sample_size; + cinfo->coef->column_right_boundary = + jdiv_round_up(col_right_boundary, index->MCU_sample_size); +} + +/* + * Read a scanline from the current position. + * + * Return the number of lines actually read. + */ + +GLOBAL(JDIMENSION) +jpeg_read_tile_scanline (j_decompress_ptr cinfo, huffman_index *index, + JSAMPARRAY scanlines) +{ + // Calculates the boundary of iMCU + int lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE; + int lines_per_iMCU_col = cinfo->max_h_samp_factor * DCTSIZE; + int sample_size = DCTSIZE / cinfo->min_DCT_scaled_size; + JDIMENSION row_ctr = 0; + + if (cinfo->progressive_mode) { + (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, 1); + } else { + if (cinfo->output_scanline % (lines_per_iMCU_row / sample_size) == 0) { + // Set the read head to the next iMCU row + int iMCU_row_offset = cinfo->output_scanline / + (lines_per_iMCU_row / sample_size); + int offset_data_col_position = cinfo->coef->MCU_column_left_boundary / + index->MCU_sample_size; + huffman_offset_data offset_data = + index->scan[0].offset[iMCU_row_offset][offset_data_col_position]; + (*cinfo->entropy->configure_huffman_decoder) (cinfo, offset_data); + } + (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, 1); + } + + cinfo->output_scanline += row_ctr; + return row_ctr; +} + +/* + * Alternate entry point to read raw data. + * Processes exactly one iMCU row per call, unless suspended. + */ + +GLOBAL(JDIMENSION) +jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION max_lines) +{ + JDIMENSION lines_per_iMCU_row; + + if (cinfo->global_state != DSTATE_RAW_OK) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + if (cinfo->output_scanline >= cinfo->output_height) { + WARNMS(cinfo, JWRN_TOO_MUCH_DATA); + return 0; + } + + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) { + cinfo->progress->pass_counter = (long) cinfo->output_scanline; + cinfo->progress->pass_limit = (long) cinfo->output_height; + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + } + + /* Verify that at least one iMCU row can be returned. */ + lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size; + if (max_lines < lines_per_iMCU_row) + ERREXIT(cinfo, JERR_BUFFER_SIZE); + + /* Decompress directly into user's buffer. */ + if (! (*cinfo->coef->decompress_data) (cinfo, data)) + return 0; /* suspension forced, can do nothing more */ + + /* OK, we processed one iMCU row. */ + cinfo->output_scanline += lines_per_iMCU_row; + return lines_per_iMCU_row; +} + + +/* Additional entry points for buffered-image mode. */ + +#ifdef D_MULTISCAN_FILES_SUPPORTED + +/* + * Initialize for an output pass in buffered-image mode. + */ + +GLOBAL(boolean) +jpeg_start_output (j_decompress_ptr cinfo, int scan_number) +{ + if (cinfo->global_state != DSTATE_BUFIMAGE && + cinfo->global_state != DSTATE_PRESCAN) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + /* Limit scan number to valid range */ + if (scan_number <= 0) + scan_number = 1; + if (cinfo->inputctl->eoi_reached && + scan_number > cinfo->input_scan_number) + scan_number = cinfo->input_scan_number; + cinfo->output_scan_number = scan_number; + /* Perform any dummy output passes, and set up for the real pass */ + return output_pass_setup(cinfo); +} + + +/* + * Finish up after an output pass in buffered-image mode. + * + * Returns FALSE if suspended. The return value need be inspected only if + * a suspending data source is used. + */ + +GLOBAL(boolean) +jpeg_finish_output (j_decompress_ptr cinfo) +{ + if ((cinfo->global_state == DSTATE_SCANNING || + cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) { + /* Terminate this pass. */ + /* We do not require the whole pass to have been completed. */ + (*cinfo->master->finish_output_pass) (cinfo); + cinfo->global_state = DSTATE_BUFPOST; + } else if (cinfo->global_state != DSTATE_BUFPOST) { + /* BUFPOST = repeat call after a suspension, anything else is error */ + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + } + /* Read markers looking for SOS or EOI */ + while (cinfo->input_scan_number <= cinfo->output_scan_number && + ! cinfo->inputctl->eoi_reached) { + if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) + return FALSE; /* Suspend, come back later */ + } + cinfo->global_state = DSTATE_BUFIMAGE; + return TRUE; +} + +#endif /* D_MULTISCAN_FILES_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jdatadst.c b/TMessagesProj/jni/libjpeg/jdatadst.c new file mode 100755 index 000000000..a8f6fb0e0 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdatadst.c @@ -0,0 +1,151 @@ +/* + * jdatadst.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains compression data destination routines for the case of + * emitting JPEG data to a file (or any stdio stream). While these routines + * are sufficient for most applications, some will want to use a different + * destination manager. + * IMPORTANT: we assume that fwrite() will correctly transcribe an array of + * JOCTETs into 8-bit-wide elements on external storage. If char is wider + * than 8 bits on your machine, you may need to do some tweaking. + */ + +/* this is not a core library module, so it doesn't define JPEG_INTERNALS */ +#include "jinclude.h" +#include "jpeglib.h" +#include "jerror.h" + + +/* Expanded data destination object for stdio output */ + +typedef struct { + struct jpeg_destination_mgr pub; /* public fields */ + + FILE * outfile; /* target stream */ + JOCTET * buffer; /* start of buffer */ +} my_destination_mgr; + +typedef my_destination_mgr * my_dest_ptr; + +#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ + + +/* + * Initialize destination --- called by jpeg_start_compress + * before any data is actually written. + */ + +METHODDEF(void) +init_destination (j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr) cinfo->dest; + + /* Allocate the output buffer --- it will be released when done with image */ + dest->buffer = (JOCTET *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + OUTPUT_BUF_SIZE * SIZEOF(JOCTET)); + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; +} + + +/* + * Empty the output buffer --- called whenever buffer fills up. + * + * In typical applications, this should write the entire output buffer + * (ignoring the current state of next_output_byte & free_in_buffer), + * reset the pointer & count to the start of the buffer, and return TRUE + * indicating that the buffer has been dumped. + * + * In applications that need to be able to suspend compression due to output + * overrun, a FALSE return indicates that the buffer cannot be emptied now. + * In this situation, the compressor will return to its caller (possibly with + * an indication that it has not accepted all the supplied scanlines). The + * application should resume compression after it has made more room in the + * output buffer. Note that there are substantial restrictions on the use of + * suspension --- see the documentation. + * + * When suspending, the compressor will back up to a convenient restart point + * (typically the start of the current MCU). next_output_byte & free_in_buffer + * indicate where the restart point will be if the current call returns FALSE. + * Data beyond this point will be regenerated after resumption, so do not + * write it out when emptying the buffer externally. + */ + +METHODDEF(boolean) +empty_output_buffer (j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr) cinfo->dest; + + if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) != + (size_t) OUTPUT_BUF_SIZE) + ERREXIT(cinfo, JERR_FILE_WRITE); + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; + + return TRUE; +} + + +/* + * Terminate destination --- called by jpeg_finish_compress + * after all data has been written. Usually needs to flush buffer. + * + * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding + * application must deal with any cleanup that should happen even + * for error exit. + */ + +METHODDEF(void) +term_destination (j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr) cinfo->dest; + size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; + + /* Write any data remaining in the buffer */ + if (datacount > 0) { + if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount) + ERREXIT(cinfo, JERR_FILE_WRITE); + } + fflush(dest->outfile); + /* Make sure we wrote the output file OK */ + if (ferror(dest->outfile)) + ERREXIT(cinfo, JERR_FILE_WRITE); +} + + +/* + * Prepare for output to a stdio stream. + * The caller must have already opened the stream, and is responsible + * for closing it after finishing compression. + */ + +GLOBAL(void) +jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile) +{ + my_dest_ptr dest; + + /* The destination object is made permanent so that multiple JPEG images + * can be written to the same file without re-executing jpeg_stdio_dest. + * This makes it dangerous to use this manager and a different destination + * manager serially with the same JPEG object, because their private object + * sizes may be different. Caveat programmer. + */ + if (cinfo->dest == NULL) { /* first time for this JPEG object? */ + cinfo->dest = (struct jpeg_destination_mgr *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + SIZEOF(my_destination_mgr)); + } + + dest = (my_dest_ptr) cinfo->dest; + dest->pub.init_destination = init_destination; + dest->pub.empty_output_buffer = empty_output_buffer; + dest->pub.term_destination = term_destination; + dest->outfile = outfile; +} diff --git a/TMessagesProj/jni/libjpeg/jdatasrc.c b/TMessagesProj/jni/libjpeg/jdatasrc.c new file mode 100755 index 000000000..edc752bf5 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdatasrc.c @@ -0,0 +1,212 @@ +/* + * jdatasrc.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains decompression data source routines for the case of + * reading JPEG data from a file (or any stdio stream). While these routines + * are sufficient for most applications, some will want to use a different + * source manager. + * IMPORTANT: we assume that fread() will correctly transcribe an array of + * JOCTETs from 8-bit-wide elements on external storage. If char is wider + * than 8 bits on your machine, you may need to do some tweaking. + */ + +/* this is not a core library module, so it doesn't define JPEG_INTERNALS */ +#include "jinclude.h" +#include "jpeglib.h" +#include "jerror.h" + + +/* Expanded data source object for stdio input */ + +typedef struct { + struct jpeg_source_mgr pub; /* public fields */ + + FILE * infile; /* source stream */ + JOCTET * buffer; /* start of buffer */ + boolean start_of_file; /* have we gotten any data yet? */ +} my_source_mgr; + +typedef my_source_mgr * my_src_ptr; + +#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ + + +/* + * Initialize source --- called by jpeg_read_header + * before any data is actually read. + */ + +METHODDEF(void) +init_source (j_decompress_ptr cinfo) +{ + my_src_ptr src = (my_src_ptr) cinfo->src; + + /* We reset the empty-input-file flag for each image, + * but we don't clear the input buffer. + * This is correct behavior for reading a series of images from one source. + */ + src->start_of_file = TRUE; +} + + +/* + * Fill the input buffer --- called whenever buffer is emptied. + * + * In typical applications, this should read fresh data into the buffer + * (ignoring the current state of next_input_byte & bytes_in_buffer), + * reset the pointer & count to the start of the buffer, and return TRUE + * indicating that the buffer has been reloaded. It is not necessary to + * fill the buffer entirely, only to obtain at least one more byte. + * + * There is no such thing as an EOF return. If the end of the file has been + * reached, the routine has a choice of ERREXIT() or inserting fake data into + * the buffer. In most cases, generating a warning message and inserting a + * fake EOI marker is the best course of action --- this will allow the + * decompressor to output however much of the image is there. However, + * the resulting error message is misleading if the real problem is an empty + * input file, so we handle that case specially. + * + * In applications that need to be able to suspend compression due to input + * not being available yet, a FALSE return indicates that no more data can be + * obtained right now, but more may be forthcoming later. In this situation, + * the decompressor will return to its caller (with an indication of the + * number of scanlines it has read, if any). The application should resume + * decompression after it has loaded more data into the input buffer. Note + * that there are substantial restrictions on the use of suspension --- see + * the documentation. + * + * When suspending, the decompressor will back up to a convenient restart point + * (typically the start of the current MCU). next_input_byte & bytes_in_buffer + * indicate where the restart point will be if the current call returns FALSE. + * Data beyond this point must be rescanned after resumption, so move it to + * the front of the buffer rather than discarding it. + */ + +METHODDEF(boolean) +fill_input_buffer (j_decompress_ptr cinfo) +{ + my_src_ptr src = (my_src_ptr) cinfo->src; + size_t nbytes; + + nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE); + + if (nbytes <= 0) { + if (src->start_of_file) /* Treat empty input file as fatal error */ + ERREXIT(cinfo, JERR_INPUT_EMPTY); + WARNMS(cinfo, JWRN_JPEG_EOF); + /* Insert a fake EOI marker */ + src->buffer[0] = (JOCTET) 0xFF; + src->buffer[1] = (JOCTET) JPEG_EOI; + nbytes = 2; + } + + src->pub.next_input_byte = src->buffer; + src->pub.bytes_in_buffer = nbytes; + src->start_of_file = FALSE; + + return TRUE; +} + + +/* + * Skip data --- used to skip over a potentially large amount of + * uninteresting data (such as an APPn marker). + * + * Writers of suspendable-input applications must note that skip_input_data + * is not granted the right to give a suspension return. If the skip extends + * beyond the data currently in the buffer, the buffer can be marked empty so + * that the next read will cause a fill_input_buffer call that can suspend. + * Arranging for additional bytes to be discarded before reloading the input + * buffer is the application writer's problem. + */ + +METHODDEF(void) +skip_input_data (j_decompress_ptr cinfo, long num_bytes) +{ + my_src_ptr src = (my_src_ptr) cinfo->src; + + /* Just a dumb implementation for now. Could use fseek() except + * it doesn't work on pipes. Not clear that being smart is worth + * any trouble anyway --- large skips are infrequent. + */ + if (num_bytes > 0) { + while (num_bytes > (long) src->pub.bytes_in_buffer) { + num_bytes -= (long) src->pub.bytes_in_buffer; + (void) fill_input_buffer(cinfo); + /* note we assume that fill_input_buffer will never return FALSE, + * so suspension need not be handled. + */ + } + src->pub.next_input_byte += (size_t) num_bytes; + src->pub.bytes_in_buffer -= (size_t) num_bytes; + } +} + + +/* + * An additional method that can be provided by data source modules is the + * resync_to_restart method for error recovery in the presence of RST markers. + * For the moment, this source module just uses the default resync method + * provided by the JPEG library. That method assumes that no backtracking + * is possible. + */ + + +/* + * Terminate source --- called by jpeg_finish_decompress + * after all data has been read. Often a no-op. + * + * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding + * application must deal with any cleanup that should happen even + * for error exit. + */ + +METHODDEF(void) +term_source (j_decompress_ptr cinfo) +{ + /* no work necessary here */ +} + + +/* + * Prepare for input from a stdio stream. + * The caller must have already opened the stream, and is responsible + * for closing it after finishing decompression. + */ + +GLOBAL(void) +jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile) +{ + my_src_ptr src; + + /* The source object and input buffer are made permanent so that a series + * of JPEG images can be read from the same file by calling jpeg_stdio_src + * only before the first one. (If we discarded the buffer at the end of + * one image, we'd likely lose the start of the next one.) + * This makes it unsafe to use this manager and a different source + * manager serially with the same JPEG object. Caveat programmer. + */ + if (cinfo->src == NULL) { /* first time for this JPEG object? */ + cinfo->src = (struct jpeg_source_mgr *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + SIZEOF(my_source_mgr)); + src = (my_src_ptr) cinfo->src; + src->buffer = (JOCTET *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + INPUT_BUF_SIZE * SIZEOF(JOCTET)); + } + + src = (my_src_ptr) cinfo->src; + src->pub.init_source = init_source; + src->pub.fill_input_buffer = fill_input_buffer; + src->pub.skip_input_data = skip_input_data; + src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ + src->pub.term_source = term_source; + src->infile = infile; + src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ + src->pub.next_input_byte = NULL; /* until buffer loaded */ +} diff --git a/TMessagesProj/jni/libjpeg/jdcoefct.c b/TMessagesProj/jni/libjpeg/jdcoefct.c new file mode 100755 index 000000000..e6e95062c --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdcoefct.c @@ -0,0 +1,1038 @@ +/* + * jdcoefct.c + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the coefficient buffer controller for decompression. + * This controller is the top level of the JPEG decompressor proper. + * The coefficient buffer lies between entropy decoding and inverse-DCT steps. + * + * In buffered-image mode, this controller is the interface between + * input-oriented processing and output-oriented processing. + * Also, the input side (only) is used when reading a file for transcoding. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + +/* Block smoothing is only applicable for progressive JPEG, so: */ +#ifndef D_PROGRESSIVE_SUPPORTED +#undef BLOCK_SMOOTHING_SUPPORTED +#endif + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_d_coef_controller pub; /* public fields */ + + /* These variables keep track of the current location of the input side. */ + /* cinfo->input_iMCU_row is also used for this. */ + JDIMENSION MCU_ctr; /* counts MCUs processed in current row */ + int MCU_vert_offset; /* counts MCU rows within iMCU row */ + int MCU_rows_per_iMCU_row; /* number of such rows needed */ + + /* The output side's location is represented by cinfo->output_iMCU_row. */ + + /* In single-pass modes, it's sufficient to buffer just one MCU. + * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks, + * and let the entropy decoder write into that workspace each time. + * (On 80x86, the workspace is FAR even though it's not really very big; + * this is to keep the module interfaces unchanged when a large coefficient + * buffer is necessary.) + * In multi-pass modes, this array points to the current MCU's blocks + * within the virtual arrays; it is used only by the input side. + */ + JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU]; + +#ifdef D_MULTISCAN_FILES_SUPPORTED + /* In multi-pass modes, we need a virtual block array for each component. */ + jvirt_barray_ptr whole_image[MAX_COMPONENTS]; +#endif + +#ifdef BLOCK_SMOOTHING_SUPPORTED + /* When doing block smoothing, we latch coefficient Al values here */ + int * coef_bits_latch; +#define SAVED_COEFS 6 /* we save coef_bits[0..5] */ +#endif +} my_coef_controller; + +typedef my_coef_controller * my_coef_ptr; + +/* Forward declarations */ +METHODDEF(int) decompress_onepass + JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); +#ifdef D_MULTISCAN_FILES_SUPPORTED +METHODDEF(int) decompress_data + JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); +#endif +#ifdef BLOCK_SMOOTHING_SUPPORTED +LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo)); +METHODDEF(int) decompress_smooth_data + JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); +#endif + + +LOCAL(void) +start_iMCU_row (j_decompress_ptr cinfo) +/* Reset within-iMCU-row counters for a new row (input side) */ +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + /* In an interleaved scan, an MCU row is the same as an iMCU row. + * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. + * But at the bottom of the image, process only what's left. + */ + if (cinfo->comps_in_scan > 1) { + coef->MCU_rows_per_iMCU_row = 1; + } else { + if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1)) + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; + else + coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; + } + + coef->MCU_ctr = 0; + coef->MCU_vert_offset = 0; +} + + +/* + * Initialize for an input processing pass. + */ + +METHODDEF(void) +start_input_pass (j_decompress_ptr cinfo) +{ + cinfo->input_iMCU_row = 0; + start_iMCU_row(cinfo); +} + + +/* + * Initialize for an output processing pass. + */ + +METHODDEF(void) +start_output_pass (j_decompress_ptr cinfo) +{ +#ifdef BLOCK_SMOOTHING_SUPPORTED + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + + /* If multipass, check to see whether to use block smoothing on this pass */ + if (coef->pub.coef_arrays != NULL) { + if (cinfo->do_block_smoothing && smoothing_ok(cinfo)) + coef->pub.decompress_data = decompress_smooth_data; + else + coef->pub.decompress_data = decompress_data; + } +#endif + cinfo->output_iMCU_row = 0; +} + + +/* + * Decompress and return some data in the single-pass case. + * Always attempts to emit one fully interleaved MCU row ("iMCU" row). + * Input and output must run in lockstep since we have only a one-MCU buffer. + * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. + * + * NB: output_buf contains a plane for each component in image, + * which we index according to the component's SOF position. + */ + +METHODDEF(int) +decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + int blkn, ci, xindex, yindex, yoffset, useful_width; + JSAMPARRAY output_ptr; + JDIMENSION start_col, output_col; + jpeg_component_info *compptr; + inverse_DCT_method_ptr inverse_DCT; + +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + last_MCU_col = + (cinfo->coef->MCU_column_right_boundary - + cinfo->coef->MCU_column_left_boundary) - 1; + } +#endif + + /* Loop to process as much as one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col; + MCU_col_num++) { + /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */ + if (MCU_col_num < coef->pub.MCU_columns_to_skip) { + (*cinfo->entropy->decode_mcu_discard_coef) (cinfo); + continue; + } else { + jzero_far((void FAR *) coef->MCU_buffer[0], + (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK))); + if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->MCU_ctr = MCU_col_num; + return JPEG_SUSPENDED; + } + } + /* Determine where data should go in output_buf and do the IDCT thing. + * We skip dummy blocks at the right and bottom edges (but blkn gets + * incremented past them!). Note the inner loop relies on having + * allocated the MCU_buffer[] blocks sequentially. + */ + blkn = 0; /* index of current DCT block within MCU */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* Don't bother to IDCT an uninteresting component. */ + if (! compptr->component_needed) { + blkn += compptr->MCU_blocks; + continue; + } + inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index]; + useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width + : compptr->last_col_width; + output_ptr = output_buf[compptr->component_index] + + yoffset * compptr->DCT_scaled_size; + start_col = MCU_col_num * compptr->MCU_sample_width; + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + if (cinfo->input_iMCU_row < last_iMCU_row || + yoffset+yindex < compptr->last_row_height) { + output_col = start_col; + for (xindex = 0; xindex < useful_width; xindex++) { + (*inverse_DCT) (cinfo, compptr, + (JCOEFPTR) coef->MCU_buffer[blkn+xindex], + output_ptr, output_col); + output_col += compptr->DCT_scaled_size; + } + } + blkn += compptr->MCU_width; + output_ptr += compptr->DCT_scaled_size; + } + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->MCU_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + cinfo->output_iMCU_row++; + if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { + start_iMCU_row(cinfo); + return JPEG_ROW_COMPLETED; + } + /* Completed the scan */ + (*cinfo->inputctl->finish_input_pass) (cinfo); + return JPEG_SCAN_COMPLETED; +} + + +/* + * Dummy consume-input routine for single-pass operation. + */ + +METHODDEF(int) +dummy_consume_data (j_decompress_ptr cinfo) +{ + return JPEG_SUSPENDED; /* Always indicate nothing was done */ +} + +#ifdef D_MULTISCAN_FILES_SUPPORTED +/* + * Consume input data and store it in the full-image coefficient buffer. + * We read as much as one fully interleaved MCU row ("iMCU" row) per call, + * ie, v_samp_factor block rows for each component in the scan. + * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. + */ + +METHODDEF(int) +consume_data (j_decompress_ptr cinfo) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + int blkn, ci, xindex, yindex, yoffset; + JDIMENSION start_col; + JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; + JBLOCKROW buffer_ptr; + jpeg_component_info *compptr; + + /* Align the virtual buffers for the components used in this scan. */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + buffer[ci] = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], + cinfo->tile_decode ? 0 : cinfo->input_iMCU_row * compptr->v_samp_factor, + (JDIMENSION) compptr->v_samp_factor, TRUE); + /* Note: entropy decoder expects buffer to be zeroed, + * but this is handled automatically by the memory manager + * because we requested a pre-zeroed array. + */ + } + unsigned int MCUs_per_row = cinfo->MCUs_per_row; +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + int iMCU_width_To_MCU_width; + if (cinfo->comps_in_scan > 1) { + // Interleaved + iMCU_width_To_MCU_width = 1; + } else { + // Non-intervleaved + iMCU_width_To_MCU_width = cinfo->cur_comp_info[0]->h_samp_factor; + } + MCUs_per_row = jmin(MCUs_per_row, + (cinfo->coef->column_right_boundary - cinfo->coef->column_left_boundary) + * cinfo->entropy->index->MCU_sample_size * iMCU_width_To_MCU_width); + } +#endif + + /* Loop to process one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + // configure huffman decoder +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + huffman_scan_header scan_header = + cinfo->entropy->index->scan[cinfo->input_scan_number]; + int col_offset = cinfo->coef->column_left_boundary; + (*cinfo->entropy->configure_huffman_decoder) (cinfo, + scan_header.offset[cinfo->input_iMCU_row] + [col_offset + yoffset * scan_header.MCUs_per_row]); + } +#endif + + // zero all blocks + for (MCU_col_num = coef->MCU_ctr; MCU_col_num < MCUs_per_row; + MCU_col_num++) { + /* Construct list of pointers to DCT blocks belonging to this MCU */ + blkn = 0; /* index of current DCT block within MCU */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + start_col = MCU_col_num * compptr->MCU_width; + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + buffer_ptr = buffer[ci][yindex+yoffset] + start_col; + for (xindex = 0; xindex < compptr->MCU_width; xindex++) { + coef->MCU_buffer[blkn++] = buffer_ptr++; +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode && cinfo->input_scan_number == 0) { + // need to do pre-zero ourselves. + jzero_far((void FAR *) coef->MCU_buffer[blkn-1], + (size_t) (SIZEOF(JBLOCK))); + } +#endif + } + } + } + + + /* Try to fetch the MCU. */ + if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->MCU_ctr = MCU_col_num; + return JPEG_SUSPENDED; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->MCU_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { + start_iMCU_row(cinfo); + return JPEG_ROW_COMPLETED; + } + /* Completed the scan */ + (*cinfo->inputctl->finish_input_pass) (cinfo); + return JPEG_SCAN_COMPLETED; +} + +/* + * Consume input data and store it in the coefficient buffer. + * Read one fully interleaved MCU row ("iMCU" row) per call. + */ + +METHODDEF(int) +consume_data_multi_scan (j_decompress_ptr cinfo) +{ + huffman_index *index = cinfo->entropy->index; + int i, retcode, ci; + int mcu = cinfo->input_iMCU_row; + jinit_phuff_decoder(cinfo); + for (i = 0; i < index->scan_count; i++) { + (*cinfo->inputctl->finish_input_pass) (cinfo); + jset_input_stream_position(cinfo, index->scan[i].bitstream_offset); + cinfo->output_iMCU_row = mcu; + cinfo->unread_marker = 0; + // Consume SOS and DHT headers + retcode = (*cinfo->inputctl->consume_markers) (cinfo, index, i); + cinfo->input_iMCU_row = mcu; + cinfo->input_scan_number = i; + cinfo->entropy->index = index; + // Consume scan block data + consume_data(cinfo); + } + cinfo->input_iMCU_row = mcu + 1; + cinfo->input_scan_number = 0; + cinfo->output_scan_number = 0; + return JPEG_ROW_COMPLETED; +} + +/* + * Same as consume_data, expect for saving the Huffman decode information + * - bitstream offset and DC coefficient to index. + */ + +METHODDEF(int) +consume_data_build_huffman_index_baseline (j_decompress_ptr cinfo, + huffman_index *index, int current_scan) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + int ci, xindex, yindex, yoffset; + JDIMENSION start_col; + JBLOCKROW buffer_ptr; + + huffman_scan_header *scan_header = index->scan + current_scan; + scan_header->MCU_rows_per_iMCU_row = coef->MCU_rows_per_iMCU_row; + + size_t allocate_size = coef->MCU_rows_per_iMCU_row + * jdiv_round_up(cinfo->MCUs_per_row, index->MCU_sample_size) + * sizeof(huffman_offset_data); + scan_header->offset[cinfo->input_iMCU_row] = + (huffman_offset_data*)malloc(allocate_size); + index->mem_used += allocate_size; + + huffman_offset_data *offset_data = scan_header->offset[cinfo->input_iMCU_row]; + + /* Loop to process one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; + MCU_col_num++) { + // Record huffman bit offset + if (MCU_col_num % index->MCU_sample_size == 0) { + (*cinfo->entropy->get_huffman_decoder_configuration) + (cinfo, offset_data); + ++offset_data; + } + + /* Try to fetch the MCU. */ + if (! (*cinfo->entropy->decode_mcu_discard_coef) (cinfo)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->MCU_ctr = MCU_col_num; + return JPEG_SUSPENDED; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->MCU_ctr = 0; + } + /* Completed the iMCU row, advance counters for next one */ + if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { + start_iMCU_row(cinfo); + return JPEG_ROW_COMPLETED; + } + /* Completed the scan */ + (*cinfo->inputctl->finish_input_pass) (cinfo); + return JPEG_SCAN_COMPLETED; +} + +/* + * Same as consume_data, expect for saving the Huffman decode information + * - bitstream offset and DC coefficient to index. + */ + +METHODDEF(int) +consume_data_build_huffman_index_progressive (j_decompress_ptr cinfo, + huffman_index *index, int current_scan) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION MCU_col_num; /* index of current MCU within row */ + int blkn, ci, xindex, yindex, yoffset; + JDIMENSION start_col; + JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; + JBLOCKROW buffer_ptr; + jpeg_component_info *compptr; + + int factor = 4; // maximum factor is 4. + for (ci = 0; ci < cinfo->comps_in_scan; ci++) + factor = jmin(factor, cinfo->cur_comp_info[ci]->h_samp_factor); + + int sample_size = index->MCU_sample_size * factor; + huffman_scan_header *scan_header = index->scan + current_scan; + scan_header->MCU_rows_per_iMCU_row = coef->MCU_rows_per_iMCU_row; + scan_header->MCUs_per_row = jdiv_round_up(cinfo->MCUs_per_row, sample_size); + scan_header->comps_in_scan = cinfo->comps_in_scan; + + size_t allocate_size = coef->MCU_rows_per_iMCU_row + * scan_header->MCUs_per_row * sizeof(huffman_offset_data); + scan_header->offset[cinfo->input_iMCU_row] = + (huffman_offset_data*)malloc(allocate_size); + index->mem_used += allocate_size; + + huffman_offset_data *offset_data = scan_header->offset[cinfo->input_iMCU_row]; + + /* Align the virtual buffers for the components used in this scan. */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + buffer[ci] = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], + 0, // Only need one row buffer + (JDIMENSION) compptr->v_samp_factor, TRUE); + } + /* Loop to process one whole iMCU row */ + for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; + yoffset++) { + for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; + MCU_col_num++) { + /* For each MCU, we loop through different color components. + * Then, for each color component we will get a list of pointers to DCT + * blocks in the virtual buffer. + */ + blkn = 0; /* index of current DCT block within MCU */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + start_col = MCU_col_num * compptr->MCU_width; + /* Get the list of pointers to DCT blocks in + * the virtual buffer in a color component of the MCU. + */ + for (yindex = 0; yindex < compptr->MCU_height; yindex++) { + buffer_ptr = buffer[ci][yindex+yoffset] + start_col; + for (xindex = 0; xindex < compptr->MCU_width; xindex++) { + coef->MCU_buffer[blkn++] = buffer_ptr++; + if (cinfo->input_scan_number == 0) { + // need to do pre-zero by ourself. + jzero_far((void FAR *) coef->MCU_buffer[blkn-1], + (size_t) (SIZEOF(JBLOCK))); + } + } + } + } + // Record huffman bit offset + if (MCU_col_num % sample_size == 0) { + (*cinfo->entropy->get_huffman_decoder_configuration) + (cinfo, offset_data); + ++offset_data; + } + /* Try to fetch the MCU. */ + if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { + /* Suspension forced; update state counters and exit */ + coef->MCU_vert_offset = yoffset; + coef->MCU_ctr = MCU_col_num; + return JPEG_SUSPENDED; + } + } + /* Completed an MCU row, but perhaps not an iMCU row */ + coef->MCU_ctr = 0; + } + (*cinfo->entropy->get_huffman_decoder_configuration) + (cinfo, &scan_header->prev_MCU_offset); + /* Completed the iMCU row, advance counters for next one */ + if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { + start_iMCU_row(cinfo); + return JPEG_ROW_COMPLETED; + } + /* Completed the scan */ + (*cinfo->inputctl->finish_input_pass) (cinfo); + return JPEG_SCAN_COMPLETED; +} + +/* + * Decompress and return some data in the multi-pass case. + * Always attempts to emit one fully interleaved MCU row ("iMCU" row). + * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. + * + * NB: output_buf contains a plane for each component in image. + */ + +METHODDEF(int) +decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + JDIMENSION block_num; + int ci, block_row, block_rows; + JBLOCKARRAY buffer; + JBLOCKROW buffer_ptr; + JSAMPARRAY output_ptr; + JDIMENSION output_col; + jpeg_component_info *compptr; + inverse_DCT_method_ptr inverse_DCT; + + /* Force some input to be done if we are getting ahead of the input. */ + while (cinfo->input_scan_number < cinfo->output_scan_number || + (cinfo->input_scan_number == cinfo->output_scan_number && + cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) { + if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED) + return JPEG_SUSPENDED; + } + + /* OK, output from the virtual arrays. */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Don't bother to IDCT an uninteresting component. */ + if (! compptr->component_needed) + continue; + /* Align the virtual buffer for this component. */ + buffer = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[ci], + cinfo->tile_decode ? 0 : cinfo->output_iMCU_row * compptr->v_samp_factor, + (JDIMENSION) compptr->v_samp_factor, FALSE); + /* Count non-dummy DCT block rows in this iMCU row. */ + if (cinfo->output_iMCU_row < last_iMCU_row) + block_rows = compptr->v_samp_factor; + else { + /* NB: can't use last_row_height here; it is input-side-dependent! */ + block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); + if (block_rows == 0) block_rows = compptr->v_samp_factor; + } + inverse_DCT = cinfo->idct->inverse_DCT[ci]; + output_ptr = output_buf[ci]; + int width_in_blocks = compptr->width_in_blocks; + int start_block = 0; +#if ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + // width_in_blocks for a component depends on its h_samp_factor. + width_in_blocks = jmin(width_in_blocks, + (cinfo->coef->MCU_column_right_boundary - + cinfo->coef->MCU_column_left_boundary) * + compptr->h_samp_factor); + start_block = coef->pub.MCU_columns_to_skip * + compptr->h_samp_factor; + } +#endif + /* Loop over all DCT blocks to be processed. */ + for (block_row = 0; block_row < block_rows; block_row++) { + buffer_ptr = buffer[block_row]; + output_col = start_block * compptr->DCT_scaled_size; + buffer_ptr += start_block; + for (block_num = start_block; block_num < width_in_blocks; block_num++) { + (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr, + output_ptr, output_col); + buffer_ptr++; + output_col += compptr->DCT_scaled_size; + } + output_ptr += compptr->DCT_scaled_size; + } + } + + if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) + return JPEG_ROW_COMPLETED; + return JPEG_SCAN_COMPLETED; +} + +#endif /* D_MULTISCAN_FILES_SUPPORTED */ + + +#ifdef BLOCK_SMOOTHING_SUPPORTED + +/* + * This code applies interblock smoothing as described by section K.8 + * of the JPEG standard: the first 5 AC coefficients are estimated from + * the DC values of a DCT block and its 8 neighboring blocks. + * We apply smoothing only for progressive JPEG decoding, and only if + * the coefficients it can estimate are not yet known to full precision. + */ + +/* Natural-order array positions of the first 5 zigzag-order coefficients */ +#define Q01_POS 1 +#define Q10_POS 8 +#define Q20_POS 16 +#define Q11_POS 9 +#define Q02_POS 2 + +/* + * Determine whether block smoothing is applicable and safe. + * We also latch the current states of the coef_bits[] entries for the + * AC coefficients; otherwise, if the input side of the decompressor + * advances into a new scan, we might think the coefficients are known + * more accurately than they really are. + */ + +LOCAL(boolean) +smoothing_ok (j_decompress_ptr cinfo) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + boolean smoothing_useful = FALSE; + int ci, coefi; + jpeg_component_info *compptr; + JQUANT_TBL * qtable; + int * coef_bits; + int * coef_bits_latch; + + if (! cinfo->progressive_mode || cinfo->coef_bits == NULL) + return FALSE; + + /* Allocate latch area if not already done */ + if (coef->coef_bits_latch == NULL) + coef->coef_bits_latch = (int *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + cinfo->num_components * + (SAVED_COEFS * SIZEOF(int))); + coef_bits_latch = coef->coef_bits_latch; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* All components' quantization values must already be latched. */ + if ((qtable = compptr->quant_table) == NULL) + return FALSE; + /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */ + if (qtable->quantval[0] == 0 || + qtable->quantval[Q01_POS] == 0 || + qtable->quantval[Q10_POS] == 0 || + qtable->quantval[Q20_POS] == 0 || + qtable->quantval[Q11_POS] == 0 || + qtable->quantval[Q02_POS] == 0) + return FALSE; + /* DC values must be at least partly known for all components. */ + coef_bits = cinfo->coef_bits[ci]; + if (coef_bits[0] < 0) + return FALSE; + /* Block smoothing is helpful if some AC coefficients remain inaccurate. */ + for (coefi = 1; coefi <= 5; coefi++) { + coef_bits_latch[coefi] = coef_bits[coefi]; + if (coef_bits[coefi] != 0) + smoothing_useful = TRUE; + } + coef_bits_latch += SAVED_COEFS; + } + + return smoothing_useful; +} + + +/* + * Variant of decompress_data for use when doing block smoothing. + */ + +METHODDEF(int) +decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) +{ + my_coef_ptr coef = (my_coef_ptr) cinfo->coef; + JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; + JDIMENSION block_num, last_block_column; + int ci, block_row, block_rows, access_rows; + JBLOCKARRAY buffer; + JBLOCKROW buffer_ptr, prev_block_row, next_block_row; + JSAMPARRAY output_ptr; + JDIMENSION output_col; + jpeg_component_info *compptr; + inverse_DCT_method_ptr inverse_DCT; + boolean first_row, last_row; + JBLOCK workspace; + int *coef_bits; + JQUANT_TBL *quanttbl; + INT32 Q00,Q01,Q02,Q10,Q11,Q20, num; + int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9; + int Al, pred; + + /* Force some input to be done if we are getting ahead of the input. */ + while (cinfo->input_scan_number <= cinfo->output_scan_number && + ! cinfo->inputctl->eoi_reached) { + if (cinfo->input_scan_number == cinfo->output_scan_number) { + /* If input is working on current scan, we ordinarily want it to + * have completed the current row. But if input scan is DC, + * we want it to keep one row ahead so that next block row's DC + * values are up to date. + */ + JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0; + if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta) + break; + } + if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED) + return JPEG_SUSPENDED; + } + + /* OK, output from the virtual arrays. */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Don't bother to IDCT an uninteresting component. */ + if (! compptr->component_needed) + continue; + /* Count non-dummy DCT block rows in this iMCU row. */ + if (cinfo->output_iMCU_row < last_iMCU_row) { + block_rows = compptr->v_samp_factor; + access_rows = block_rows * 2; /* this and next iMCU row */ + last_row = FALSE; + } else { + /* NB: can't use last_row_height here; it is input-side-dependent! */ + block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); + if (block_rows == 0) block_rows = compptr->v_samp_factor; + access_rows = block_rows; /* this iMCU row only */ + last_row = TRUE; + } + /* Align the virtual buffer for this component. */ + if (cinfo->output_iMCU_row > 0) { + access_rows += compptr->v_samp_factor; /* prior iMCU row too */ + buffer = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[ci], + (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor, + (JDIMENSION) access_rows, FALSE); + buffer += compptr->v_samp_factor; /* point to current iMCU row */ + first_row = FALSE; + } else { + buffer = (*cinfo->mem->access_virt_barray) + ((j_common_ptr) cinfo, coef->whole_image[ci], + (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE); + first_row = TRUE; + } + /* Fetch component-dependent info */ + coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); + quanttbl = compptr->quant_table; + Q00 = quanttbl->quantval[0]; + Q01 = quanttbl->quantval[Q01_POS]; + Q10 = quanttbl->quantval[Q10_POS]; + Q20 = quanttbl->quantval[Q20_POS]; + Q11 = quanttbl->quantval[Q11_POS]; + Q02 = quanttbl->quantval[Q02_POS]; + inverse_DCT = cinfo->idct->inverse_DCT[ci]; + output_ptr = output_buf[ci]; + /* Loop over all DCT blocks to be processed. */ + for (block_row = 0; block_row < block_rows; block_row++) { + buffer_ptr = buffer[block_row]; + if (first_row && block_row == 0) + prev_block_row = buffer_ptr; + else + prev_block_row = buffer[block_row-1]; + if (last_row && block_row == block_rows-1) + next_block_row = buffer_ptr; + else + next_block_row = buffer[block_row+1]; + /* We fetch the surrounding DC values using a sliding-register approach. + * Initialize all nine here so as to do the right thing on narrow pics. + */ + DC1 = DC2 = DC3 = (int) prev_block_row[0][0]; + DC4 = DC5 = DC6 = (int) buffer_ptr[0][0]; + DC7 = DC8 = DC9 = (int) next_block_row[0][0]; + output_col = 0; + last_block_column = compptr->width_in_blocks - 1; + for (block_num = 0; block_num <= last_block_column; block_num++) { + /* Fetch current DCT block into workspace so we can modify it. */ + jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1); + /* Update DC values */ + if (block_num < last_block_column) { + DC3 = (int) prev_block_row[1][0]; + DC6 = (int) buffer_ptr[1][0]; + DC9 = (int) next_block_row[1][0]; + } + /* Compute coefficient estimates per K.8. + * An estimate is applied only if coefficient is still zero, + * and is not known to be fully accurate. + */ + /* AC01 */ + if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) { + num = 36 * Q00 * (DC4 - DC6); + if (num >= 0) { + pred = (int) (((Q01<<7) + num) / (Q01<<8)); + if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { + pred = (int) (((Q10<<7) + num) / (Q10<<8)); + if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { + pred = (int) (((Q20<<7) + num) / (Q20<<8)); + if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { + pred = (int) (((Q11<<7) + num) / (Q11<<8)); + if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { + pred = (int) (((Q02<<7) + num) / (Q02<<8)); + if (Al > 0 && pred >= (1< 0 && pred >= (1<DCT_scaled_size; + } + output_ptr += compptr->DCT_scaled_size; + } + } + + if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) + return JPEG_ROW_COMPLETED; + return JPEG_SCAN_COMPLETED; +} + +#endif /* BLOCK_SMOOTHING_SUPPORTED */ + + +/* + * Initialize coefficient buffer controller. + */ + +GLOBAL(void) +jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer) +{ + my_coef_ptr coef; + + coef = (my_coef_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_coef_controller)); + cinfo->coef = (struct jpeg_d_coef_controller *) coef; + coef->pub.start_input_pass = start_input_pass; + coef->pub.start_output_pass = start_output_pass; + coef->pub.column_left_boundary = 0; + coef->pub.column_right_boundary = 0; + coef->pub.MCU_columns_to_skip = 0; +#ifdef BLOCK_SMOOTHING_SUPPORTED + coef->coef_bits_latch = NULL; +#endif + +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + if (cinfo->progressive_mode) { + /* Allocate one iMCU row virtual array, coef->whole_image[ci], + * for each color component, padded to a multiple of h_samp_factor + * DCT blocks in the horizontal direction. + */ + int ci, access_rows; + jpeg_component_info *compptr; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + access_rows = compptr->v_samp_factor; + coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE, + (JDIMENSION) jround_up((long) compptr->width_in_blocks, + (long) compptr->h_samp_factor), + (JDIMENSION) compptr->v_samp_factor, // one iMCU row + (JDIMENSION) access_rows); + } + coef->pub.consume_data_build_huffman_index = + consume_data_build_huffman_index_progressive; + coef->pub.consume_data = consume_data_multi_scan; + coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */ + coef->pub.decompress_data = decompress_onepass; + } else { + /* We only need a single-MCU buffer. */ + JBLOCKROW buffer; + int i; + + buffer = (JBLOCKROW) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); + for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) { + coef->MCU_buffer[i] = buffer + i; + } + coef->pub.consume_data_build_huffman_index = + consume_data_build_huffman_index_baseline; + coef->pub.consume_data = dummy_consume_data; + coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */ + coef->pub.decompress_data = decompress_onepass; + } + return; + } +#endif + + /* Create the coefficient buffer. */ + if (need_full_buffer) { +#ifdef D_MULTISCAN_FILES_SUPPORTED + /* Allocate a full-image virtual array for each component, */ + /* padded to a multiple of samp_factor DCT blocks in each direction. */ + /* Note we ask for a pre-zeroed array. */ + int ci, access_rows; + jpeg_component_info *compptr; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + access_rows = compptr->v_samp_factor; +#ifdef BLOCK_SMOOTHING_SUPPORTED + /* If block smoothing could be used, need a bigger window */ + if (cinfo->progressive_mode) + access_rows *= 3; +#endif + coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE, + (JDIMENSION) jround_up((long) compptr->width_in_blocks, + (long) compptr->h_samp_factor), + (JDIMENSION) jround_up((long) compptr->height_in_blocks, + (long) compptr->v_samp_factor), + (JDIMENSION) access_rows); + } + coef->pub.consume_data = consume_data; + coef->pub.decompress_data = decompress_data; + coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */ +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + /* We only need a single-MCU buffer. */ + JBLOCKROW buffer; + int i; + + buffer = (JBLOCKROW) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); + for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) { + coef->MCU_buffer[i] = buffer + i; + } + coef->pub.consume_data = dummy_consume_data; + coef->pub.decompress_data = decompress_onepass; + coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */ + } +} diff --git a/TMessagesProj/jni/libjpeg/jdcolor.c b/TMessagesProj/jni/libjpeg/jdcolor.c new file mode 100755 index 000000000..d9048ebc7 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdcolor.c @@ -0,0 +1,899 @@ +/* + * jdcolor.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains output colorspace conversion routines. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#ifdef NV_ARM_NEON +#include "jsimd_neon.h" +#endif + +/* Private subobject */ + +typedef struct { + struct jpeg_color_deconverter pub; /* public fields */ + + /* Private state for YCC->RGB conversion */ + int * Cr_r_tab; /* => table for Cr to R conversion */ + int * Cb_b_tab; /* => table for Cb to B conversion */ + INT32 * Cr_g_tab; /* => table for Cr to G conversion */ + INT32 * Cb_g_tab; /* => table for Cb to G conversion */ +} my_color_deconverter; + +typedef my_color_deconverter * my_cconvert_ptr; + + +#ifdef ANDROID_RGB + +/* Declarations for ordered dithering. + * + * We use 4x4 ordered dither array packed into 32 bits. This array is + * sufficent for dithering RGB_888 to RGB_565. + */ + +#define DITHER_MASK 0x3 +#define DITHER_ROTATE(x) (((x)<<24) | (((x)>>8)&0x00FFFFFF)) +static const INT32 dither_matrix[4] = { + 0x0008020A, + 0x0C040E06, + 0x030B0109, + 0x0F070D05 +}; + +#endif + + +/**************** YCbCr -> RGB conversion: most common case **************/ + +/* + * YCbCr is defined per CCIR 601-1, except that Cb and Cr are + * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. + * The conversion equations to be implemented are therefore + * R = Y + 1.40200 * Cr + * G = Y - 0.34414 * Cb - 0.71414 * Cr + * B = Y + 1.77200 * Cb + * where Cb and Cr represent the incoming values less CENTERJSAMPLE. + * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) + * + * To avoid floating-point arithmetic, we represent the fractional constants + * as integers scaled up by 2^16 (about 4 digits precision); we have to divide + * the products by 2^16, with appropriate rounding, to get the correct answer. + * Notice that Y, being an integral input, does not contribute any fraction + * so it need not participate in the rounding. + * + * For even more speed, we avoid doing any multiplications in the inner loop + * by precalculating the constants times Cb and Cr for all possible values. + * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); + * for 12-bit samples it is still acceptable. It's not very reasonable for + * 16-bit samples, but if you want lossless storage you shouldn't be changing + * colorspace anyway. + * The Cr=>R and Cb=>B values can be rounded to integers in advance; the + * values for the G calculation are left scaled up, since we must add them + * together before rounding. + */ + +#define SCALEBITS 16 /* speediest right-shift on some machines */ +#define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) +#define FIX(x) ((INT32) ((x) * (1L<RGB colorspace conversion. + */ + +LOCAL(void) +build_ycc_rgb_table (j_decompress_ptr cinfo) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + int i; + INT32 x; + SHIFT_TEMPS + + cconvert->Cr_r_tab = (int *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(int)); + cconvert->Cb_b_tab = (int *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(int)); + cconvert->Cr_g_tab = (INT32 *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(INT32)); + cconvert->Cb_g_tab = (INT32 *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(INT32)); + + for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { + /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ + /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ + /* Cr=>R value is nearest int to 1.40200 * x */ + cconvert->Cr_r_tab[i] = (int) + RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); + /* Cb=>B value is nearest int to 1.77200 * x */ + cconvert->Cb_b_tab[i] = (int) + RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); + /* Cr=>G value is scaled-up -0.71414 * x */ + cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x; + /* Cb=>G value is scaled-up -0.34414 * x */ + /* We also add in ONE_HALF so that need not do it in inner loop */ + cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; + } +} + +/* + * Convert some rows of samples to the output colorspace. + * + * Note that we change from noninterleaved, one-plane-per-component format + * to interleaved-pixel format. The output buffer is therefore three times + * as wide as the input buffer. + * A starting row offset is provided only for the input buffer. The caller + * can easily adjust the passed output_buf value to accommodate any row + * offset required on that side. + */ + +METHODDEF(void) +ycc_rgb_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int y, cb, cr; + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + register int * Crrtab = cconvert->Cr_r_tab; + register int * Cbbtab = cconvert->Cb_b_tab; + register INT32 * Crgtab = cconvert->Cr_g_tab; + register INT32 * Cbgtab = cconvert->Cb_g_tab; + SHIFT_TEMPS + + while (--num_rows >= 0) { + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + y = GETJSAMPLE(inptr0[col]); + cb = GETJSAMPLE(inptr1[col]); + cr = GETJSAMPLE(inptr2[col]); + /* Range-limiting is essential due to noise introduced by DCT losses. */ + outptr[RGB_RED] = range_limit[y + Crrtab[cr]]; + outptr[RGB_GREEN] = range_limit[y + + ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], + SCALEBITS))]; + outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]]; + outptr += RGB_PIXELSIZE; + } + } +} + +#ifdef ANDROID_RGB +METHODDEF(void) +ycc_rgba_8888_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int y, cb, cr; + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + register int * Crrtab = cconvert->Cr_r_tab; + register int * Cbbtab = cconvert->Cb_b_tab; + register INT32 * Crgtab = cconvert->Cr_g_tab; + register INT32 * Cbgtab = cconvert->Cb_g_tab; + SHIFT_TEMPS + + while (--num_rows >= 0) { + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + y = GETJSAMPLE(inptr0[col]); + cb = GETJSAMPLE(inptr1[col]); + cr = GETJSAMPLE(inptr2[col]); + /* Range-limiting is essential due to noise introduced by DCT losses. */ + outptr[RGB_RED] = range_limit[y + Crrtab[cr]]; + outptr[RGB_GREEN] = range_limit[y + + ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], + SCALEBITS))]; + outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]]; + outptr[RGB_ALPHA] = 0xFF; + outptr += 4; + } + } +} + +METHODDEF(void) +ycc_rgb_565_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int y, cb, cr; + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + register int * Crrtab = cconvert->Cr_r_tab; + register int * Cbbtab = cconvert->Cb_b_tab; + register INT32 * Crgtab = cconvert->Cr_g_tab; + register INT32 * Cbgtab = cconvert->Cb_g_tab; + SHIFT_TEMPS + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int r, g, b; + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + + if (PACK_NEED_ALIGNMENT(outptr)) { + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[y + Crrtab[cr]]; + g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS))]; + b = range_limit[y + Cbbtab[cb]]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[y + Crrtab[cr]]; + g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS))]; + b = range_limit[y + Cbbtab[cb]]; + rgb = PACK_SHORT_565(r,g,b); + + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[y + Crrtab[cr]]; + g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS))]; + b = range_limit[y + Cbbtab[cb]]; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + y = GETJSAMPLE(*inptr0); + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + r = range_limit[y + Crrtab[cr]]; + g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS))]; + b = range_limit[y + Cbbtab[cb]]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } + } +} + +METHODDEF(void) +ycc_rgb_565D_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int y, cb, cr; + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + register int * Crrtab = cconvert->Cr_r_tab; + register int * Cbbtab = cconvert->Cb_b_tab; + register INT32 * Crgtab = cconvert->Cr_g_tab; + register INT32 * Cbgtab = cconvert->Cb_g_tab; + INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; + SHIFT_TEMPS + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int r, g, b; + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + if (PACK_NEED_ALIGNMENT(outptr)) { + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; + g = range_limit[DITHER_565_G(y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS)), d0)]; + b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; + g = range_limit[DITHER_565_G(y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS)), d0)]; + b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr0++); + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; + g = range_limit[DITHER_565_G(y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS)), d0)]; + b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + y = GETJSAMPLE(*inptr0); + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; + g = range_limit[DITHER_565_G(y + ((int)RIGHT_SHIFT(Cbgtab[cb]+Crgtab[cr], SCALEBITS)), d0)]; + b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } + } +} + +#endif + +/**************** Cases other than YCbCr -> RGB(A) **************/ + +#ifdef ANDROID_RGB +METHODDEF(void) +rgb_rgba_8888_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + SHIFT_TEMPS + + while (--num_rows >= 0) { + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + *outptr++ = *inptr0++; + *outptr++ = *inptr1++; + *outptr++ = *inptr2++; + *outptr++ = 0xFF; + } + } +} + +METHODDEF(void) +rgb_rgb_565_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + SHIFT_TEMPS + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int r, g, b; + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + if (PACK_NEED_ALIGNMENT(outptr)) { + r = GETJSAMPLE(*inptr0++); + g = GETJSAMPLE(*inptr1++); + b = GETJSAMPLE(*inptr2++); + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + r = GETJSAMPLE(*inptr0++); + g = GETJSAMPLE(*inptr1++); + b = GETJSAMPLE(*inptr2++); + rgb = PACK_SHORT_565(r,g,b); + r = GETJSAMPLE(*inptr0++); + g = GETJSAMPLE(*inptr1++); + b = GETJSAMPLE(*inptr2++); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + r = GETJSAMPLE(*inptr0); + g = GETJSAMPLE(*inptr1); + b = GETJSAMPLE(*inptr2); + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } + } +} + + +METHODDEF(void) +rgb_rgb_565D_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2; + register JDIMENSION col; + register JSAMPLE * range_limit = cinfo->sample_range_limit; + JDIMENSION num_cols = cinfo->output_width; + INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; + SHIFT_TEMPS + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int r, g, b; + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + input_row++; + outptr = *output_buf++; + if (PACK_NEED_ALIGNMENT(outptr)) { + r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; + g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; + b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; + g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; + b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_SHORT_565(r,g,b); + r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; + g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; + b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0), d0)]; + g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1), d0)]; + b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2), d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } + } +} + +#endif + +/* + * Color conversion for no colorspace change: just copy the data, + * converting from separate-planes to interleaved representation. + */ + +METHODDEF(void) +null_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW inptr, outptr; + register JDIMENSION count; + register int num_components = cinfo->num_components; + JDIMENSION num_cols = cinfo->output_width; + int ci; + + while (--num_rows >= 0) { + for (ci = 0; ci < num_components; ci++) { + inptr = input_buf[ci][input_row]; + outptr = output_buf[0] + ci; + for (count = num_cols; count > 0; count--) { + *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */ + outptr += num_components; + } + } + input_row++; + output_buf++; + } +} + + +/* + * Color conversion for grayscale: just copy the data. + * This also works for YCbCr -> grayscale conversion, in which + * we just copy the Y (luminance) component and ignore chrominance. + */ + +METHODDEF(void) +grayscale_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0, + num_rows, cinfo->output_width); +} + + +/* + * Convert grayscale to RGB: just duplicate the graylevel three times. + * This is provided to support applications that don't want to cope + * with grayscale as a separate case. + */ + +METHODDEF(void) +gray_rgb_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW inptr, outptr; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + + while (--num_rows >= 0) { + inptr = input_buf[0][input_row++]; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + /* We can dispense with GETJSAMPLE() here */ + outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col]; + outptr += RGB_PIXELSIZE; + } + } +} + +#ifdef ANDROID_RGB +METHODDEF(void) +gray_rgba_8888_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW inptr, outptr; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + + while (--num_rows >= 0) { + inptr = input_buf[0][input_row++]; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + /* We can dispense with GETJSAMPLE() here */ + outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col]; + outptr[RGB_ALPHA] = 0xff; + outptr += 4; + } + } +} + +METHODDEF(void) +gray_rgb_565_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW inptr, outptr; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int g; + inptr = input_buf[0][input_row++]; + outptr = *output_buf++; + if (PACK_NEED_ALIGNMENT(outptr)) { + g = *inptr++; + rgb = PACK_SHORT_565(g, g, g); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + g = *inptr++; + rgb = PACK_SHORT_565(g, g, g); + g = *inptr++; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g)); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + g = *inptr; + rgb = PACK_SHORT_565(g, g, g); + *(INT16*)outptr = rgb; + } + } +} + +METHODDEF(void) +gray_rgb_565D_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + register JSAMPROW inptr, outptr; + register JDIMENSION col; + register JSAMPLE * range_limit = cinfo->sample_range_limit; + JDIMENSION num_cols = cinfo->output_width; + INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; + + while (--num_rows >= 0) { + INT32 rgb; + unsigned int g; + inptr = input_buf[0][input_row++]; + outptr = *output_buf++; + if (PACK_NEED_ALIGNMENT(outptr)) { + g = *inptr++; + g = range_limit[DITHER_565_R(g, d0)]; + rgb = PACK_SHORT_565(g, g, g); + *(INT16*)outptr = rgb; + outptr += 2; + num_cols--; + } + for (col = 0; col < (num_cols>>1); col++) { + g = *inptr++; + g = range_limit[DITHER_565_R(g, d0)]; + rgb = PACK_SHORT_565(g, g, g); + d0 = DITHER_ROTATE(d0); + g = *inptr++; + g = range_limit[DITHER_565_R(g, d0)]; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g)); + d0 = DITHER_ROTATE(d0); + WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); + outptr += 4; + } + if (num_cols&1) { + g = *inptr; + g = range_limit[DITHER_565_R(g, d0)]; + rgb = PACK_SHORT_565(g, g, g); + *(INT16*)outptr = rgb; + } + } +} +#endif + +/* + * Adobe-style YCCK->CMYK conversion. + * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same + * conversion as above, while passing K (black) unchanged. + * We assume build_ycc_rgb_table has been called. + */ + +METHODDEF(void) +ycck_cmyk_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ + my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; + register int y, cb, cr; + register JSAMPROW outptr; + register JSAMPROW inptr0, inptr1, inptr2, inptr3; + register JDIMENSION col; + JDIMENSION num_cols = cinfo->output_width; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + register int * Crrtab = cconvert->Cr_r_tab; + register int * Cbbtab = cconvert->Cb_b_tab; + register INT32 * Crgtab = cconvert->Cr_g_tab; + register INT32 * Cbgtab = cconvert->Cb_g_tab; + SHIFT_TEMPS + + while (--num_rows >= 0) { + inptr0 = input_buf[0][input_row]; + inptr1 = input_buf[1][input_row]; + inptr2 = input_buf[2][input_row]; + inptr3 = input_buf[3][input_row]; + input_row++; + outptr = *output_buf++; + for (col = 0; col < num_cols; col++) { + y = GETJSAMPLE(inptr0[col]); + cb = GETJSAMPLE(inptr1[col]); + cr = GETJSAMPLE(inptr2[col]); + /* Range-limiting is essential due to noise introduced by DCT losses. */ + outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */ + outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */ + ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], + SCALEBITS)))]; + outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */ + /* K passes through unchanged */ + outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */ + outptr += 4; + } + } +} + + +/* + * Empty method for start_pass. + */ + +METHODDEF(void) +start_pass_dcolor (j_decompress_ptr cinfo) +{ + /* no work needed */ +} + + +/* + * Module initialization routine for output colorspace conversion. + */ + +GLOBAL(void) +jinit_color_deconverter (j_decompress_ptr cinfo) +{ + my_cconvert_ptr cconvert; + int ci; + + cconvert = (my_cconvert_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_color_deconverter)); + cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert; + cconvert->pub.start_pass = start_pass_dcolor; + + /* Make sure num_components agrees with jpeg_color_space */ + switch (cinfo->jpeg_color_space) { + case JCS_GRAYSCALE: + if (cinfo->num_components != 1) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + break; + + case JCS_RGB: + case JCS_YCbCr: + if (cinfo->num_components != 3) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + break; + + case JCS_CMYK: + case JCS_YCCK: + if (cinfo->num_components != 4) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + break; + + default: /* JCS_UNKNOWN can be anything */ + if (cinfo->num_components < 1) + ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); + break; + } + + /* Set out_color_components and conversion method based on requested space. + * Also clear the component_needed flags for any unused components, + * so that earlier pipeline stages can avoid useless computation. + */ + + switch (cinfo->out_color_space) { + case JCS_GRAYSCALE: + cinfo->out_color_components = 1; + if (cinfo->jpeg_color_space == JCS_GRAYSCALE || + cinfo->jpeg_color_space == JCS_YCbCr) { + cconvert->pub.color_convert = grayscale_convert; + /* For color->grayscale conversion, only the Y (0) component is needed */ + for (ci = 1; ci < cinfo->num_components; ci++) + cinfo->comp_info[ci].component_needed = FALSE; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_RGB: + cinfo->out_color_components = RGB_PIXELSIZE; + if (cinfo->jpeg_color_space == JCS_YCbCr) { + cconvert->pub.color_convert = ycc_rgb_convert; + build_ycc_rgb_table(cinfo); + } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { + cconvert->pub.color_convert = gray_rgb_convert; + } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) { + cconvert->pub.color_convert = null_convert; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + +#ifdef ANDROID_RGB + case JCS_RGBA_8888: + cinfo->out_color_components = 4; + if (cinfo->jpeg_color_space == JCS_YCbCr) { +#if defined(NV_ARM_NEON) && defined(__ARM_HAVE_NEON) + if (cap_neon_ycc_rgb()) { + cconvert->pub.color_convert = jsimd_ycc_rgba8888_convert; + } else { + cconvert->pub.color_convert = ycc_rgba_8888_convert; + } +#else + cconvert->pub.color_convert = ycc_rgba_8888_convert; +#endif + build_ycc_rgb_table(cinfo); + } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { + cconvert->pub.color_convert = gray_rgba_8888_convert; + } else if (cinfo->jpeg_color_space == JCS_RGB) { + cconvert->pub.color_convert = rgb_rgba_8888_convert; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + case JCS_RGB_565: + cinfo->out_color_components = RGB_PIXELSIZE; + if (cinfo->dither_mode == JDITHER_NONE) { + if (cinfo->jpeg_color_space == JCS_YCbCr) { +#if defined(NV_ARM_NEON) && defined(__ARM_HAVE_NEON) + if (cap_neon_ycc_rgb()) { + cconvert->pub.color_convert = jsimd_ycc_rgb565_convert; + } else { + cconvert->pub.color_convert = ycc_rgb_565_convert; + } +#else + cconvert->pub.color_convert = ycc_rgb_565_convert; +#endif + build_ycc_rgb_table(cinfo); + } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { + cconvert->pub.color_convert = gray_rgb_565_convert; + } else if (cinfo->jpeg_color_space == JCS_RGB) { + cconvert->pub.color_convert = rgb_rgb_565_convert; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + } else { + /* only ordered dither is supported */ + if (cinfo->jpeg_color_space == JCS_YCbCr) { + cconvert->pub.color_convert = ycc_rgb_565D_convert; + build_ycc_rgb_table(cinfo); + } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { + cconvert->pub.color_convert = gray_rgb_565D_convert; + } else if (cinfo->jpeg_color_space == JCS_RGB) { + cconvert->pub.color_convert = rgb_rgb_565D_convert; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + } + break; +#endif + + case JCS_CMYK: + cinfo->out_color_components = 4; + if (cinfo->jpeg_color_space == JCS_YCCK) { + cconvert->pub.color_convert = ycck_cmyk_convert; + build_ycc_rgb_table(cinfo); + } else if (cinfo->jpeg_color_space == JCS_CMYK) { + cconvert->pub.color_convert = null_convert; + } else + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + + default: + /* Permit null conversion to same output space */ + if (cinfo->out_color_space == cinfo->jpeg_color_space) { + cinfo->out_color_components = cinfo->num_components; + cconvert->pub.color_convert = null_convert; + } else /* unsupported non-null conversion */ + ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); + break; + } + + if (cinfo->quantize_colors) + cinfo->output_components = 1; /* single colormapped output component */ + else + cinfo->output_components = cinfo->out_color_components; +} diff --git a/TMessagesProj/jni/libjpeg/jdct.h b/TMessagesProj/jni/libjpeg/jdct.h new file mode 100755 index 000000000..d5d868f16 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdct.h @@ -0,0 +1,180 @@ +/* + * jdct.h + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This include file contains common declarations for the forward and + * inverse DCT modules. These declarations are private to the DCT managers + * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms. + * The individual DCT algorithms are kept in separate files to ease + * machine-dependent tuning (e.g., assembly coding). + */ + + +/* + * A forward DCT routine is given a pointer to a work area of type DCTELEM[]; + * the DCT is to be performed in-place in that buffer. Type DCTELEM is int + * for 8-bit samples, INT32 for 12-bit samples. (NOTE: Floating-point DCT + * implementations use an array of type FAST_FLOAT, instead.) + * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE). + * The DCT outputs are returned scaled up by a factor of 8; they therefore + * have a range of +-8K for 8-bit data, +-128K for 12-bit data. This + * convention improves accuracy in integer implementations and saves some + * work in floating-point ones. + * Quantization of the output coefficients is done by jcdctmgr.c. + */ + +#if BITS_IN_JSAMPLE == 8 +#ifdef ANDROID_MIPS_IDCT +typedef short DCTELEM; /* 16 or 32 bits is fine */ +#else +typedef int DCTELEM; /* 16 or 32 bits is fine */ +#endif +#else +typedef INT32 DCTELEM; /* must have 32 bits */ +#endif + +typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data)); +typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data)); + + +/* + * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer + * to an output sample array. The routine must dequantize the input data as + * well as perform the IDCT; for dequantization, it uses the multiplier table + * pointed to by compptr->dct_table. The output data is to be placed into the + * sample array starting at a specified column. (Any row offset needed will + * be applied to the array pointer before it is passed to the IDCT code.) + * Note that the number of samples emitted by the IDCT routine is + * DCT_scaled_size * DCT_scaled_size. + */ + +/* typedef inverse_DCT_method_ptr is declared in jpegint.h */ + +/* + * Each IDCT routine has its own ideas about the best dct_table element type. + */ + +typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */ +#if BITS_IN_JSAMPLE == 8 +typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */ +#define IFAST_SCALE_BITS 2 /* fractional bits in scale factors */ +#else +typedef INT32 IFAST_MULT_TYPE; /* need 32 bits for scaled quantizers */ +#define IFAST_SCALE_BITS 13 /* fractional bits in scale factors */ +#endif +typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */ + + +/* + * Each IDCT routine is responsible for range-limiting its results and + * converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could + * be quite far out of range if the input data is corrupt, so a bulletproof + * range-limiting step is required. We use a mask-and-table-lookup method + * to do the combined operations quickly. See the comments with + * prepare_range_limit_table (in jdmaster.c) for more info. + */ + +#define IDCT_range_limit(cinfo) ((cinfo)->sample_range_limit + CENTERJSAMPLE) + +#define RANGE_MASK (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */ + + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_fdct_islow jFDislow +#define jpeg_fdct_ifast jFDifast +#define jpeg_fdct_float jFDfloat +#define jpeg_idct_islow jRDislow +#define jpeg_idct_ifast jRDifast +#define jpeg_idct_float jRDfloat +#define jpeg_idct_4x4 jRD4x4 +#define jpeg_idct_2x2 jRD2x2 +#define jpeg_idct_1x1 jRD1x1 +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + +/* Extern declarations for the forward and inverse DCT routines. */ + +EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data)); +EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data)); +EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data)); + +EXTERN(void) jpeg_idct_islow + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); +EXTERN(void) jpeg_idct_ifast + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); +EXTERN(void) jpeg_idct_float + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); +EXTERN(void) jpeg_idct_4x4 + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); +EXTERN(void) jpeg_idct_2x2 + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); +EXTERN(void) jpeg_idct_1x1 + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); + + +/* + * Macros for handling fixed-point arithmetic; these are used by many + * but not all of the DCT/IDCT modules. + * + * All values are expected to be of type INT32. + * Fractional constants are scaled left by CONST_BITS bits. + * CONST_BITS is defined within each module using these macros, + * and may differ from one module to the next. + */ + +#define ONE ((INT32) 1) +#define CONST_SCALE (ONE << CONST_BITS) + +/* Convert a positive real constant to an integer scaled by CONST_SCALE. + * Caution: some C compilers fail to reduce "FIX(constant)" at compile time, + * thus causing a lot of useless floating-point operations at run time. + */ + +#define FIX(x) ((INT32) ((x) * CONST_SCALE + 0.5)) + +/* Descale and correctly round an INT32 value that's scaled by N bits. + * We assume RIGHT_SHIFT rounds towards minus infinity, so adding + * the fudge factor is correct for either sign of X. + */ + +#define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n) + +/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. + * This macro is used only when the two inputs will actually be no more than + * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a + * full 32x32 multiply. This provides a useful speedup on many machines. + * Unfortunately there is no way to specify a 16x16->32 multiply portably + * in C, but some C compilers will do the right thing if you provide the + * correct combination of casts. + */ + +#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */ +#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT16) (const))) +#endif +#ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */ +#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT32) (const))) +#endif + +#ifndef MULTIPLY16C16 /* default definition */ +#define MULTIPLY16C16(var,const) ((var) * (const)) +#endif + +/* Same except both inputs are variables. */ + +#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */ +#define MULTIPLY16V16(var1,var2) (((INT16) (var1)) * ((INT16) (var2))) +#endif + +#ifndef MULTIPLY16V16 /* default definition */ +#define MULTIPLY16V16(var1,var2) ((var1) * (var2)) +#endif diff --git a/TMessagesProj/jni/libjpeg/jddctmgr.c b/TMessagesProj/jni/libjpeg/jddctmgr.c new file mode 100755 index 000000000..980f8f316 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jddctmgr.c @@ -0,0 +1,383 @@ +/* + * jddctmgr.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the inverse-DCT management logic. + * This code selects a particular IDCT implementation to be used, + * and it performs related housekeeping chores. No code in this file + * is executed per IDCT step, only during output pass setup. + * + * Note that the IDCT routines are responsible for performing coefficient + * dequantization as well as the IDCT proper. This module sets up the + * dequantization multiplier table needed by the IDCT routine. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef ANDROID_ARMV6_IDCT + #undef ANDROID_ARMV6_IDCT + #ifdef __arm__ + #include + #if __ARM_ARCH__ >= 6 + #define ANDROID_ARMV6_IDCT + #else + #warning "ANDROID_ARMV6_IDCT is disabled" + #endif + #endif +#endif + +#ifdef NV_ARM_NEON +#include "jsimd_neon.h" +#endif + +#ifdef ANDROID_ARMV6_IDCT + +/* Intentionally declare the prototype with arguments of primitive types instead + * of type-defined ones. This will at least generate some warnings if jmorecfg.h + * is changed and becomes incompatible with the assembly code. + */ +extern void armv6_idct(short *coefs, int *quans, unsigned char **rows, int col); + +void jpeg_idct_armv6 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + IFAST_MULT_TYPE *dct_table = (IFAST_MULT_TYPE *)compptr->dct_table; + armv6_idct(coef_block, dct_table, output_buf, output_col); +} + +#endif + +#ifdef ANDROID_INTELSSE2_IDCT +extern short __attribute__((aligned(16))) quantptrSSE[DCTSIZE2]; +extern void jpeg_idct_intelsse (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col); +#endif + +#ifdef ANDROID_MIPS_IDCT +extern void jpeg_idct_mips(j_decompress_ptr, jpeg_component_info *, JCOEFPTR, JSAMPARRAY, JDIMENSION); +#endif + +/* + * The decompressor input side (jdinput.c) saves away the appropriate + * quantization table for each component at the start of the first scan + * involving that component. (This is necessary in order to correctly + * decode files that reuse Q-table slots.) + * When we are ready to make an output pass, the saved Q-table is converted + * to a multiplier table that will actually be used by the IDCT routine. + * The multiplier table contents are IDCT-method-dependent. To support + * application changes in IDCT method between scans, we can remake the + * multiplier tables if necessary. + * In buffered-image mode, the first output pass may occur before any data + * has been seen for some components, and thus before their Q-tables have + * been saved away. To handle this case, multiplier tables are preset + * to zeroes; the result of the IDCT will be a neutral gray level. + */ + + +/* Private subobject for this module */ + +typedef struct { + struct jpeg_inverse_dct pub; /* public fields */ + + /* This array contains the IDCT method code that each multiplier table + * is currently set up for, or -1 if it's not yet set up. + * The actual multiplier tables are pointed to by dct_table in the + * per-component comp_info structures. + */ + int cur_method[MAX_COMPONENTS]; +} my_idct_controller; + +typedef my_idct_controller * my_idct_ptr; + + +/* Allocated multiplier tables: big enough for any supported variant */ + +typedef union { + ISLOW_MULT_TYPE islow_array[DCTSIZE2]; +#ifdef DCT_IFAST_SUPPORTED + IFAST_MULT_TYPE ifast_array[DCTSIZE2]; +#endif +#ifdef DCT_FLOAT_SUPPORTED + FLOAT_MULT_TYPE float_array[DCTSIZE2]; +#endif +} multiplier_table; + + +/* The current scaled-IDCT routines require ISLOW-style multiplier tables, + * so be sure to compile that code if either ISLOW or SCALING is requested. + */ +#ifdef DCT_ISLOW_SUPPORTED +#define PROVIDE_ISLOW_TABLES +#else +#ifdef IDCT_SCALING_SUPPORTED +#define PROVIDE_ISLOW_TABLES +#endif +#endif + + +/* + * Prepare for an output pass. + * Here we select the proper IDCT routine for each component and build + * a matching multiplier table. + */ + +METHODDEF(void) +start_pass (j_decompress_ptr cinfo) +{ + my_idct_ptr idct = (my_idct_ptr) cinfo->idct; + int ci, i; + jpeg_component_info *compptr; + int method = 0; + inverse_DCT_method_ptr method_ptr = NULL; + JQUANT_TBL * qtbl; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Select the proper IDCT routine for this component's scaling */ + switch (compptr->DCT_scaled_size) { +#ifdef IDCT_SCALING_SUPPORTED + case 1: + method_ptr = jpeg_idct_1x1; + method = JDCT_ISLOW; /* jidctred uses islow-style table */ + break; + case 2: +#if defined(NV_ARM_NEON) && defined(__ARM_HAVE_NEON) + if (cap_neon_idct_2x2()) { + method_ptr = jsimd_idct_2x2; + } else { + method_ptr = jpeg_idct_2x2; + } +#else + method_ptr = jpeg_idct_2x2; +#endif + method = JDCT_ISLOW; /* jidctred uses islow-style table */ + break; + case 4: +#if defined(NV_ARM_NEON) && defined(__ARM_HAVE_NEON) + if (cap_neon_idct_4x4()) { + method_ptr = jsimd_idct_4x4; + } else { + method_ptr = jpeg_idct_4x4; + } +#else + method_ptr = jpeg_idct_4x4; +#endif + method = JDCT_ISLOW; /* jidctred uses islow-style table */ + break; +#endif + case DCTSIZE: + switch (cinfo->dct_method) { +#ifdef ANDROID_ARMV6_IDCT + case JDCT_ISLOW: + case JDCT_IFAST: + method_ptr = jpeg_idct_armv6; + method = JDCT_IFAST; + break; +#else /* ANDROID_ARMV6_IDCT */ +#ifdef ANDROID_INTELSSE2_IDCT + case JDCT_ISLOW: + case JDCT_IFAST: + method_ptr = jpeg_idct_intelsse; + method = JDCT_ISLOW; /* Use quant table of ISLOW.*/ + break; +#else /* ANDROID_INTELSSE2_IDCT */ +#ifdef ANDROID_MIPS_IDCT + case JDCT_ISLOW: + case JDCT_IFAST: + method_ptr = jpeg_idct_mips; + method = JDCT_IFAST; + break; +#else /* ANDROID_MIPS_IDCT */ +#ifdef DCT_ISLOW_SUPPORTED + case JDCT_ISLOW: + method_ptr = jpeg_idct_islow; + method = JDCT_ISLOW; + break; +#endif +#ifdef DCT_IFAST_SUPPORTED + case JDCT_IFAST: +#if defined(NV_ARM_NEON) && defined(__ARM_HAVE_NEON) + if (cap_neon_idct_ifast()) { + method_ptr = jsimd_idct_ifast; + } else { + method_ptr = jpeg_idct_ifast; + } +#else + method_ptr = jpeg_idct_ifast; +#endif + method = JDCT_IFAST; + break; +#endif +#endif /* ANDROID_MIPS_IDCT */ +#endif /* ANDROID_INTELSSE2_IDCT*/ +#endif /* ANDROID_ARMV6_IDCT */ +#ifdef DCT_FLOAT_SUPPORTED + case JDCT_FLOAT: + method_ptr = jpeg_idct_float; + method = JDCT_FLOAT; + break; +#endif + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + break; + } + break; + default: + ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size); + break; + } + idct->pub.inverse_DCT[ci] = method_ptr; + /* Create multiplier table from quant table. + * However, we can skip this if the component is uninteresting + * or if we already built the table. Also, if no quant table + * has yet been saved for the component, we leave the + * multiplier table all-zero; we'll be reading zeroes from the + * coefficient controller's buffer anyway. + */ + if (! compptr->component_needed || idct->cur_method[ci] == method) + continue; + qtbl = compptr->quant_table; + if (qtbl == NULL) /* happens if no data yet for component */ + continue; + idct->cur_method[ci] = method; + switch (method) { +#ifdef PROVIDE_ISLOW_TABLES + case JDCT_ISLOW: + { + /* For LL&M IDCT method, multipliers are equal to raw quantization + * coefficients, but are stored as ints to ensure access efficiency. + */ + ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table; + for (i = 0; i < DCTSIZE2; i++) { + ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i]; + } + } + break; +#endif +#ifdef DCT_IFAST_SUPPORTED + case JDCT_IFAST: + { + /* For AA&N IDCT method, multipliers are equal to quantization + * coefficients scaled by scalefactor[row]*scalefactor[col], where + * scalefactor[0] = 1 + * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 + * For integer operation, the multiplier table is to be scaled by + * IFAST_SCALE_BITS. + */ + IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table; +#ifdef ANDROID_ARMV6_IDCT + /* Precomputed values scaled up by 15 bits. */ + static const unsigned short scales[DCTSIZE2] = { + 32768, 45451, 42813, 38531, 32768, 25746, 17734, 9041, + 45451, 63042, 59384, 53444, 45451, 35710, 24598, 12540, + 42813, 59384, 55938, 50343, 42813, 33638, 23170, 11812, + 38531, 53444, 50343, 45308, 38531, 30274, 20853, 10631, + 32768, 45451, 42813, 38531, 32768, 25746, 17734, 9041, + 25746, 35710, 33638, 30274, 25746, 20228, 13933, 7103, + 17734, 24598, 23170, 20853, 17734, 13933, 9598, 4893, + 9041, 12540, 11812, 10631, 9041, 7103, 4893, 2494, + }; + /* Inverse map of [7, 5, 1, 3, 0, 2, 4, 6]. */ + static const char orders[DCTSIZE] = {4, 2, 5, 3, 6, 1, 7, 0}; + /* Reorder the columns after transposing. */ + for (i = 0; i < DCTSIZE2; ++i) { + int j = ((i & 7) << 3) + orders[i >> 3]; + ifmtbl[j] = (qtbl->quantval[i] * scales[i] + 2) >> 2; + } +#else /* ANDROID_ARMV6_IDCT */ + +#define CONST_BITS 14 + static const INT16 aanscales[DCTSIZE2] = { + /* precomputed values scaled up by 14 bits */ + 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, + 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, + 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, + 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, + 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, + 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, + 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, + 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 + }; + SHIFT_TEMPS + + for (i = 0; i < DCTSIZE2; i++) { + ifmtbl[i] = (IFAST_MULT_TYPE) + DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i], + (INT32) aanscales[i]), + CONST_BITS-IFAST_SCALE_BITS); + } +#endif /* ANDROID_ARMV6_IDCT */ + } + break; +#endif +#ifdef DCT_FLOAT_SUPPORTED + case JDCT_FLOAT: + { + /* For float AA&N IDCT method, multipliers are equal to quantization + * coefficients scaled by scalefactor[row]*scalefactor[col], where + * scalefactor[0] = 1 + * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 + */ + FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table; + int row, col; + static const double aanscalefactor[DCTSIZE] = { + 1.0, 1.387039845, 1.306562965, 1.175875602, + 1.0, 0.785694958, 0.541196100, 0.275899379 + }; + + i = 0; + for (row = 0; row < DCTSIZE; row++) { + for (col = 0; col < DCTSIZE; col++) { + fmtbl[i] = (FLOAT_MULT_TYPE) + ((double) qtbl->quantval[i] * + aanscalefactor[row] * aanscalefactor[col]); + i++; + } + } + } + break; +#endif + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + break; + } + } +} + + +/* + * Initialize IDCT manager. + */ + +GLOBAL(void) +jinit_inverse_dct (j_decompress_ptr cinfo) +{ + my_idct_ptr idct; + int ci; + jpeg_component_info *compptr; + + idct = (my_idct_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_idct_controller)); + cinfo->idct = (struct jpeg_inverse_dct *) idct; + idct->pub.start_pass = start_pass; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Allocate and pre-zero a multiplier table for each component */ + compptr->dct_table = + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(multiplier_table)); + MEMZERO(compptr->dct_table, SIZEOF(multiplier_table)); + /* Mark multiplier table not yet set up for any method */ + idct->cur_method[ci] = -1; + } +} diff --git a/TMessagesProj/jni/libjpeg/jdhuff.c b/TMessagesProj/jni/libjpeg/jdhuff.c new file mode 100755 index 000000000..bc5d4fdd2 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdhuff.c @@ -0,0 +1,894 @@ +/* + * jdhuff.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains Huffman entropy decoding routines. + * + * Much of the complexity here has to do with supporting input suspension. + * If the data source module demands suspension, we want to be able to back + * up to the start of the current MCU. To do this, we copy state variables + * into local working storage, and update them back to the permanent + * storage only upon successful completion of an MCU. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdhuff.h" /* Declarations shared with jdphuff.c */ + +LOCAL(boolean) process_restart (j_decompress_ptr cinfo); + + +/* + * Expanded entropy decoder object for Huffman decoding. + * + * The savable_state subrecord contains fields that change within an MCU, + * but must not be updated permanently until we complete the MCU. + */ + +typedef struct { + int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ +} savable_state; + +/* This macro is to work around compilers with missing or broken + * structure assignment. You'll need to fix this code if you have + * such a compiler and you change MAX_COMPS_IN_SCAN. + */ + +#ifndef NO_STRUCT_ASSIGN +#define ASSIGN_STATE(dest,src) ((dest) = (src)) +#else +#if MAX_COMPS_IN_SCAN == 4 +#define ASSIGN_STATE(dest,src) \ + ((dest).last_dc_val[0] = (src).last_dc_val[0], \ + (dest).last_dc_val[1] = (src).last_dc_val[1], \ + (dest).last_dc_val[2] = (src).last_dc_val[2], \ + (dest).last_dc_val[3] = (src).last_dc_val[3]) +#endif +#endif + + +typedef struct { + struct jpeg_entropy_decoder pub; /* public fields */ + + /* These fields are loaded into local variables at start of each MCU. + * In case of suspension, we exit WITHOUT updating them. + */ + bitread_perm_state bitstate; /* Bit buffer at start of MCU */ + savable_state saved; /* Other state at start of MCU */ + + /* These fields are NOT loaded into local working state. */ + unsigned int restarts_to_go; /* MCUs left in this restart interval */ + + /* Pointers to derived tables (these workspaces have image lifespan) */ + d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]; + d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]; + + /* Precalculated info set up by start_pass for use in decode_mcu: */ + + /* Pointers to derived tables to be used for each block within an MCU */ + d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU]; + d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU]; + /* Whether we care about the DC and AC coefficient values for each block */ + boolean dc_needed[D_MAX_BLOCKS_IN_MCU]; + boolean ac_needed[D_MAX_BLOCKS_IN_MCU]; +} huff_entropy_decoder; + +typedef huff_entropy_decoder * huff_entropy_ptr; + +/* + * Initialize for a Huffman-compressed scan. + */ + +METHODDEF(void) +start_pass_huff_decoder (j_decompress_ptr cinfo) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int ci, blkn, dctbl, actbl; + jpeg_component_info * compptr; + + /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG. + * This ought to be an error condition, but we make it a warning because + * there are some baseline files out there with all zeroes in these bytes. + */ + if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 || + cinfo->Ah != 0 || cinfo->Al != 0) + WARNMS(cinfo, JWRN_NOT_SEQUENTIAL); + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + dctbl = compptr->dc_tbl_no; + actbl = compptr->ac_tbl_no; + /* Compute derived values for Huffman tables */ + /* We may do this more than once for a table, but it's not expensive */ + jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl, + & entropy->dc_derived_tbls[dctbl]); + jpeg_make_d_derived_tbl(cinfo, FALSE, actbl, + & entropy->ac_derived_tbls[actbl]); + /* Initialize DC predictions to 0 */ + entropy->saved.last_dc_val[ci] = 0; + } + + /* Precalculate decoding info for each block in an MCU of this scan */ + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + ci = cinfo->MCU_membership[blkn]; + compptr = cinfo->cur_comp_info[ci]; + /* Precalculate which table to use for each block */ + entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no]; + entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no]; + /* Decide whether we really care about the coefficient values */ + if (compptr->component_needed) { + entropy->dc_needed[blkn] = TRUE; + /* we don't need the ACs if producing a 1/8th-size image */ + entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1); + } else { + entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE; + } + } + + /* Initialize bitread state variables */ + entropy->bitstate.bits_left = 0; + entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */ + entropy->pub.insufficient_data = FALSE; + + /* Initialize restart counter */ + entropy->restarts_to_go = cinfo->restart_interval; +} + + +/* + * Compute the derived values for a Huffman table. + * This routine also performs some validation checks on the table. + * + * Note this is also used by jdphuff.c. + */ + +GLOBAL(void) +jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno, + d_derived_tbl ** pdtbl) +{ + JHUFF_TBL *htbl; + d_derived_tbl *dtbl; + int p, i, l, si, numsymbols; + int lookbits, ctr; + char huffsize[257]; + unsigned int huffcode[257]; + unsigned int code; + + /* Note that huffsize[] and huffcode[] are filled in code-length order, + * paralleling the order of the symbols themselves in htbl->huffval[]. + */ + + /* Find the input Huffman table */ + if (tblno < 0 || tblno >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); + htbl = + isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno]; + if (htbl == NULL) + ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); + + /* Allocate a workspace if we haven't already done so. */ + if (*pdtbl == NULL) + *pdtbl = (d_derived_tbl *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(d_derived_tbl)); + dtbl = *pdtbl; + dtbl->pub = htbl; /* fill in back link */ + + /* Figure C.1: make table of Huffman code length for each symbol */ + + p = 0; + for (l = 1; l <= 16; l++) { + i = (int) htbl->bits[l]; + if (i < 0 || p + i > 256) /* protect against table overrun */ + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + while (i--) + huffsize[p++] = (char) l; + } + huffsize[p] = 0; + numsymbols = p; + + /* Figure C.2: generate the codes themselves */ + /* We also validate that the counts represent a legal Huffman code tree. */ + + code = 0; + si = huffsize[0]; + p = 0; + while (huffsize[p]) { + while (((int) huffsize[p]) == si) { + huffcode[p++] = code; + code++; + } + /* code is now 1 more than the last code used for codelength si; but + * it must still fit in si bits, since no code is allowed to be all ones. + */ + if (((INT32) code) >= (((INT32) 1) << si)) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + code <<= 1; + si++; + } + + /* Figure F.15: generate decoding tables for bit-sequential decoding */ + + p = 0; + for (l = 1; l <= 16; l++) { + if (htbl->bits[l]) { + /* valoffset[l] = huffval[] index of 1st symbol of code length l, + * minus the minimum code of length l + */ + dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p]; + p += htbl->bits[l]; + dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */ + } else { + dtbl->maxcode[l] = -1; /* -1 if no codes of this length */ + } + } + dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */ + + /* Compute lookahead tables to speed up decoding. + * First we set all the table entries to 0, indicating "too long"; + * then we iterate through the Huffman codes that are short enough and + * fill in all the entries that correspond to bit sequences starting + * with that code. + */ + + MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits)); + + p = 0; + for (l = 1; l <= HUFF_LOOKAHEAD; l++) { + for (i = 1; i <= (int) htbl->bits[l]; i++, p++) { + /* l = current code's length, p = its index in huffcode[] & huffval[]. */ + /* Generate left-justified code followed by all possible bit sequences */ + lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l); + for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) { + dtbl->look_nbits[lookbits] = l; + dtbl->look_sym[lookbits] = htbl->huffval[p]; + lookbits++; + } + } + } + + /* Validate symbols as being reasonable. + * For AC tables, we make no check, but accept all byte values 0..255. + * For DC tables, we require the symbols to be in range 0..15. + * (Tighter bounds could be applied depending on the data depth and mode, + * but this is sufficient to ensure safe decoding.) + */ + if (isDC) { + for (i = 0; i < numsymbols; i++) { + int sym = htbl->huffval[i]; + if (sym < 0 || sym > 15) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + } + } +} + + +/* + * Out-of-line code for bit fetching (shared with jdphuff.c). + * See jdhuff.h for info about usage. + * Note: current values of get_buffer and bits_left are passed as parameters, + * but are returned in the corresponding fields of the state struct. + * + * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width + * of get_buffer to be used. (On machines with wider words, an even larger + * buffer could be used.) However, on some machines 32-bit shifts are + * quite slow and take time proportional to the number of places shifted. + * (This is true with most PC compilers, for instance.) In this case it may + * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the + * average shift distance at the cost of more calls to jpeg_fill_bit_buffer. + */ + +#ifdef SLOW_SHIFT_32 +#define MIN_GET_BITS 15 /* minimum allowable value */ +#else +#define MIN_GET_BITS (BIT_BUF_SIZE-7) +#endif + + +GLOBAL(boolean) +jpeg_fill_bit_buffer (bitread_working_state * state, + register bit_buf_type get_buffer, register int bits_left, + int nbits) +/* Load up the bit buffer to a depth of at least nbits */ +{ + /* Copy heavily used state fields into locals (hopefully registers) */ + register const JOCTET * next_input_byte = state->next_input_byte; + register size_t bytes_in_buffer = state->bytes_in_buffer; + j_decompress_ptr cinfo = state->cinfo; + + /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */ + /* (It is assumed that no request will be for more than that many bits.) */ + /* We fail to do so only if we hit a marker or are forced to suspend. */ + + if (cinfo->unread_marker == 0) { /* cannot advance past a marker */ + while (bits_left < MIN_GET_BITS) { + register int c; + + /* Attempt to read a byte */ + if (bytes_in_buffer == 0) { + if (! (*cinfo->src->fill_input_buffer) (cinfo)) + return FALSE; + next_input_byte = cinfo->src->next_input_byte; + bytes_in_buffer = cinfo->src->bytes_in_buffer; + } + bytes_in_buffer--; + c = GETJOCTET(*next_input_byte++); + + /* If it's 0xFF, check and discard stuffed zero byte */ + if (c == 0xFF) { + /* Loop here to discard any padding FF's on terminating marker, + * so that we can save a valid unread_marker value. NOTE: we will + * accept multiple FF's followed by a 0 as meaning a single FF data + * byte. This data pattern is not valid according to the standard. + */ + do { + if (bytes_in_buffer == 0) { + if (! (*cinfo->src->fill_input_buffer) (cinfo)) + return FALSE; + next_input_byte = cinfo->src->next_input_byte; + bytes_in_buffer = cinfo->src->bytes_in_buffer; + } + bytes_in_buffer--; + c = GETJOCTET(*next_input_byte++); + } while (c == 0xFF); + + if (c == 0) { + /* Found FF/00, which represents an FF data byte */ + c = 0xFF; + } else { + /* Oops, it's actually a marker indicating end of compressed data. + * Save the marker code for later use. + * Fine point: it might appear that we should save the marker into + * bitread working state, not straight into permanent state. But + * once we have hit a marker, we cannot need to suspend within the + * current MCU, because we will read no more bytes from the data + * source. So it is OK to update permanent state right away. + */ + cinfo->unread_marker = c; + /* See if we need to insert some fake zero bits. */ + goto no_more_bytes; + } + } + + /* OK, load c into get_buffer */ + get_buffer = (get_buffer << 8) | c; + bits_left += 8; + } /* end while */ + } else { + no_more_bytes: + /* We get here if we've read the marker that terminates the compressed + * data segment. There should be enough bits in the buffer register + * to satisfy the request; if so, no problem. + */ + if (nbits > bits_left) { + /* Uh-oh. Report corrupted data to user and stuff zeroes into + * the data stream, so that we can produce some kind of image. + * We use a nonvolatile flag to ensure that only one warning message + * appears per data segment. + */ + if (! cinfo->entropy->insufficient_data) { + WARNMS(cinfo, JWRN_HIT_MARKER); + cinfo->entropy->insufficient_data = TRUE; + } + /* Fill the buffer with zero bits */ + get_buffer <<= MIN_GET_BITS - bits_left; + bits_left = MIN_GET_BITS; + } + } + + /* Unload the local registers */ + state->next_input_byte = next_input_byte; + state->bytes_in_buffer = bytes_in_buffer; + state->get_buffer = get_buffer; + state->bits_left = bits_left; + + return TRUE; +} + + +/* + * Out-of-line code for Huffman code decoding. + * See jdhuff.h for info about usage. + */ + +GLOBAL(int) +jpeg_huff_decode (bitread_working_state * state, + register bit_buf_type get_buffer, register int bits_left, + d_derived_tbl * htbl, int min_bits) +{ + register int l = min_bits; + register INT32 code; + + /* HUFF_DECODE has determined that the code is at least min_bits */ + /* bits long, so fetch that many bits in one swoop. */ + + CHECK_BIT_BUFFER(*state, l, return -1); + code = GET_BITS(l); + + /* Collect the rest of the Huffman code one bit at a time. */ + /* This is per Figure F.16 in the JPEG spec. */ + + while (code > htbl->maxcode[l]) { + code <<= 1; + CHECK_BIT_BUFFER(*state, 1, return -1); + code |= GET_BITS(1); + l++; + } + + /* Unload the local registers */ + state->get_buffer = get_buffer; + state->bits_left = bits_left; + + /* With garbage input we may reach the sentinel value l = 17. */ + + if (l > 16) { + WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE); + return 0; /* fake a zero as the safest result */ + } + + return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ]; +} + + +/* + * Figure F.12: extend sign bit. + * On some machines, a shift and add will be faster than a table lookup. + */ + +#ifdef AVOID_TABLES + +#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x)) + +#else + +#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x)) + +static const int extend_test[16] = /* entry n is 2**(n-1) */ + { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, + 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 }; + +static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */ + { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1, + ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1, + ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1, + ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 }; + +#endif /* AVOID_TABLES */ + + +/* + * Check for a restart marker & resynchronize decoder. + * Returns FALSE if must suspend. + */ + +LOCAL(boolean) +process_restart (j_decompress_ptr cinfo) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int ci; + + /* Throw away any unused bits remaining in bit buffer; */ + /* include any full bytes in next_marker's count of discarded bytes */ + cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8; + entropy->bitstate.bits_left = 0; + + /* Advance past the RSTn marker */ + if (! (*cinfo->marker->read_restart_marker) (cinfo)) + return FALSE; + + /* Re-initialize DC predictions to 0 */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) + entropy->saved.last_dc_val[ci] = 0; + + /* Reset restart counter */ + entropy->restarts_to_go = cinfo->restart_interval; + + /* Reset out-of-data flag, unless read_restart_marker left us smack up + * against a marker. In that case we will end up treating the next data + * segment as empty, and we can avoid producing bogus output pixels by + * leaving the flag set. + */ + if (cinfo->unread_marker == 0) + entropy->pub.insufficient_data = FALSE; + + return TRUE; +} + +/* + * Save the current Huffman deocde position and the DC coefficients + * for each component into bitstream_offset and dc_info[], respectively. + */ +METHODDEF(void) +get_huffman_decoder_configuration(j_decompress_ptr cinfo, + huffman_offset_data *offset) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + short int *dc_info = offset->prev_dc; + int i; + jpeg_get_huffman_decoder_configuration(cinfo, offset); + for (i = 0; i < cinfo->comps_in_scan; i++) { + dc_info[i] = entropy->saved.last_dc_val[i]; + } +} + +/* + * Save the current Huffman decoder position and the bit buffer + * into bitstream_offset and get_buffer, respectively. + */ +GLOBAL(void) +jpeg_get_huffman_decoder_configuration(j_decompress_ptr cinfo, + huffman_offset_data *offset) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + + if (cinfo->restart_interval) { + // We are at the end of a data segment + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return; + } + + // Save restarts_to_go and next_restart_num + offset->restarts_to_go = (unsigned short) entropy->restarts_to_go; + offset->next_restart_num = cinfo->marker->next_restart_num; + + offset->bitstream_offset = + (jget_input_stream_position(cinfo) << LOG_TWO_BIT_BUF_SIZE) + + entropy->bitstate.bits_left; + + offset->get_buffer = entropy->bitstate.get_buffer; +} + +/* + * Configure the Huffman decoder to decode the image + * starting from the bitstream position recorded in offset. + */ +METHODDEF(void) +configure_huffman_decoder(j_decompress_ptr cinfo, huffman_offset_data offset) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + short int *dc_info = offset.prev_dc; + int i; + jpeg_configure_huffman_decoder(cinfo, offset); + for (i = 0; i < cinfo->comps_in_scan; i++) { + entropy->saved.last_dc_val[i] = dc_info[i]; + } +} + +/* + * Configure the Huffman decoder reader position and bit buffer. + */ +GLOBAL(void) +jpeg_configure_huffman_decoder(j_decompress_ptr cinfo, + huffman_offset_data offset) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + + // Restore restarts_to_go and next_restart_num + cinfo->unread_marker = 0; + entropy->restarts_to_go = offset.restarts_to_go; + cinfo->marker->next_restart_num = offset.next_restart_num; + + unsigned int bitstream_offset = offset.bitstream_offset; + int blkn, i; + + unsigned int byte_offset = bitstream_offset >> LOG_TWO_BIT_BUF_SIZE; + unsigned int bit_in_bit_buffer = + bitstream_offset & ((1 << LOG_TWO_BIT_BUF_SIZE) - 1); + + jset_input_stream_position_bit(cinfo, byte_offset, + bit_in_bit_buffer, offset.get_buffer); +} + +/* + * Decode and return one MCU's worth of Huffman-compressed coefficients. + * The coefficients are reordered from zigzag order into natural array order, + * but are not dequantized. + * + * The i'th block of the MCU is stored into the block pointed to by + * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER. + * (Wholesale zeroing is usually a little faster than retail...) + * + * Returns FALSE if data source requested suspension. In that case no + * changes have been made to permanent state. (Exception: some output + * coefficients may already have been assigned. This is harmless for + * this module, since we'll just re-assign them on the next call.) + */ + +METHODDEF(boolean) +decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int blkn; + BITREAD_STATE_VARS; + savable_state state; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + /* If we've run out of data, just leave the MCU set to zeroes. + * This way, we return uniform gray for the remainder of the segment. + */ + if (! entropy->pub.insufficient_data) { + /* Load up working state */ + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(state, entropy->saved); + + /* Outer loop handles each block in the MCU */ + + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + JBLOCKROW block = MCU_data[blkn]; + d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn]; + d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn]; + register int s, k, r; + + /* Decode a single block's worth of coefficients */ + + /* Section F.2.2.1: decode the DC coefficient difference */ + HUFF_DECODE(s, br_state, dctbl, return FALSE, label1); + if (s) { + CHECK_BIT_BUFFER(br_state, s, return FALSE); + r = GET_BITS(s); + s = HUFF_EXTEND(r, s); + } + + if (entropy->dc_needed[blkn]) { + /* Convert DC difference to actual value, update last_dc_val */ + int ci = cinfo->MCU_membership[blkn]; + s += state.last_dc_val[ci]; + state.last_dc_val[ci] = s; + /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */ + (*block)[0] = (JCOEF) s; + } + + if (entropy->ac_needed[blkn]) { + + /* Section F.2.2.2: decode the AC coefficients */ + /* Since zeroes are skipped, output area must be cleared beforehand */ + for (k = 1; k < DCTSIZE2; k++) { + HUFF_DECODE(s, br_state, actbl, return FALSE, label2); + + r = s >> 4; + s &= 15; + + if (s) { + k += r; + CHECK_BIT_BUFFER(br_state, s, return FALSE); + r = GET_BITS(s); + s = HUFF_EXTEND(r, s); + /* Output coefficient in natural (dezigzagged) order. + * Note: the extra entries in jpeg_natural_order[] will save us + * if k >= DCTSIZE2, which could happen if the data is corrupted. + */ + (*block)[jpeg_natural_order[k]] = (JCOEF) s; + } else { + if (r != 15) + break; + k += 15; + } + } + + } else { + + /* Section F.2.2.2: decode the AC coefficients */ + /* In this path we just discard the values */ + for (k = 1; k < DCTSIZE2; k++) { + HUFF_DECODE(s, br_state, actbl, return FALSE, label3); + + r = s >> 4; + s &= 15; + + if (s) { + k += r; + CHECK_BIT_BUFFER(br_state, s, return FALSE); + DROP_BITS(s); + } else { + if (r != 15) + break; + k += 15; + } + } + + } + } + + /* Completed MCU, so update state */ + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(entropy->saved, state); + } + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; +} + +/* + * Decode one MCU's worth of Huffman-compressed coefficients. + * The propose of this method is to calculate the + * data length of one MCU in Huffman-coded format. + * Therefore, all coefficients are discarded. + */ + +METHODDEF(boolean) +decode_mcu_discard_coef (j_decompress_ptr cinfo) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + int blkn; + BITREAD_STATE_VARS; + savable_state state; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + if (! entropy->pub.insufficient_data) { + + /* Load up working state */ + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(state, entropy->saved); + + /* Outer loop handles each block in the MCU */ + + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn]; + d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn]; + register int s, k, r; + + /* Decode a single block's worth of coefficients */ + + /* Section F.2.2.1: decode the DC coefficient difference */ + HUFF_DECODE(s, br_state, dctbl, return FALSE, label1); + if (s) { + CHECK_BIT_BUFFER(br_state, s, return FALSE); + r = GET_BITS(s); + s = HUFF_EXTEND(r, s); + } + + /* discard all coefficients */ + if (entropy->dc_needed[blkn]) { + /* Convert DC difference to actual value, update last_dc_val */ + int ci = cinfo->MCU_membership[blkn]; + s += state.last_dc_val[ci]; + state.last_dc_val[ci] = s; + } + for (k = 1; k < DCTSIZE2; k++) { + HUFF_DECODE(s, br_state, actbl, return FALSE, label3); + + r = s >> 4; + s &= 15; + + if (s) { + k += r; + CHECK_BIT_BUFFER(br_state, s, return FALSE); + DROP_BITS(s); + } else { + if (r != 15) + break; + k += 15; + } + } + } + + /* Completed MCU, so update state */ + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(entropy->saved, state); + } + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; +} + + +/* + * Module initialization routine for Huffman entropy decoding. + */ + +GLOBAL(void) +jinit_huff_decoder (j_decompress_ptr cinfo) +{ + huff_entropy_ptr entropy; + int i; + + entropy = (huff_entropy_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(huff_entropy_decoder)); + cinfo->entropy = (struct jpeg_entropy_decoder *) entropy; + entropy->pub.start_pass = start_pass_huff_decoder; + entropy->pub.decode_mcu = decode_mcu; + entropy->pub.decode_mcu_discard_coef = decode_mcu_discard_coef; + entropy->pub.configure_huffman_decoder = configure_huffman_decoder; + entropy->pub.get_huffman_decoder_configuration = + get_huffman_decoder_configuration; + entropy->pub.index = NULL; + + /* Mark tables unallocated */ + for (i = 0; i < NUM_HUFF_TBLS; i++) { + entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; + } +} + +/* + * Call after jpeg_read_header + */ +GLOBAL(void) +jpeg_create_huffman_index(j_decompress_ptr cinfo, huffman_index *index) +{ + int i, s; + index->scan_count = 1; + index->total_iMCU_rows = cinfo->total_iMCU_rows; + index->scan = (huffman_scan_header*)malloc(index->scan_count + * sizeof(huffman_scan_header)); + index->scan[0].offset = (huffman_offset_data**)malloc(cinfo->total_iMCU_rows + * sizeof(huffman_offset_data*)); + index->scan[0].prev_MCU_offset.bitstream_offset = 0; + index->MCU_sample_size = DEFAULT_MCU_SAMPLE_SIZE; + + index->mem_used = sizeof(huffman_scan_header) + + cinfo->total_iMCU_rows * sizeof(huffman_offset_data*); +} + +GLOBAL(void) +jpeg_destroy_huffman_index(huffman_index *index) +{ + int i, j; + for (i = 0; i < index->scan_count; i++) { + for(j = 0; j < index->total_iMCU_rows; j++) { + free(index->scan[i].offset[j]); + } + free(index->scan[i].offset); + } + free(index->scan); +} + +/* + * Set the reader byte position to offset + */ +GLOBAL(void) +jset_input_stream_position(j_decompress_ptr cinfo, int offset) +{ + if (cinfo->src->seek_input_data) { + cinfo->src->seek_input_data(cinfo, offset); + } else { + cinfo->src->bytes_in_buffer = cinfo->src->current_offset - offset; + cinfo->src->next_input_byte = cinfo->src->start_input_byte + offset; + } +} + +/* + * Set the reader byte position to offset and bit position to bit_left + * with bit buffer set to buf. + */ +GLOBAL(void) +jset_input_stream_position_bit(j_decompress_ptr cinfo, + int byte_offset, int bit_left, INT32 buf) +{ + huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; + + entropy->bitstate.bits_left = bit_left; + entropy->bitstate.get_buffer = buf; + + jset_input_stream_position(cinfo, byte_offset); +} + +/* + * Get the current reader byte position. + */ +GLOBAL(int) +jget_input_stream_position(j_decompress_ptr cinfo) +{ + return cinfo->src->current_offset - cinfo->src->bytes_in_buffer; +} diff --git a/TMessagesProj/jni/libjpeg/jdhuff.h b/TMessagesProj/jni/libjpeg/jdhuff.h new file mode 100755 index 000000000..5760a134e --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdhuff.h @@ -0,0 +1,202 @@ +/* + * jdhuff.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains declarations for Huffman entropy decoding routines + * that are shared between the sequential decoder (jdhuff.c) and the + * progressive decoder (jdphuff.c). No other modules need to see these. + */ + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_make_d_derived_tbl jMkDDerived +#define jpeg_fill_bit_buffer jFilBitBuf +#define jpeg_huff_decode jHufDecode +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Derived data constructed for each Huffman table */ + +#define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */ + +typedef struct { + /* Basic tables: (element [0] of each array is unused) */ + INT32 maxcode[18]; /* largest code of length k (-1 if none) */ + /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */ + INT32 valoffset[17]; /* huffval[] offset for codes of length k */ + /* valoffset[k] = huffval[] index of 1st symbol of code length k, less + * the smallest code of length k; so given a code of length k, the + * corresponding symbol is huffval[code + valoffset[k]] + */ + + /* Link to public Huffman table (needed only in jpeg_huff_decode) */ + JHUFF_TBL *pub; + + /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of + * the input data stream. If the next Huffman code is no more + * than HUFF_LOOKAHEAD bits long, we can obtain its length and + * the corresponding symbol directly from these tables. + */ + int look_nbits[1< 32 bits on your machine, and shifting/masking longs is + * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE + * appropriately should be a win. Unfortunately we can't define the size + * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8) + * because not all machines measure sizeof in 8-bit bytes. + */ + +typedef struct { /* Bitreading state saved across MCUs */ + bit_buf_type get_buffer; /* current bit-extraction buffer */ + int bits_left; /* # of unused bits in it */ +} bitread_perm_state; + +typedef struct { /* Bitreading working state within an MCU */ + /* Current data source location */ + /* We need a copy, rather than munging the original, in case of suspension */ + const JOCTET * next_input_byte; /* => next byte to read from source */ + size_t bytes_in_buffer; /* # of bytes remaining in source buffer */ + /* Bit input buffer --- note these values are kept in register variables, + * not in this struct, inside the inner loops. + */ + bit_buf_type get_buffer; /* current bit-extraction buffer */ + int bits_left; /* # of unused bits in it */ + /* Pointer needed by jpeg_fill_bit_buffer. */ + j_decompress_ptr cinfo; /* back link to decompress master record */ +} bitread_working_state; + +/* Macros to declare and load/save bitread local variables. */ +#define BITREAD_STATE_VARS \ + register bit_buf_type get_buffer; \ + register int bits_left; \ + bitread_working_state br_state + +#define BITREAD_LOAD_STATE(cinfop,permstate) \ + br_state.cinfo = cinfop; \ + br_state.next_input_byte = cinfop->src->next_input_byte; \ + br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \ + get_buffer = permstate.get_buffer; \ + bits_left = permstate.bits_left; + +#define BITREAD_SAVE_STATE(cinfop,permstate) \ + cinfop->src->next_input_byte = br_state.next_input_byte; \ + cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \ + permstate.get_buffer = get_buffer; \ + permstate.bits_left = bits_left + +/* + * These macros provide the in-line portion of bit fetching. + * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer + * before using GET_BITS, PEEK_BITS, or DROP_BITS. + * The variables get_buffer and bits_left are assumed to be locals, + * but the state struct might not be (jpeg_huff_decode needs this). + * CHECK_BIT_BUFFER(state,n,action); + * Ensure there are N bits in get_buffer; if suspend, take action. + * val = GET_BITS(n); + * Fetch next N bits. + * val = PEEK_BITS(n); + * Fetch next N bits without removing them from the buffer. + * DROP_BITS(n); + * Discard next N bits. + * The value N should be a simple variable, not an expression, because it + * is evaluated multiple times. + */ + +#define CHECK_BIT_BUFFER(state,nbits,action) \ + { if (bits_left < (nbits)) { \ + if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \ + { action; } \ + get_buffer = (state).get_buffer; bits_left = (state).bits_left; } } + +#define GET_BITS(nbits) \ + (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1)) + +#define PEEK_BITS(nbits) \ + (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1)) + +#define DROP_BITS(nbits) \ + (bits_left -= (nbits)) + +/* Load up the bit buffer to a depth of at least nbits */ +EXTERN(boolean) jpeg_fill_bit_buffer + JPP((bitread_working_state * state, register bit_buf_type get_buffer, + register int bits_left, int nbits)); + + +/* + * Code for extracting next Huffman-coded symbol from input bit stream. + * Again, this is time-critical and we make the main paths be macros. + * + * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits + * without looping. Usually, more than 95% of the Huffman codes will be 8 + * or fewer bits long. The few overlength codes are handled with a loop, + * which need not be inline code. + * + * Notes about the HUFF_DECODE macro: + * 1. Near the end of the data segment, we may fail to get enough bits + * for a lookahead. In that case, we do it the hard way. + * 2. If the lookahead table contains no entry, the next code must be + * more than HUFF_LOOKAHEAD bits long. + * 3. jpeg_huff_decode returns -1 if forced to suspend. + */ + +#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \ +{ register int nb, look; \ + if (bits_left < HUFF_LOOKAHEAD) { \ + if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \ + get_buffer = state.get_buffer; bits_left = state.bits_left; \ + if (bits_left < HUFF_LOOKAHEAD) { \ + nb = 1; goto slowlabel; \ + } \ + } \ + look = PEEK_BITS(HUFF_LOOKAHEAD); \ + if ((nb = htbl->look_nbits[look]) != 0) { \ + DROP_BITS(nb); \ + result = htbl->look_sym[look]; \ + } else { \ + nb = HUFF_LOOKAHEAD+1; \ +slowlabel: \ + if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \ + { failaction; } \ + get_buffer = state.get_buffer; bits_left = state.bits_left; \ + } \ +} + +/* Out-of-line case for Huffman code fetching */ +EXTERN(int) jpeg_huff_decode + JPP((bitread_working_state * state, register bit_buf_type get_buffer, + register int bits_left, d_derived_tbl * htbl, int min_bits)); diff --git a/TMessagesProj/jni/libjpeg/jdinput.c b/TMessagesProj/jni/libjpeg/jdinput.c new file mode 100755 index 000000000..4261c1a1c --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdinput.c @@ -0,0 +1,415 @@ +/* + * jdinput.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains input control logic for the JPEG decompressor. + * These routines are concerned with controlling the decompressor's input + * processing (marker reading and coefficient decoding). The actual input + * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Private state */ + +typedef struct { + struct jpeg_input_controller pub; /* public fields */ + + boolean inheaders; /* TRUE until first SOS is reached */ +} my_input_controller; + +typedef my_input_controller * my_inputctl_ptr; + + +/* Forward declarations */ +METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo)); +METHODDEF(int) consume_markers_with_huffman_index JPP((j_decompress_ptr cinfo, + huffman_index *index, int current_scan)); + + +/* + * Routines to calculate various quantities related to the size of the image. + */ + +LOCAL(void) +initial_setup (j_decompress_ptr cinfo) +/* Called once, when first SOS marker is reached */ +{ + int ci; + jpeg_component_info *compptr; + + /* Make sure image isn't bigger than I can handle */ + if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || + (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) + ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); + + /* For now, precision must match compiled-in value... */ + if (cinfo->data_precision != BITS_IN_JSAMPLE) + ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); + + /* Check that number of components won't exceed internal array sizes */ + if (cinfo->num_components > MAX_COMPONENTS) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, + MAX_COMPONENTS); + + /* Compute maximum sampling factors; check factor validity */ + cinfo->max_h_samp_factor = 1; + cinfo->max_v_samp_factor = 1; + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || + compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) + ERREXIT(cinfo, JERR_BAD_SAMPLING); + cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, + compptr->h_samp_factor); + cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, + compptr->v_samp_factor); + } + + /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE. + * In the full decompressor, this will be overridden by jdmaster.c; + * but in the transcoder, jdmaster.c is not used, so we must do it here. + */ + cinfo->min_DCT_scaled_size = DCTSIZE; + + /* Compute dimensions of components */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + compptr->DCT_scaled_size = DCTSIZE; + /* Size in DCT blocks */ + compptr->width_in_blocks = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, + (long) (cinfo->max_h_samp_factor * DCTSIZE)); + compptr->height_in_blocks = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, + (long) (cinfo->max_v_samp_factor * DCTSIZE)); + /* downsampled_width and downsampled_height will also be overridden by + * jdmaster.c if we are doing full decompression. The transcoder library + * doesn't use these values, but the calling application might. + */ + /* Size in samples */ + compptr->downsampled_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, + (long) cinfo->max_h_samp_factor); + compptr->downsampled_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, + (long) cinfo->max_v_samp_factor); + /* Mark component needed, until color conversion says otherwise */ + compptr->component_needed = TRUE; + /* Mark no quantization table yet saved for component */ + compptr->quant_table = NULL; + } + + /* Compute number of fully interleaved MCU rows. */ + cinfo->total_iMCU_rows = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, + (long) (cinfo->max_v_samp_factor*DCTSIZE)); + + /* Decide whether file contains multiple scans */ + if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode) + cinfo->inputctl->has_multiple_scans = TRUE; + else + cinfo->inputctl->has_multiple_scans = FALSE; + cinfo->original_image_width = cinfo->image_width; +} + +LOCAL(void) +per_scan_setup (j_decompress_ptr cinfo) +/* Do computations that are needed before processing a JPEG scan */ +/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */ +{ + int ci, mcublks, tmp; + jpeg_component_info *compptr; + + if (cinfo->comps_in_scan == 1) { + + /* Noninterleaved (single-component) scan */ + compptr = cinfo->cur_comp_info[0]; + + /* Overall image size in MCUs */ + cinfo->MCUs_per_row = compptr->width_in_blocks; + cinfo->MCU_rows_in_scan = compptr->height_in_blocks; + + /* For noninterleaved scan, always one block per MCU */ + compptr->MCU_width = 1; + compptr->MCU_height = 1; + compptr->MCU_blocks = 1; + compptr->MCU_sample_width = compptr->DCT_scaled_size; + compptr->last_col_width = 1; + /* For noninterleaved scans, it is convenient to define last_row_height + * as the number of block rows present in the last iMCU row. + */ + tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); + if (tmp == 0) tmp = compptr->v_samp_factor; + compptr->last_row_height = tmp; + + /* Prepare array describing MCU composition */ + cinfo->blocks_in_MCU = 1; + cinfo->MCU_membership[0] = 0; + + } else { + + /* Interleaved (multi-component) scan */ + if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) + ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, + MAX_COMPS_IN_SCAN); + + /* Overall image size in MCUs */ + cinfo->MCUs_per_row = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width, + (long) (cinfo->max_h_samp_factor*DCTSIZE)); + cinfo->MCU_rows_in_scan = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, + (long) (cinfo->max_v_samp_factor*DCTSIZE)); + + cinfo->blocks_in_MCU = 0; + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* Sampling factors give # of blocks of component in each MCU */ + compptr->MCU_width = compptr->h_samp_factor; + compptr->MCU_height = compptr->v_samp_factor; + compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; + compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size; + /* Figure number of non-dummy blocks in last MCU column & row */ + tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); + if (tmp == 0) tmp = compptr->MCU_width; + compptr->last_col_width = tmp; +#ifdef ANDROID_TILE_BASED_DECODE + if (cinfo->tile_decode) { + tmp = (int) (jdiv_round_up(cinfo->image_width, 8) + % compptr->MCU_width); + if (tmp == 0) tmp = compptr->MCU_width; + compptr->last_col_width = tmp; + } +#endif + + tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); + if (tmp == 0) tmp = compptr->MCU_height; + compptr->last_row_height = tmp; + /* Prepare array describing MCU composition */ + mcublks = compptr->MCU_blocks; + if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU) + ERREXIT(cinfo, JERR_BAD_MCU_SIZE); + while (mcublks-- > 0) { + cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; + } + } + + } +} + +GLOBAL(void) +jpeg_decompress_per_scan_setup(j_decompress_ptr cinfo) +{ + per_scan_setup(cinfo); +} + + + +/* + * Save away a copy of the Q-table referenced by each component present + * in the current scan, unless already saved during a prior scan. + * + * In a multiple-scan JPEG file, the encoder could assign different components + * the same Q-table slot number, but change table definitions between scans + * so that each component uses a different Q-table. (The IJG encoder is not + * currently capable of doing this, but other encoders might.) Since we want + * to be able to dequantize all the components at the end of the file, this + * means that we have to save away the table actually used for each component. + * We do this by copying the table at the start of the first scan containing + * the component. + * The JPEG spec prohibits the encoder from changing the contents of a Q-table + * slot between scans of a component using that slot. If the encoder does so + * anyway, this decoder will simply use the Q-table values that were current + * at the start of the first scan for the component. + * + * The decompressor output side looks only at the saved quant tables, + * not at the current Q-table slots. + */ + +LOCAL(void) +latch_quant_tables (j_decompress_ptr cinfo) +{ + int ci, qtblno; + jpeg_component_info *compptr; + JQUANT_TBL * qtbl; + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* No work if we already saved Q-table for this component */ + if (compptr->quant_table != NULL) + continue; + /* Make sure specified quantization table is present */ + qtblno = compptr->quant_tbl_no; + if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || + cinfo->quant_tbl_ptrs[qtblno] == NULL) + ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); + /* OK, save away the quantization table */ + qtbl = (JQUANT_TBL *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(JQUANT_TBL)); + MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL)); + compptr->quant_table = qtbl; + } +} + + +/* + * Initialize the input modules to read a scan of compressed data. + * The first call to this is done by jdmaster.c after initializing + * the entire decompressor (during jpeg_start_decompress). + * Subsequent calls come from consume_markers, below. + */ + +METHODDEF(void) +start_input_pass (j_decompress_ptr cinfo) +{ + per_scan_setup(cinfo); + latch_quant_tables(cinfo); + (*cinfo->entropy->start_pass) (cinfo); + (*cinfo->coef->start_input_pass) (cinfo); + cinfo->inputctl->consume_input = cinfo->coef->consume_data; + cinfo->inputctl->consume_input_build_huffman_index = + cinfo->coef->consume_data_build_huffman_index; +} + + +/* + * Finish up after inputting a compressed-data scan. + * This is called by the coefficient controller after it's read all + * the expected data of the scan. + */ + +METHODDEF(void) +finish_input_pass (j_decompress_ptr cinfo) +{ + cinfo->inputctl->consume_input = consume_markers; + cinfo->inputctl->consume_input_build_huffman_index = + consume_markers_with_huffman_index; +} + + +METHODDEF(int) +consume_markers_with_huffman_index (j_decompress_ptr cinfo, + huffman_index *index, int current_scan) +{ + return consume_markers(cinfo); +} +/* + * Read JPEG markers before, between, or after compressed-data scans. + * Change state as necessary when a new scan is reached. + * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. + * + * The consume_input method pointer points either here or to the + * coefficient controller's consume_data routine, depending on whether + * we are reading a compressed data segment or inter-segment markers. + */ + +METHODDEF(int) +consume_markers (j_decompress_ptr cinfo) +{ + my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; + int val; + + if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */ + return JPEG_REACHED_EOI; + + val = (*cinfo->marker->read_markers) (cinfo); + + switch (val) { + case JPEG_REACHED_SOS: /* Found SOS */ + if (inputctl->inheaders) { /* 1st SOS */ + initial_setup(cinfo); + inputctl->inheaders = FALSE; + /* Note: start_input_pass must be called by jdmaster.c + * before any more input can be consumed. jdapimin.c is + * responsible for enforcing this sequencing. + */ + } else { /* 2nd or later SOS marker */ + if (! inputctl->pub.has_multiple_scans) + ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */ + start_input_pass(cinfo); + } + break; + case JPEG_REACHED_EOI: /* Found EOI */ + inputctl->pub.eoi_reached = TRUE; + if (inputctl->inheaders) { /* Tables-only datastream, apparently */ + if (cinfo->marker->saw_SOF) + ERREXIT(cinfo, JERR_SOF_NO_SOS); + } else { + /* Prevent infinite loop in coef ctlr's decompress_data routine + * if user set output_scan_number larger than number of scans. + */ + if (cinfo->output_scan_number > cinfo->input_scan_number) + cinfo->output_scan_number = cinfo->input_scan_number; + } + break; + case JPEG_SUSPENDED: + break; + } + + return val; +} + + +/* + * Reset state to begin a fresh datastream. + */ + +METHODDEF(void) +reset_input_controller (j_decompress_ptr cinfo) +{ + my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; + + inputctl->pub.consume_input = consume_markers; + inputctl->pub.consume_input_build_huffman_index = + consume_markers_with_huffman_index; + inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ + inputctl->pub.eoi_reached = FALSE; + inputctl->inheaders = TRUE; + /* Reset other modules */ + (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); + (*cinfo->marker->reset_marker_reader) (cinfo); + /* Reset progression state -- would be cleaner if entropy decoder did this */ + cinfo->coef_bits = NULL; +} + + +/* + * Initialize the input controller module. + * This is called only once, when the decompression object is created. + */ + +GLOBAL(void) +jinit_input_controller (j_decompress_ptr cinfo) +{ + my_inputctl_ptr inputctl; + + /* Create subobject in permanent pool */ + inputctl = (my_inputctl_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + SIZEOF(my_input_controller)); + cinfo->inputctl = (struct jpeg_input_controller *) inputctl; + /* Initialize method pointers */ + inputctl->pub.consume_input = consume_markers; + inputctl->pub.reset_input_controller = reset_input_controller; + inputctl->pub.start_input_pass = start_input_pass; + inputctl->pub.finish_input_pass = finish_input_pass; + + inputctl->pub.consume_markers = consume_markers_with_huffman_index; + inputctl->pub.consume_input_build_huffman_index = + consume_markers_with_huffman_index; + /* Initialize state: can't use reset_input_controller since we don't + * want to try to reset other modules yet. + */ + inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ + inputctl->pub.eoi_reached = FALSE; + inputctl->inheaders = TRUE; +} diff --git a/TMessagesProj/jni/libjpeg/jdmainct.c b/TMessagesProj/jni/libjpeg/jdmainct.c new file mode 100755 index 000000000..13c956f5d --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdmainct.c @@ -0,0 +1,512 @@ +/* + * jdmainct.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the main buffer controller for decompression. + * The main buffer lies between the JPEG decompressor proper and the + * post-processor; it holds downsampled data in the JPEG colorspace. + * + * Note that this code is bypassed in raw-data mode, since the application + * supplies the equivalent of the main buffer in that case. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * In the current system design, the main buffer need never be a full-image + * buffer; any full-height buffers will be found inside the coefficient or + * postprocessing controllers. Nonetheless, the main controller is not + * trivial. Its responsibility is to provide context rows for upsampling/ + * rescaling, and doing this in an efficient fashion is a bit tricky. + * + * Postprocessor input data is counted in "row groups". A row group + * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size) + * sample rows of each component. (We require DCT_scaled_size values to be + * chosen such that these numbers are integers. In practice DCT_scaled_size + * values will likely be powers of two, so we actually have the stronger + * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.) + * Upsampling will typically produce max_v_samp_factor pixel rows from each + * row group (times any additional scale factor that the upsampler is + * applying). + * + * The coefficient controller will deliver data to us one iMCU row at a time; + * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or + * exactly min_DCT_scaled_size row groups. (This amount of data corresponds + * to one row of MCUs when the image is fully interleaved.) Note that the + * number of sample rows varies across components, but the number of row + * groups does not. Some garbage sample rows may be included in the last iMCU + * row at the bottom of the image. + * + * Depending on the vertical scaling algorithm used, the upsampler may need + * access to the sample row(s) above and below its current input row group. + * The upsampler is required to set need_context_rows TRUE at global selection + * time if so. When need_context_rows is FALSE, this controller can simply + * obtain one iMCU row at a time from the coefficient controller and dole it + * out as row groups to the postprocessor. + * + * When need_context_rows is TRUE, this controller guarantees that the buffer + * passed to postprocessing contains at least one row group's worth of samples + * above and below the row group(s) being processed. Note that the context + * rows "above" the first passed row group appear at negative row offsets in + * the passed buffer. At the top and bottom of the image, the required + * context rows are manufactured by duplicating the first or last real sample + * row; this avoids having special cases in the upsampling inner loops. + * + * The amount of context is fixed at one row group just because that's a + * convenient number for this controller to work with. The existing + * upsamplers really only need one sample row of context. An upsampler + * supporting arbitrary output rescaling might wish for more than one row + * group of context when shrinking the image; tough, we don't handle that. + * (This is justified by the assumption that downsizing will be handled mostly + * by adjusting the DCT_scaled_size values, so that the actual scale factor at + * the upsample step needn't be much less than one.) + * + * To provide the desired context, we have to retain the last two row groups + * of one iMCU row while reading in the next iMCU row. (The last row group + * can't be processed until we have another row group for its below-context, + * and so we have to save the next-to-last group too for its above-context.) + * We could do this most simply by copying data around in our buffer, but + * that'd be very slow. We can avoid copying any data by creating a rather + * strange pointer structure. Here's how it works. We allocate a workspace + * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number + * of row groups per iMCU row). We create two sets of redundant pointers to + * the workspace. Labeling the physical row groups 0 to M+1, the synthesized + * pointer lists look like this: + * M+1 M-1 + * master pointer --> 0 master pointer --> 0 + * 1 1 + * ... ... + * M-3 M-3 + * M-2 M + * M-1 M+1 + * M M-2 + * M+1 M-1 + * 0 0 + * We read alternate iMCU rows using each master pointer; thus the last two + * row groups of the previous iMCU row remain un-overwritten in the workspace. + * The pointer lists are set up so that the required context rows appear to + * be adjacent to the proper places when we pass the pointer lists to the + * upsampler. + * + * The above pictures describe the normal state of the pointer lists. + * At top and bottom of the image, we diddle the pointer lists to duplicate + * the first or last sample row as necessary (this is cheaper than copying + * sample rows around). + * + * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1. In that + * situation each iMCU row provides only one row group so the buffering logic + * must be different (eg, we must read two iMCU rows before we can emit the + * first row group). For now, we simply do not support providing context + * rows when min_DCT_scaled_size is 1. That combination seems unlikely to + * be worth providing --- if someone wants a 1/8th-size preview, they probably + * want it quick and dirty, so a context-free upsampler is sufficient. + */ + + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_d_main_controller pub; /* public fields */ + + /* Pointer to allocated workspace (M or M+2 row groups). */ + JSAMPARRAY buffer[MAX_COMPONENTS]; + + boolean buffer_full; /* Have we gotten an iMCU row from decoder? */ + JDIMENSION rowgroup_ctr; /* counts row groups output to postprocessor */ + + /* Remaining fields are only used in the context case. */ + + /* These are the master pointers to the funny-order pointer lists. */ + JSAMPIMAGE xbuffer[2]; /* pointers to weird pointer lists */ + + int whichptr; /* indicates which pointer set is now in use */ + int context_state; /* process_data state machine status */ + JDIMENSION rowgroups_avail; /* row groups available to postprocessor */ + JDIMENSION iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */ +} my_main_controller; + +typedef my_main_controller * my_main_ptr; + +/* context_state values: */ +#define CTX_PREPARE_FOR_IMCU 0 /* need to prepare for MCU row */ +#define CTX_PROCESS_IMCU 1 /* feeding iMCU to postprocessor */ +#define CTX_POSTPONED_ROW 2 /* feeding postponed row group */ + + +/* Forward declarations */ +METHODDEF(void) process_data_simple_main + JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, + JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); +METHODDEF(void) process_data_context_main + JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, + JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); +#ifdef QUANT_2PASS_SUPPORTED +METHODDEF(void) process_data_crank_post + JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, + JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); +#endif + + +LOCAL(void) +alloc_funny_pointers (j_decompress_ptr cinfo) +/* Allocate space for the funny pointer lists. + * This is done only once, not once per pass. + */ +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + int ci, rgroup; + int M = cinfo->min_DCT_scaled_size; + jpeg_component_info *compptr; + JSAMPARRAY xbuf; + + /* Get top-level space for component array pointers. + * We alloc both arrays with one call to save a few cycles. + */ + main->xbuffer[0] = (JSAMPIMAGE) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + cinfo->num_components * 2 * SIZEOF(JSAMPARRAY)); + main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; /* height of a row group of component */ + /* Get space for pointer lists --- M+4 row groups in each list. + * We alloc both pointer lists with one call to save a few cycles. + */ + xbuf = (JSAMPARRAY) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW)); + xbuf += rgroup; /* want one row group at negative offsets */ + main->xbuffer[0][ci] = xbuf; + xbuf += rgroup * (M + 4); + main->xbuffer[1][ci] = xbuf; + } +} + + +LOCAL(void) +make_funny_pointers (j_decompress_ptr cinfo) +/* Create the funny pointer lists discussed in the comments above. + * The actual workspace is already allocated (in main->buffer), + * and the space for the pointer lists is allocated too. + * This routine just fills in the curiously ordered lists. + * This will be repeated at the beginning of each pass. + */ +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + int ci, i, rgroup; + int M = cinfo->min_DCT_scaled_size; + jpeg_component_info *compptr; + JSAMPARRAY buf, xbuf0, xbuf1; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; /* height of a row group of component */ + xbuf0 = main->xbuffer[0][ci]; + xbuf1 = main->xbuffer[1][ci]; + /* First copy the workspace pointers as-is */ + buf = main->buffer[ci]; + for (i = 0; i < rgroup * (M + 2); i++) { + xbuf0[i] = xbuf1[i] = buf[i]; + } + /* In the second list, put the last four row groups in swapped order */ + for (i = 0; i < rgroup * 2; i++) { + xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i]; + xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i]; + } + /* The wraparound pointers at top and bottom will be filled later + * (see set_wraparound_pointers, below). Initially we want the "above" + * pointers to duplicate the first actual data line. This only needs + * to happen in xbuffer[0]. + */ + for (i = 0; i < rgroup; i++) { + xbuf0[i - rgroup] = xbuf0[0]; + } + } +} + + +LOCAL(void) +set_wraparound_pointers (j_decompress_ptr cinfo) +/* Set up the "wraparound" pointers at top and bottom of the pointer lists. + * This changes the pointer list state from top-of-image to the normal state. + */ +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + int ci, i, rgroup; + int M = cinfo->min_DCT_scaled_size; + jpeg_component_info *compptr; + JSAMPARRAY xbuf0, xbuf1; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; /* height of a row group of component */ + xbuf0 = main->xbuffer[0][ci]; + xbuf1 = main->xbuffer[1][ci]; + for (i = 0; i < rgroup; i++) { + xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i]; + xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i]; + xbuf0[rgroup*(M+2) + i] = xbuf0[i]; + xbuf1[rgroup*(M+2) + i] = xbuf1[i]; + } + } +} + + +LOCAL(void) +set_bottom_pointers (j_decompress_ptr cinfo) +/* Change the pointer lists to duplicate the last sample row at the bottom + * of the image. whichptr indicates which xbuffer holds the final iMCU row. + * Also sets rowgroups_avail to indicate number of nondummy row groups in row. + */ +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + int ci, i, rgroup, iMCUheight, rows_left; + jpeg_component_info *compptr; + JSAMPARRAY xbuf; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Count sample rows in one iMCU row and in one row group */ + iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size; + rgroup = iMCUheight / cinfo->min_DCT_scaled_size; + /* Count nondummy sample rows remaining for this component */ + rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight); + if (rows_left == 0) rows_left = iMCUheight; + /* Count nondummy row groups. Should get same answer for each component, + * so we need only do it once. + */ + if (ci == 0) { + main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1); + } + /* Duplicate the last real sample row rgroup*2 times; this pads out the + * last partial rowgroup and ensures at least one full rowgroup of context. + */ + xbuf = main->xbuffer[main->whichptr][ci]; + for (i = 0; i < rgroup * 2; i++) { + xbuf[rows_left + i] = xbuf[rows_left-1]; + } + } +} + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + + switch (pass_mode) { + case JBUF_PASS_THRU: + if (cinfo->upsample->need_context_rows) { + main->pub.process_data = process_data_context_main; + make_funny_pointers(cinfo); /* Create the xbuffer[] lists */ + main->whichptr = 0; /* Read first iMCU row into xbuffer[0] */ + main->context_state = CTX_PREPARE_FOR_IMCU; + main->iMCU_row_ctr = 0; + } else { + /* Simple case with no context needed */ + main->pub.process_data = process_data_simple_main; + } + main->buffer_full = FALSE; /* Mark buffer empty */ + main->rowgroup_ctr = 0; + break; +#ifdef QUANT_2PASS_SUPPORTED + case JBUF_CRANK_DEST: + /* For last pass of 2-pass quantization, just crank the postprocessor */ + main->pub.process_data = process_data_crank_post; + break; +#endif + default: + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + break; + } +} + + +/* + * Process some data. + * This handles the simple case where no context is required. + */ + +METHODDEF(void) +process_data_simple_main (j_decompress_ptr cinfo, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + JDIMENSION rowgroups_avail; + + /* Read input data if we haven't filled the main buffer yet */ + if (! main->buffer_full) { + if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer)) + return; /* suspension forced, can do nothing more */ + main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */ + } + + /* There are always min_DCT_scaled_size row groups in an iMCU row. */ + rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size; + /* Note: at the bottom of the image, we may pass extra garbage row groups + * to the postprocessor. The postprocessor has to check for bottom + * of image anyway (at row resolution), so no point in us doing it too. + */ + + /* Feed the postprocessor */ + (*cinfo->post->post_process_data) (cinfo, main->buffer, + &main->rowgroup_ctr, rowgroups_avail, + output_buf, out_row_ctr, out_rows_avail); + + /* Has postprocessor consumed all the data yet? If so, mark buffer empty */ + if (main->rowgroup_ctr >= rowgroups_avail) { + main->buffer_full = FALSE; + main->rowgroup_ctr = 0; + } +} + + +/* + * Process some data. + * This handles the case where context rows must be provided. + */ + +METHODDEF(void) +process_data_context_main (j_decompress_ptr cinfo, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_main_ptr main = (my_main_ptr) cinfo->main; + + /* Read input data if we haven't filled the main buffer yet */ + if (! main->buffer_full) { + if (! (*cinfo->coef->decompress_data) (cinfo, + main->xbuffer[main->whichptr])) + return; /* suspension forced, can do nothing more */ + main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */ + main->iMCU_row_ctr++; /* count rows received */ + } + + /* Postprocessor typically will not swallow all the input data it is handed + * in one call (due to filling the output buffer first). Must be prepared + * to exit and restart. This switch lets us keep track of how far we got. + * Note that each case falls through to the next on successful completion. + */ + switch (main->context_state) { + case CTX_POSTPONED_ROW: + /* Call postprocessor using previously set pointers for postponed row */ + (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], + &main->rowgroup_ctr, main->rowgroups_avail, + output_buf, out_row_ctr, out_rows_avail); + if (main->rowgroup_ctr < main->rowgroups_avail) + return; /* Need to suspend */ + main->context_state = CTX_PREPARE_FOR_IMCU; + if (*out_row_ctr >= out_rows_avail) + return; /* Postprocessor exactly filled output buf */ + /*FALLTHROUGH*/ + case CTX_PREPARE_FOR_IMCU: + /* Prepare to process first M-1 row groups of this iMCU row */ + main->rowgroup_ctr = 0; + main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1); + /* Check for bottom of image: if so, tweak pointers to "duplicate" + * the last sample row, and adjust rowgroups_avail to ignore padding rows. + */ + if (main->iMCU_row_ctr == cinfo->total_iMCU_rows) + set_bottom_pointers(cinfo); + main->context_state = CTX_PROCESS_IMCU; + /*FALLTHROUGH*/ + case CTX_PROCESS_IMCU: + /* Call postprocessor using previously set pointers */ + (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], + &main->rowgroup_ctr, main->rowgroups_avail, + output_buf, out_row_ctr, out_rows_avail); + if (main->rowgroup_ctr < main->rowgroups_avail) + return; /* Need to suspend */ + /* After the first iMCU, change wraparound pointers to normal state */ + if (main->iMCU_row_ctr == 1) + set_wraparound_pointers(cinfo); + /* Prepare to load new iMCU row using other xbuffer list */ + main->whichptr ^= 1; /* 0=>1 or 1=>0 */ + main->buffer_full = FALSE; + /* Still need to process last row group of this iMCU row, */ + /* which is saved at index M+1 of the other xbuffer */ + main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1); + main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2); + main->context_state = CTX_POSTPONED_ROW; + } +} + + +/* + * Process some data. + * Final pass of two-pass quantization: just call the postprocessor. + * Source data will be the postprocessor controller's internal buffer. + */ + +#ifdef QUANT_2PASS_SUPPORTED + +METHODDEF(void) +process_data_crank_post (j_decompress_ptr cinfo, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL, + (JDIMENSION *) NULL, (JDIMENSION) 0, + output_buf, out_row_ctr, out_rows_avail); +} + +#endif /* QUANT_2PASS_SUPPORTED */ + + +/* + * Initialize main buffer controller. + */ + +GLOBAL(void) +jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer) +{ + my_main_ptr main; + int ci, rgroup, ngroups; + jpeg_component_info *compptr; + + main = (my_main_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_main_controller)); + cinfo->main = (struct jpeg_d_main_controller *) main; + main->pub.start_pass = start_pass_main; + + if (need_full_buffer) /* shouldn't happen */ + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + + /* Allocate the workspace. + * ngroups is the number of row groups we need. + */ + if (cinfo->upsample->need_context_rows) { + if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */ + ERREXIT(cinfo, JERR_NOTIMPL); + alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */ + ngroups = cinfo->min_DCT_scaled_size + 2; + } else { + ngroups = cinfo->min_DCT_scaled_size; + } + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; /* height of a row group of component */ + main->buffer[ci] = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + compptr->width_in_blocks * compptr->DCT_scaled_size, + (JDIMENSION) (rgroup * ngroups)); + } +} diff --git a/TMessagesProj/jni/libjpeg/jdmarker.c b/TMessagesProj/jni/libjpeg/jdmarker.c new file mode 100755 index 000000000..6978049d4 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdmarker.c @@ -0,0 +1,1410 @@ +/* + * jdmarker.c + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains routines to decode JPEG datastream markers. + * Most of the complexity arises from our desire to support input + * suspension: if not all of the data for a marker is available, + * we must exit back to the application. On resumption, we reprocess + * the marker. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +typedef enum { /* JPEG marker codes */ + M_SOF0 = 0xc0, + M_SOF1 = 0xc1, + M_SOF2 = 0xc2, + M_SOF3 = 0xc3, + + M_SOF5 = 0xc5, + M_SOF6 = 0xc6, + M_SOF7 = 0xc7, + + M_JPG = 0xc8, + M_SOF9 = 0xc9, + M_SOF10 = 0xca, + M_SOF11 = 0xcb, + + M_SOF13 = 0xcd, + M_SOF14 = 0xce, + M_SOF15 = 0xcf, + + M_DHT = 0xc4, + + M_DAC = 0xcc, + + M_RST0 = 0xd0, + M_RST1 = 0xd1, + M_RST2 = 0xd2, + M_RST3 = 0xd3, + M_RST4 = 0xd4, + M_RST5 = 0xd5, + M_RST6 = 0xd6, + M_RST7 = 0xd7, + + M_SOI = 0xd8, + M_EOI = 0xd9, + M_SOS = 0xda, + M_DQT = 0xdb, + M_DNL = 0xdc, + M_DRI = 0xdd, + M_DHP = 0xde, + M_EXP = 0xdf, + + M_APP0 = 0xe0, + M_APP1 = 0xe1, + M_APP2 = 0xe2, + M_APP3 = 0xe3, + M_APP4 = 0xe4, + M_APP5 = 0xe5, + M_APP6 = 0xe6, + M_APP7 = 0xe7, + M_APP8 = 0xe8, + M_APP9 = 0xe9, + M_APP10 = 0xea, + M_APP11 = 0xeb, + M_APP12 = 0xec, + M_APP13 = 0xed, + M_APP14 = 0xee, + M_APP15 = 0xef, + + M_JPG0 = 0xf0, + M_JPG13 = 0xfd, + M_COM = 0xfe, + + M_TEM = 0x01, + + M_ERROR = 0x100 +} JPEG_MARKER; + + +/* Private state */ + +typedef struct { + struct jpeg_marker_reader pub; /* public fields */ + + /* Application-overridable marker processing methods */ + jpeg_marker_parser_method process_COM; + jpeg_marker_parser_method process_APPn[16]; + + /* Limit on marker data length to save for each marker type */ + unsigned int length_limit_COM; + unsigned int length_limit_APPn[16]; + + /* Status of COM/APPn marker saving */ + jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */ + unsigned int bytes_read; /* data bytes read so far in marker */ + /* Note: cur_marker is not linked into marker_list until it's all read. */ +} my_marker_reader; + +typedef my_marker_reader * my_marker_ptr; + + +/* + * Macros for fetching data from the data source module. + * + * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect + * the current restart point; we update them only when we have reached a + * suitable place to restart if a suspension occurs. + */ + +/* Declare and initialize local copies of input pointer/count */ +#define INPUT_VARS(cinfo) \ + struct jpeg_source_mgr * datasrc = (cinfo)->src; \ + const JOCTET * next_input_byte = datasrc->next_input_byte; \ + size_t bytes_in_buffer = datasrc->bytes_in_buffer + +/* Unload the local copies --- do this only at a restart boundary */ +#define INPUT_SYNC(cinfo) \ + ( datasrc->next_input_byte = next_input_byte, \ + datasrc->bytes_in_buffer = bytes_in_buffer ) + +/* Reload the local copies --- used only in MAKE_BYTE_AVAIL */ +#define INPUT_RELOAD(cinfo) \ + ( next_input_byte = datasrc->next_input_byte, \ + bytes_in_buffer = datasrc->bytes_in_buffer ) + +/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available. + * Note we do *not* do INPUT_SYNC before calling fill_input_buffer, + * but we must reload the local copies after a successful fill. + */ +#define MAKE_BYTE_AVAIL(cinfo,action) \ + if (bytes_in_buffer == 0) { \ + if (! (*datasrc->fill_input_buffer) (cinfo)) \ + { action; } \ + INPUT_RELOAD(cinfo); \ + } + +/* Read a byte into variable V. + * If must suspend, take the specified action (typically "return FALSE"). + */ +#define INPUT_BYTE(cinfo,V,action) \ + MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ + bytes_in_buffer--; \ + V = GETJOCTET(*next_input_byte++); ) + +/* As above, but read two bytes interpreted as an unsigned 16-bit integer. + * V should be declared unsigned int or perhaps INT32. + */ +#define INPUT_2BYTES(cinfo,V,action) \ + MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ + bytes_in_buffer--; \ + V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \ + MAKE_BYTE_AVAIL(cinfo,action); \ + bytes_in_buffer--; \ + V += GETJOCTET(*next_input_byte++); ) + + +/* + * Routines to process JPEG markers. + * + * Entry condition: JPEG marker itself has been read and its code saved + * in cinfo->unread_marker; input restart point is just after the marker. + * + * Exit: if return TRUE, have read and processed any parameters, and have + * updated the restart point to point after the parameters. + * If return FALSE, was forced to suspend before reaching end of + * marker parameters; restart point has not been moved. Same routine + * will be called again after application supplies more input data. + * + * This approach to suspension assumes that all of a marker's parameters + * can fit into a single input bufferload. This should hold for "normal" + * markers. Some COM/APPn markers might have large parameter segments + * that might not fit. If we are simply dropping such a marker, we use + * skip_input_data to get past it, and thereby put the problem on the + * source manager's shoulders. If we are saving the marker's contents + * into memory, we use a slightly different convention: when forced to + * suspend, the marker processor updates the restart point to the end of + * what it's consumed (ie, the end of the buffer) before returning FALSE. + * On resumption, cinfo->unread_marker still contains the marker code, + * but the data source will point to the next chunk of marker data. + * The marker processor must retain internal state to deal with this. + * + * Note that we don't bother to avoid duplicate trace messages if a + * suspension occurs within marker parameters. Other side effects + * require more care. + */ + + +LOCAL(boolean) +get_soi (j_decompress_ptr cinfo) +/* Process an SOI marker */ +{ + int i; + + TRACEMS(cinfo, 1, JTRC_SOI); + + if (cinfo->marker->saw_SOI) + ERREXIT(cinfo, JERR_SOI_DUPLICATE); + + /* Reset all parameters that are defined to be reset by SOI */ + + for (i = 0; i < NUM_ARITH_TBLS; i++) { + cinfo->arith_dc_L[i] = 0; + cinfo->arith_dc_U[i] = 1; + cinfo->arith_ac_K[i] = 5; + } + cinfo->restart_interval = 0; + + /* Set initial assumptions for colorspace etc */ + + cinfo->jpeg_color_space = JCS_UNKNOWN; + cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */ + + cinfo->saw_JFIF_marker = FALSE; + cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */ + cinfo->JFIF_minor_version = 1; + cinfo->density_unit = 0; + cinfo->X_density = 1; + cinfo->Y_density = 1; + cinfo->saw_Adobe_marker = FALSE; + cinfo->Adobe_transform = 0; + + cinfo->marker->saw_SOI = TRUE; + + return TRUE; +} + + +LOCAL(boolean) +get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith) +/* Process a SOFn marker */ +{ + INT32 length; + int c, ci; + jpeg_component_info * compptr; + INPUT_VARS(cinfo); + + cinfo->progressive_mode = is_prog; + cinfo->arith_code = is_arith; + + INPUT_2BYTES(cinfo, length, return FALSE); + + INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE); + INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE); + INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE); + INPUT_BYTE(cinfo, cinfo->num_components, return FALSE); + + length -= 8; + + TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker, + (int) cinfo->image_width, (int) cinfo->image_height, + cinfo->num_components); + + if (cinfo->marker->saw_SOF) + ERREXIT(cinfo, JERR_SOF_DUPLICATE); + + /* We don't support files in which the image height is initially specified */ + /* as 0 and is later redefined by DNL. As long as we have to check that, */ + /* might as well have a general sanity check. */ + if (cinfo->image_height <= 0 || cinfo->image_width <= 0 + || cinfo->num_components <= 0) + ERREXIT(cinfo, JERR_EMPTY_IMAGE); + + if (length != (cinfo->num_components * 3)) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + if (cinfo->comp_info == NULL) /* do only once, even if suspend */ + cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + cinfo->num_components * SIZEOF(jpeg_component_info)); + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + compptr->component_index = ci; + INPUT_BYTE(cinfo, compptr->component_id, return FALSE); + INPUT_BYTE(cinfo, c, return FALSE); + compptr->h_samp_factor = (c >> 4) & 15; + compptr->v_samp_factor = (c ) & 15; + INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE); + + TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT, + compptr->component_id, compptr->h_samp_factor, + compptr->v_samp_factor, compptr->quant_tbl_no); + } + + cinfo->marker->saw_SOF = TRUE; + + INPUT_SYNC(cinfo); + return TRUE; +} + + +LOCAL(boolean) +get_sos (j_decompress_ptr cinfo) +/* Process a SOS marker */ +{ + INT32 length; + int i, ci, n, c, cc, pi; + jpeg_component_info * compptr; + INPUT_VARS(cinfo); + + if (! cinfo->marker->saw_SOF) + ERREXIT(cinfo, JERR_SOS_NO_SOF); + + INPUT_2BYTES(cinfo, length, return FALSE); + + INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */ + + TRACEMS1(cinfo, 1, JTRC_SOS, n); + + if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + cinfo->comps_in_scan = n; + + /* Collect the component-spec parameters */ + + for (i = 0; i < n; i++) { + INPUT_BYTE(cinfo, cc, return FALSE); + INPUT_BYTE(cinfo, c, return FALSE); + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (cc == compptr->component_id) + goto id_found; + } + + ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc); + + id_found: + + cinfo->cur_comp_info[i] = compptr; + compptr->dc_tbl_no = (c >> 4) & 15; + compptr->ac_tbl_no = (c ) & 15; + + TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc, + compptr->dc_tbl_no, compptr->ac_tbl_no); + + /* This CSi (cc) should differ from the previous CSi */ + for (pi = 0; pi < i; pi++) { + if (cinfo->cur_comp_info[pi] == compptr) + ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc); + } + } + + /* Collect the additional scan parameters Ss, Se, Ah/Al. */ + INPUT_BYTE(cinfo, c, return FALSE); + cinfo->Ss = c; + INPUT_BYTE(cinfo, c, return FALSE); + cinfo->Se = c; + INPUT_BYTE(cinfo, c, return FALSE); + cinfo->Ah = (c >> 4) & 15; + cinfo->Al = (c ) & 15; + + TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se, + cinfo->Ah, cinfo->Al); + + /* Prepare to scan data & restart markers */ + cinfo->marker->next_restart_num = 0; + + /* Count another SOS marker */ + cinfo->input_scan_number++; + + INPUT_SYNC(cinfo); + return TRUE; +} + + +#ifdef D_ARITH_CODING_SUPPORTED + +LOCAL(boolean) +get_dac (j_decompress_ptr cinfo) +/* Process a DAC marker */ +{ + INT32 length; + int index, val; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + + while (length > 0) { + INPUT_BYTE(cinfo, index, return FALSE); + INPUT_BYTE(cinfo, val, return FALSE); + + length -= 2; + + TRACEMS2(cinfo, 1, JTRC_DAC, index, val); + + if (index < 0 || index >= (2*NUM_ARITH_TBLS)) + ERREXIT1(cinfo, JERR_DAC_INDEX, index); + + if (index >= NUM_ARITH_TBLS) { /* define AC table */ + cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val; + } else { /* define DC table */ + cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F); + cinfo->arith_dc_U[index] = (UINT8) (val >> 4); + if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index]) + ERREXIT1(cinfo, JERR_DAC_VALUE, val); + } + } + + if (length != 0) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + INPUT_SYNC(cinfo); + return TRUE; +} + +#else /* ! D_ARITH_CODING_SUPPORTED */ + +#define get_dac(cinfo) skip_variable(cinfo) + +#endif /* D_ARITH_CODING_SUPPORTED */ + + +LOCAL(boolean) +get_dht (j_decompress_ptr cinfo) +/* Process a DHT marker */ +{ + INT32 length; + UINT8 bits[17]; + UINT8 huffval[256]; + int i, index, count; + JHUFF_TBL **htblptr; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + + while (length > 16) { + INPUT_BYTE(cinfo, index, return FALSE); + + TRACEMS1(cinfo, 1, JTRC_DHT, index); + + bits[0] = 0; + count = 0; + for (i = 1; i <= 16; i++) { + INPUT_BYTE(cinfo, bits[i], return FALSE); + count += bits[i]; + } + + length -= 1 + 16; + + TRACEMS8(cinfo, 2, JTRC_HUFFBITS, + bits[1], bits[2], bits[3], bits[4], + bits[5], bits[6], bits[7], bits[8]); + TRACEMS8(cinfo, 2, JTRC_HUFFBITS, + bits[9], bits[10], bits[11], bits[12], + bits[13], bits[14], bits[15], bits[16]); + + /* Here we just do minimal validation of the counts to avoid walking + * off the end of our table space. jdhuff.c will check more carefully. + */ + if (count > 256 || ((INT32) count) > length) + ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); + + for (i = 0; i < count; i++) + INPUT_BYTE(cinfo, huffval[i], return FALSE); + + MEMZERO(&huffval[count], (256 - count) * SIZEOF(UINT8)); + + length -= count; + + if (index & 0x10) { /* AC table definition */ + index -= 0x10; + htblptr = &cinfo->ac_huff_tbl_ptrs[index]; + } else { /* DC table definition */ + htblptr = &cinfo->dc_huff_tbl_ptrs[index]; + } + + if (index < 0 || index >= NUM_HUFF_TBLS) + ERREXIT1(cinfo, JERR_DHT_INDEX, index); + + if (*htblptr == NULL) + *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); + + MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); + MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval)); + } + + if (length != 0) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + INPUT_SYNC(cinfo); + return TRUE; +} + + +LOCAL(boolean) +get_dqt (j_decompress_ptr cinfo) +/* Process a DQT marker */ +{ + INT32 length; + int n, i, prec; + unsigned int tmp; + JQUANT_TBL *quant_ptr; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + + while (length > 0) { + INPUT_BYTE(cinfo, n, return FALSE); + prec = n >> 4; + n &= 0x0F; + + TRACEMS2(cinfo, 1, JTRC_DQT, n, prec); + + if (n >= NUM_QUANT_TBLS) + ERREXIT1(cinfo, JERR_DQT_INDEX, n); + + if (cinfo->quant_tbl_ptrs[n] == NULL) + cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo); + quant_ptr = cinfo->quant_tbl_ptrs[n]; + + for (i = 0; i < DCTSIZE2; i++) { + if (prec) + INPUT_2BYTES(cinfo, tmp, return FALSE); + else + INPUT_BYTE(cinfo, tmp, return FALSE); + /* We convert the zigzag-order table to natural array order. */ + quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp; + } + + if (cinfo->err->trace_level >= 2) { + for (i = 0; i < DCTSIZE2; i += 8) { + TRACEMS8(cinfo, 2, JTRC_QUANTVALS, + quant_ptr->quantval[i], quant_ptr->quantval[i+1], + quant_ptr->quantval[i+2], quant_ptr->quantval[i+3], + quant_ptr->quantval[i+4], quant_ptr->quantval[i+5], + quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]); + } + } + + length -= DCTSIZE2+1; + if (prec) length -= DCTSIZE2; + } + + if (length != 0) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + INPUT_SYNC(cinfo); + return TRUE; +} + + +LOCAL(boolean) +get_dri (j_decompress_ptr cinfo) +/* Process a DRI marker */ +{ + INT32 length; + unsigned int tmp; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + + if (length != 4) + ERREXIT(cinfo, JERR_BAD_LENGTH); + + INPUT_2BYTES(cinfo, tmp, return FALSE); + + TRACEMS1(cinfo, 1, JTRC_DRI, tmp); + + cinfo->restart_interval = tmp; + + INPUT_SYNC(cinfo); + return TRUE; +} + + +/* + * Routines for processing APPn and COM markers. + * These are either saved in memory or discarded, per application request. + * APP0 and APP14 are specially checked to see if they are + * JFIF and Adobe markers, respectively. + */ + +#define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */ +#define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */ +#define APPN_DATA_LEN 14 /* Must be the largest of the above!! */ + + +LOCAL(void) +examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data, + unsigned int datalen, INT32 remaining) +/* Examine first few bytes from an APP0. + * Take appropriate action if it is a JFIF marker. + * datalen is # of bytes at data[], remaining is length of rest of marker data. + */ +{ + INT32 totallen = (INT32) datalen + remaining; + + if (datalen >= APP0_DATA_LEN && + GETJOCTET(data[0]) == 0x4A && + GETJOCTET(data[1]) == 0x46 && + GETJOCTET(data[2]) == 0x49 && + GETJOCTET(data[3]) == 0x46 && + GETJOCTET(data[4]) == 0) { + /* Found JFIF APP0 marker: save info */ + cinfo->saw_JFIF_marker = TRUE; + cinfo->JFIF_major_version = GETJOCTET(data[5]); + cinfo->JFIF_minor_version = GETJOCTET(data[6]); + cinfo->density_unit = GETJOCTET(data[7]); + cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]); + cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]); + /* Check version. + * Major version must be 1, anything else signals an incompatible change. + * (We used to treat this as an error, but now it's a nonfatal warning, + * because some bozo at Hijaak couldn't read the spec.) + * Minor version should be 0..2, but process anyway if newer. + */ + if (cinfo->JFIF_major_version != 1) + WARNMS2(cinfo, JWRN_JFIF_MAJOR, + cinfo->JFIF_major_version, cinfo->JFIF_minor_version); + /* Generate trace messages */ + TRACEMS5(cinfo, 1, JTRC_JFIF, + cinfo->JFIF_major_version, cinfo->JFIF_minor_version, + cinfo->X_density, cinfo->Y_density, cinfo->density_unit); + /* Validate thumbnail dimensions and issue appropriate messages */ + if (GETJOCTET(data[12]) | GETJOCTET(data[13])) + TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, + GETJOCTET(data[12]), GETJOCTET(data[13])); + totallen -= APP0_DATA_LEN; + if (totallen != + ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3)) + TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen); + } else if (datalen >= 6 && + GETJOCTET(data[0]) == 0x4A && + GETJOCTET(data[1]) == 0x46 && + GETJOCTET(data[2]) == 0x58 && + GETJOCTET(data[3]) == 0x58 && + GETJOCTET(data[4]) == 0) { + /* Found JFIF "JFXX" extension APP0 marker */ + /* The library doesn't actually do anything with these, + * but we try to produce a helpful trace message. + */ + switch (GETJOCTET(data[5])) { + case 0x10: + TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen); + break; + case 0x11: + TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen); + break; + case 0x13: + TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen); + break; + default: + TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, + GETJOCTET(data[5]), (int) totallen); + break; + } + } else { + /* Start of APP0 does not match "JFIF" or "JFXX", or too short */ + TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen); + } +} + + +LOCAL(void) +examine_app14 (j_decompress_ptr cinfo, JOCTET FAR * data, + unsigned int datalen, INT32 remaining) +/* Examine first few bytes from an APP14. + * Take appropriate action if it is an Adobe marker. + * datalen is # of bytes at data[], remaining is length of rest of marker data. + */ +{ + unsigned int version, flags0, flags1, transform; + + if (datalen >= APP14_DATA_LEN && + GETJOCTET(data[0]) == 0x41 && + GETJOCTET(data[1]) == 0x64 && + GETJOCTET(data[2]) == 0x6F && + GETJOCTET(data[3]) == 0x62 && + GETJOCTET(data[4]) == 0x65) { + /* Found Adobe APP14 marker */ + version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]); + flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]); + flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]); + transform = GETJOCTET(data[11]); + TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform); + cinfo->saw_Adobe_marker = TRUE; + cinfo->Adobe_transform = (UINT8) transform; + } else { + /* Start of APP14 does not match "Adobe", or too short */ + TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining)); + } +} + + +METHODDEF(boolean) +get_interesting_appn (j_decompress_ptr cinfo) +/* Process an APP0 or APP14 marker without saving it */ +{ + INT32 length; + JOCTET b[APPN_DATA_LEN]; + unsigned int i, numtoread; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + + /* get the interesting part of the marker data */ + if (length >= APPN_DATA_LEN) + numtoread = APPN_DATA_LEN; + else if (length > 0) + numtoread = (unsigned int) length; + else + numtoread = 0; + for (i = 0; i < numtoread; i++) + INPUT_BYTE(cinfo, b[i], return FALSE); + length -= numtoread; + + /* process it */ + switch (cinfo->unread_marker) { + case M_APP0: + examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length); + break; + case M_APP14: + examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length); + break; + default: + /* can't get here unless jpeg_save_markers chooses wrong processor */ + ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); + break; + } + + /* skip any remaining data -- could be lots */ + INPUT_SYNC(cinfo); + if (length > 0) + (*cinfo->src->skip_input_data) (cinfo, (long) length); + + return TRUE; +} + + +#ifdef SAVE_MARKERS_SUPPORTED + +METHODDEF(boolean) +save_marker (j_decompress_ptr cinfo) +/* Save an APPn or COM marker into the marker list */ +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + jpeg_saved_marker_ptr cur_marker = marker->cur_marker; + unsigned int bytes_read, data_length; + JOCTET FAR * data; + INT32 length = 0; + INPUT_VARS(cinfo); + + if (cur_marker == NULL) { + /* begin reading a marker */ + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + if (length >= 0) { /* watch out for bogus length word */ + /* figure out how much we want to save */ + unsigned int limit; + if (cinfo->unread_marker == (int) M_COM) + limit = marker->length_limit_COM; + else + limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0]; + if ((unsigned int) length < limit) + limit = (unsigned int) length; + /* allocate and initialize the marker item */ + cur_marker = (jpeg_saved_marker_ptr) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(struct jpeg_marker_struct) + limit); + cur_marker->next = NULL; + cur_marker->marker = (UINT8) cinfo->unread_marker; + cur_marker->original_length = (unsigned int) length; + cur_marker->data_length = limit; + /* data area is just beyond the jpeg_marker_struct */ + data = cur_marker->data = (JOCTET FAR *) (cur_marker + 1); + marker->cur_marker = cur_marker; + marker->bytes_read = 0; + bytes_read = 0; + data_length = limit; + } else { + /* deal with bogus length word */ + bytes_read = data_length = 0; + data = NULL; + } + } else { + /* resume reading a marker */ + bytes_read = marker->bytes_read; + data_length = cur_marker->data_length; + data = cur_marker->data + bytes_read; + } + + while (bytes_read < data_length) { + INPUT_SYNC(cinfo); /* move the restart point to here */ + marker->bytes_read = bytes_read; + /* If there's not at least one byte in buffer, suspend */ + MAKE_BYTE_AVAIL(cinfo, return FALSE); + /* Copy bytes with reasonable rapidity */ + while (bytes_read < data_length && bytes_in_buffer > 0) { + *data++ = *next_input_byte++; + bytes_in_buffer--; + bytes_read++; + } + } + + /* Done reading what we want to read */ + if (cur_marker != NULL) { /* will be NULL if bogus length word */ + /* Add new marker to end of list */ + if (cinfo->marker_list == NULL) { + cinfo->marker_list = cur_marker; + } else { + jpeg_saved_marker_ptr prev = cinfo->marker_list; + while (prev->next != NULL) + prev = prev->next; + prev->next = cur_marker; + } + /* Reset pointer & calc remaining data length */ + data = cur_marker->data; + length = cur_marker->original_length - data_length; + } + /* Reset to initial state for next marker */ + marker->cur_marker = NULL; + + /* Process the marker if interesting; else just make a generic trace msg */ + switch (cinfo->unread_marker) { + case M_APP0: + examine_app0(cinfo, data, data_length, length); + break; + case M_APP14: + examine_app14(cinfo, data, data_length, length); + break; + default: + TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, + (int) (data_length + length)); + break; + } + + /* skip any remaining data -- could be lots */ + INPUT_SYNC(cinfo); /* do before skip_input_data */ + if (length > 0) + (*cinfo->src->skip_input_data) (cinfo, (long) length); + + return TRUE; +} + +#endif /* SAVE_MARKERS_SUPPORTED */ + + +METHODDEF(boolean) +skip_variable (j_decompress_ptr cinfo) +/* Skip over an unknown or uninteresting variable-length marker */ +{ + INT32 length; + INPUT_VARS(cinfo); + + INPUT_2BYTES(cinfo, length, return FALSE); + length -= 2; + + TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length); + + INPUT_SYNC(cinfo); /* do before skip_input_data */ + if (length > 0) + (*cinfo->src->skip_input_data) (cinfo, (long) length); + + return TRUE; +} + + +/* + * Find the next JPEG marker, save it in cinfo->unread_marker. + * Returns FALSE if had to suspend before reaching a marker; + * in that case cinfo->unread_marker is unchanged. + * + * Note that the result might not be a valid marker code, + * but it will never be 0 or FF. + */ + +LOCAL(boolean) +next_marker (j_decompress_ptr cinfo) +{ + int c; + INPUT_VARS(cinfo); + + for (;;) { + INPUT_BYTE(cinfo, c, return FALSE); + /* Skip any non-FF bytes. + * This may look a bit inefficient, but it will not occur in a valid file. + * We sync after each discarded byte so that a suspending data source + * can discard the byte from its buffer. + */ + while (c != 0xFF) { + cinfo->marker->discarded_bytes++; + INPUT_SYNC(cinfo); + INPUT_BYTE(cinfo, c, return FALSE); + } + /* This loop swallows any duplicate FF bytes. Extra FFs are legal as + * pad bytes, so don't count them in discarded_bytes. We assume there + * will not be so many consecutive FF bytes as to overflow a suspending + * data source's input buffer. + */ + do { + INPUT_BYTE(cinfo, c, return FALSE); + } while (c == 0xFF); + if (c != 0) + break; /* found a valid marker, exit loop */ + /* Reach here if we found a stuffed-zero data sequence (FF/00). + * Discard it and loop back to try again. + */ + cinfo->marker->discarded_bytes += 2; + INPUT_SYNC(cinfo); + } + + if (cinfo->marker->discarded_bytes != 0) { + WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c); + cinfo->marker->discarded_bytes = 0; + } + + cinfo->unread_marker = c; + + INPUT_SYNC(cinfo); + return TRUE; +} + + +LOCAL(boolean) +first_marker (j_decompress_ptr cinfo) +/* Like next_marker, but used to obtain the initial SOI marker. */ +/* For this marker, we do not allow preceding garbage or fill; otherwise, + * we might well scan an entire input file before realizing it ain't JPEG. + * If an application wants to process non-JFIF files, it must seek to the + * SOI before calling the JPEG library. + */ +{ + int c, c2; + INPUT_VARS(cinfo); + + INPUT_BYTE(cinfo, c, return FALSE); + INPUT_BYTE(cinfo, c2, return FALSE); + if (c != 0xFF || c2 != (int) M_SOI) + ERREXIT2(cinfo, JERR_NO_SOI, c, c2); + + cinfo->unread_marker = c2; + + INPUT_SYNC(cinfo); + return TRUE; +} + + +/* + * Read markers until SOS or EOI. + * + * Returns same codes as are defined for jpeg_consume_input: + * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. + */ + +METHODDEF(int) +read_markers (j_decompress_ptr cinfo) +{ + /* Outer loop repeats once for each marker. */ + for (;;) { + /* Collect the marker proper, unless we already did. */ + /* NB: first_marker() enforces the requirement that SOI appear first. */ + if (cinfo->unread_marker == 0) { + if (! cinfo->marker->saw_SOI) { + if (! first_marker(cinfo)) + return JPEG_SUSPENDED; + } else { + if (! next_marker(cinfo)) + return JPEG_SUSPENDED; + } + } + + /* + * Save the position of the fist marker after SOF. + */ + if (cinfo->marker->current_sos_marker_position == -1) + cinfo->marker->current_sos_marker_position = + jget_input_stream_position(cinfo) - 2; + + /* At this point cinfo->unread_marker contains the marker code and the + * input point is just past the marker proper, but before any parameters. + * A suspension will cause us to return with this state still true. + */ + switch (cinfo->unread_marker) { + case M_SOI: + if (! get_soi(cinfo)) + return JPEG_SUSPENDED; + break; + + case M_SOF0: /* Baseline */ + case M_SOF1: /* Extended sequential, Huffman */ + if (! get_sof(cinfo, FALSE, FALSE)) + return JPEG_SUSPENDED; + break; + + case M_SOF2: /* Progressive, Huffman */ + cinfo->marker->current_sos_marker_position = -1; + if (! get_sof(cinfo, TRUE, FALSE)) + return JPEG_SUSPENDED; + break; + + case M_SOF9: /* Extended sequential, arithmetic */ + if (! get_sof(cinfo, FALSE, TRUE)) + return JPEG_SUSPENDED; + break; + + case M_SOF10: /* Progressive, arithmetic */ + if (! get_sof(cinfo, TRUE, TRUE)) + return JPEG_SUSPENDED; + break; + + /* Currently unsupported SOFn types */ + case M_SOF3: /* Lossless, Huffman */ + case M_SOF5: /* Differential sequential, Huffman */ + case M_SOF6: /* Differential progressive, Huffman */ + case M_SOF7: /* Differential lossless, Huffman */ + case M_JPG: /* Reserved for JPEG extensions */ + case M_SOF11: /* Lossless, arithmetic */ + case M_SOF13: /* Differential sequential, arithmetic */ + case M_SOF14: /* Differential progressive, arithmetic */ + case M_SOF15: /* Differential lossless, arithmetic */ + ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker); + break; + + case M_SOS: + if (! get_sos(cinfo)) + return JPEG_SUSPENDED; + cinfo->unread_marker = 0; /* processed the marker */ + return JPEG_REACHED_SOS; + + case M_EOI: + TRACEMS(cinfo, 1, JTRC_EOI); + cinfo->unread_marker = 0; /* processed the marker */ + return JPEG_REACHED_EOI; + + case M_DAC: + if (! get_dac(cinfo)) + return JPEG_SUSPENDED; + break; + + case M_DHT: + if (! get_dht(cinfo)) + return JPEG_SUSPENDED; + break; + + case M_DQT: + if (! get_dqt(cinfo)) + return JPEG_SUSPENDED; + break; + + case M_DRI: + if (! get_dri(cinfo)) + return JPEG_SUSPENDED; + break; + + case M_APP0: + case M_APP1: + case M_APP2: + case M_APP3: + case M_APP4: + case M_APP5: + case M_APP6: + case M_APP7: + case M_APP8: + case M_APP9: + case M_APP10: + case M_APP11: + case M_APP12: + case M_APP13: + case M_APP14: + case M_APP15: + if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[ + cinfo->unread_marker - (int) M_APP0]) (cinfo)) + return JPEG_SUSPENDED; + break; + + case M_COM: + if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo)) + return JPEG_SUSPENDED; + break; + + case M_RST0: /* these are all parameterless */ + case M_RST1: + case M_RST2: + case M_RST3: + case M_RST4: + case M_RST5: + case M_RST6: + case M_RST7: + case M_TEM: + TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker); + break; + + case M_DNL: /* Ignore DNL ... perhaps the wrong thing */ + if (! skip_variable(cinfo)) + return JPEG_SUSPENDED; + break; + + default: /* must be DHP, EXP, JPGn, or RESn */ + /* For now, we treat the reserved markers as fatal errors since they are + * likely to be used to signal incompatible JPEG Part 3 extensions. + * Once the JPEG 3 version-number marker is well defined, this code + * ought to change! + */ + ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); + break; + } + /* Successfully processed marker, so reset state variable */ + cinfo->unread_marker = 0; + } /* end loop */ +} + + +/* + * Read a restart marker, which is expected to appear next in the datastream; + * if the marker is not there, take appropriate recovery action. + * Returns FALSE if suspension is required. + * + * This is called by the entropy decoder after it has read an appropriate + * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder + * has already read a marker from the data source. Under normal conditions + * cinfo->unread_marker will be reset to 0 before returning; if not reset, + * it holds a marker which the decoder will be unable to read past. + */ + +METHODDEF(boolean) +read_restart_marker (j_decompress_ptr cinfo) +{ + /* Obtain a marker unless we already did. */ + /* Note that next_marker will complain if it skips any data. */ + if (cinfo->unread_marker == 0) { + if (! next_marker(cinfo)) + return FALSE; + } + + if (cinfo->unread_marker == + ((int) M_RST0 + cinfo->marker->next_restart_num)) { + /* Normal case --- swallow the marker and let entropy decoder continue */ + TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num); + cinfo->unread_marker = 0; + } else { + /* Uh-oh, the restart markers have been messed up. */ + /* Let the data source manager determine how to resync. */ + if (! (*cinfo->src->resync_to_restart) (cinfo, + cinfo->marker->next_restart_num)) + return FALSE; + } + + /* Update next-restart state */ + cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7; + + return TRUE; +} + + +/* + * This is the default resync_to_restart method for data source managers + * to use if they don't have any better approach. Some data source managers + * may be able to back up, or may have additional knowledge about the data + * which permits a more intelligent recovery strategy; such managers would + * presumably supply their own resync method. + * + * read_restart_marker calls resync_to_restart if it finds a marker other than + * the restart marker it was expecting. (This code is *not* used unless + * a nonzero restart interval has been declared.) cinfo->unread_marker is + * the marker code actually found (might be anything, except 0 or FF). + * The desired restart marker number (0..7) is passed as a parameter. + * This routine is supposed to apply whatever error recovery strategy seems + * appropriate in order to position the input stream to the next data segment. + * Note that cinfo->unread_marker is treated as a marker appearing before + * the current data-source input point; usually it should be reset to zero + * before returning. + * Returns FALSE if suspension is required. + * + * This implementation is substantially constrained by wanting to treat the + * input as a data stream; this means we can't back up. Therefore, we have + * only the following actions to work with: + * 1. Simply discard the marker and let the entropy decoder resume at next + * byte of file. + * 2. Read forward until we find another marker, discarding intervening + * data. (In theory we could look ahead within the current bufferload, + * without having to discard data if we don't find the desired marker. + * This idea is not implemented here, in part because it makes behavior + * dependent on buffer size and chance buffer-boundary positions.) + * 3. Leave the marker unread (by failing to zero cinfo->unread_marker). + * This will cause the entropy decoder to process an empty data segment, + * inserting dummy zeroes, and then we will reprocess the marker. + * + * #2 is appropriate if we think the desired marker lies ahead, while #3 is + * appropriate if the found marker is a future restart marker (indicating + * that we have missed the desired restart marker, probably because it got + * corrupted). + * We apply #2 or #3 if the found marker is a restart marker no more than + * two counts behind or ahead of the expected one. We also apply #2 if the + * found marker is not a legal JPEG marker code (it's certainly bogus data). + * If the found marker is a restart marker more than 2 counts away, we do #1 + * (too much risk that the marker is erroneous; with luck we will be able to + * resync at some future point). + * For any valid non-restart JPEG marker, we apply #3. This keeps us from + * overrunning the end of a scan. An implementation limited to single-scan + * files might find it better to apply #2 for markers other than EOI, since + * any other marker would have to be bogus data in that case. + */ + +GLOBAL(boolean) +jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired) +{ + int marker = cinfo->unread_marker; + int action = 1; + + /* Always put up a warning. */ + WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired); + + /* Outer loop handles repeated decision after scanning forward. */ + for (;;) { + if (marker < (int) M_SOF0) + action = 2; /* invalid marker */ + else if (marker < (int) M_RST0 || marker > (int) M_RST7) + action = 3; /* valid non-restart marker */ + else { + if (marker == ((int) M_RST0 + ((desired+1) & 7)) || + marker == ((int) M_RST0 + ((desired+2) & 7))) + action = 3; /* one of the next two expected restarts */ + else if (marker == ((int) M_RST0 + ((desired-1) & 7)) || + marker == ((int) M_RST0 + ((desired-2) & 7))) + action = 2; /* a prior restart, so advance */ + else + action = 1; /* desired restart or too far away */ + } + TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action); + switch (action) { + case 1: + /* Discard marker and let entropy decoder resume processing. */ + cinfo->unread_marker = 0; + return TRUE; + case 2: + /* Scan to the next marker, and repeat the decision loop. */ + if (! next_marker(cinfo)) + return FALSE; + marker = cinfo->unread_marker; + break; + case 3: + /* Return without advancing past this marker. */ + /* Entropy decoder will be forced to process an empty segment. */ + return TRUE; + } + } /* end loop */ +} + +/* + * Get the position for all SOS markers in the image. + */ + +METHODDEF(void) +get_sos_marker_position(j_decompress_ptr cinfo, huffman_index *index) +{ + unsigned char *head; + int count = 0; + int retcode = JPEG_REACHED_SOS; + + while (cinfo->src->bytes_in_buffer > 0) { + if (retcode == JPEG_REACHED_SOS) { + jpeg_configure_huffman_index_scan(cinfo, index, count++, + cinfo->marker->current_sos_marker_position); + // Skips scan content to the next non-RST JPEG marker. + while(next_marker(cinfo) && + cinfo->unread_marker >= M_RST0 && cinfo->unread_marker <= M_RST7) + ; + cinfo->marker->current_sos_marker_position = + jget_input_stream_position(cinfo) - 2; + retcode = read_markers(cinfo); + } else { + break; + } + } +} + +/* + * Reset marker processing state to begin a fresh datastream. + */ + +METHODDEF(void) +reset_marker_reader (j_decompress_ptr cinfo) +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + + cinfo->comp_info = NULL; /* until allocated by get_sof */ + cinfo->input_scan_number = 0; /* no SOS seen yet */ + cinfo->unread_marker = 0; /* no pending marker */ + marker->pub.saw_SOI = FALSE; /* set internal state too */ + marker->pub.saw_SOF = FALSE; + marker->pub.discarded_bytes = 0; + marker->cur_marker = NULL; +} + + +/* + * Initialize the marker reader module. + * This is called only once, when the decompression object is created. + */ + +GLOBAL(void) +jinit_marker_reader (j_decompress_ptr cinfo) +{ + my_marker_ptr marker; + int i; + + /* Create subobject in permanent pool */ + marker = (my_marker_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + SIZEOF(my_marker_reader)); + cinfo->marker = (struct jpeg_marker_reader *) marker; + /* Initialize public method pointers */ + marker->pub.reset_marker_reader = reset_marker_reader; + marker->pub.read_markers = read_markers; + marker->pub.read_restart_marker = read_restart_marker; + marker->pub.get_sos_marker_position = get_sos_marker_position; + + // Initialize the SOS marker position to avoid underdefined behavior due to + // using a undefined field. + marker->pub.current_sos_marker_position = 0; + + /* Initialize COM/APPn processing. + * By default, we examine and then discard APP0 and APP14, + * but simply discard COM and all other APPn. + */ + marker->process_COM = skip_variable; + marker->length_limit_COM = 0; + for (i = 0; i < 16; i++) { + marker->process_APPn[i] = skip_variable; + marker->length_limit_APPn[i] = 0; + } + marker->process_APPn[0] = get_interesting_appn; + marker->process_APPn[14] = get_interesting_appn; + /* Reset marker processing state */ + reset_marker_reader(cinfo); +} + + +/* + * Control saving of COM and APPn markers into marker_list. + */ + +#ifdef SAVE_MARKERS_SUPPORTED + +GLOBAL(void) +jpeg_save_markers (j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit) +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + long maxlength; + jpeg_marker_parser_method processor; + + /* Length limit mustn't be larger than what we can allocate + * (should only be a concern in a 16-bit environment). + */ + maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct); + if (((long) length_limit) > maxlength) + length_limit = (unsigned int) maxlength; + + /* Choose processor routine to use. + * APP0/APP14 have special requirements. + */ + if (length_limit) { + processor = save_marker; + /* If saving APP0/APP14, save at least enough for our internal use. */ + if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN) + length_limit = APP0_DATA_LEN; + else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN) + length_limit = APP14_DATA_LEN; + } else { + processor = skip_variable; + /* If discarding APP0/APP14, use our regular on-the-fly processor. */ + if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14) + processor = get_interesting_appn; + } + + if (marker_code == (int) M_COM) { + marker->process_COM = processor; + marker->length_limit_COM = length_limit; + } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) { + marker->process_APPn[marker_code - (int) M_APP0] = processor; + marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit; + } else + ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); +} + +#endif /* SAVE_MARKERS_SUPPORTED */ + + +/* + * Install a special processing method for COM or APPn markers. + */ + +GLOBAL(void) +jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine) +{ + my_marker_ptr marker = (my_marker_ptr) cinfo->marker; + + if (marker_code == (int) M_COM) + marker->process_COM = routine; + else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) + marker->process_APPn[marker_code - (int) M_APP0] = routine; + else + ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); +} diff --git a/TMessagesProj/jni/libjpeg/jdmaster.c b/TMessagesProj/jni/libjpeg/jdmaster.c new file mode 100755 index 000000000..e3da758b1 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdmaster.c @@ -0,0 +1,580 @@ +/* + * jdmaster.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains master control logic for the JPEG decompressor. + * These routines are concerned with selecting the modules to be executed + * and with determining the number of passes and the work to be done in each + * pass. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Private state */ + +typedef struct { + struct jpeg_decomp_master pub; /* public fields */ + + int pass_number; /* # of passes completed */ + + boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */ + + /* Saved references to initialized quantizer modules, + * in case we need to switch modes. + */ + struct jpeg_color_quantizer * quantizer_1pass; + struct jpeg_color_quantizer * quantizer_2pass; +} my_decomp_master; + +typedef my_decomp_master * my_master_ptr; + + +/* + * Determine whether merged upsample/color conversion should be used. + * CRUCIAL: this must match the actual capabilities of jdmerge.c! + */ + +LOCAL(boolean) +use_merged_upsample (j_decompress_ptr cinfo) +{ +#ifdef UPSAMPLE_MERGING_SUPPORTED + /* Merging is the equivalent of plain box-filter upsampling */ + if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling) + return FALSE; + +#ifdef ANDROID_RGB + /* jdmerge.c only supports YCC=>RGB565 and YCC=>RGB color conversion */ + if (cinfo->jpeg_color_space != JCS_YCbCr || + cinfo->num_components != 3 || + cinfo->out_color_components != 3 || + (cinfo->out_color_space != JCS_RGB_565 && + cinfo->out_color_space != JCS_RGB)) { + return FALSE; + } +#else + /* jdmerge.c only supports YCC=>RGB color conversion */ + if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 || + cinfo->out_color_space != JCS_RGB || + cinfo->out_color_components != RGB_PIXELSIZE) + return FALSE; +#endif + + /* and it only handles 2h1v or 2h2v sampling ratios */ + if (cinfo->comp_info[0].h_samp_factor != 2 || + cinfo->comp_info[1].h_samp_factor != 1 || + cinfo->comp_info[2].h_samp_factor != 1 || + cinfo->comp_info[0].v_samp_factor > 2 || + cinfo->comp_info[1].v_samp_factor != 1 || + cinfo->comp_info[2].v_samp_factor != 1) + return FALSE; + /* furthermore, it doesn't work if we've scaled the IDCTs differently */ + if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size || + cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size || + cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size) + return FALSE; + /* ??? also need to test for upsample-time rescaling, when & if supported */ + return TRUE; /* by golly, it'll work... */ +#else + return FALSE; +#endif +} + + +/* + * Compute output image dimensions and related values. + * NOTE: this is exported for possible use by application. + * Hence it mustn't do anything that can't be done twice. + * Also note that it may be called before the master module is initialized! + */ + +GLOBAL(void) +jpeg_calc_output_dimensions (j_decompress_ptr cinfo) +/* Do computations that are needed before master selection phase */ +{ +#ifdef IDCT_SCALING_SUPPORTED + int ci; + jpeg_component_info *compptr; +#endif + + /* Prevent application from calling me at wrong times */ +#if ANDROID_TILE_BASED_DECODE + // Tile based decoding may call this function several times. + if (!cinfo->tile_decode) +#endif + if (cinfo->global_state != DSTATE_READY) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + +#ifdef IDCT_SCALING_SUPPORTED + + /* Compute actual output image dimensions and DCT scaling choices. */ + if (cinfo->scale_num * 8 <= cinfo->scale_denom) { + /* Provide 1/8 scaling */ + cinfo->output_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width, 8L); + cinfo->output_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, 8L); + cinfo->min_DCT_scaled_size = 1; + } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) { + /* Provide 1/4 scaling */ + cinfo->output_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width, 4L); + cinfo->output_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, 4L); + cinfo->min_DCT_scaled_size = 2; + } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) { + /* Provide 1/2 scaling */ + cinfo->output_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width, 2L); + cinfo->output_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height, 2L); + cinfo->min_DCT_scaled_size = 4; + } else { + /* Provide 1/1 scaling */ + cinfo->output_width = cinfo->image_width; + cinfo->output_height = cinfo->image_height; + cinfo->min_DCT_scaled_size = DCTSIZE; + } + /* In selecting the actual DCT scaling for each component, we try to + * scale up the chroma components via IDCT scaling rather than upsampling. + * This saves time if the upsampler gets to use 1:1 scaling. + * Note this code assumes that the supported DCT scalings are powers of 2. + */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + int ssize = cinfo->min_DCT_scaled_size; + while (ssize < DCTSIZE && + (compptr->h_samp_factor * ssize * 2 <= + cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) && + (compptr->v_samp_factor * ssize * 2 <= + cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) { + ssize = ssize * 2; + } + compptr->DCT_scaled_size = ssize; + } + + /* Recompute downsampled dimensions of components; + * application needs to know these if using raw downsampled data. + */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Size in samples, after IDCT scaling */ + compptr->downsampled_width = (JDIMENSION) + jdiv_round_up((long) cinfo->image_width * + (long) (compptr->h_samp_factor * compptr->DCT_scaled_size), + (long) (cinfo->max_h_samp_factor * DCTSIZE)); + compptr->downsampled_height = (JDIMENSION) + jdiv_round_up((long) cinfo->image_height * + (long) (compptr->v_samp_factor * compptr->DCT_scaled_size), + (long) (cinfo->max_v_samp_factor * DCTSIZE)); + } + +#else /* !IDCT_SCALING_SUPPORTED */ + + /* Hardwire it to "no scaling" */ + cinfo->output_width = cinfo->image_width; + cinfo->output_height = cinfo->image_height; + /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE, + * and has computed unscaled downsampled_width and downsampled_height. + */ + +#endif /* IDCT_SCALING_SUPPORTED */ + + /* Report number of components in selected colorspace. */ + /* Probably this should be in the color conversion module... */ + switch (cinfo->out_color_space) { + case JCS_GRAYSCALE: + cinfo->out_color_components = 1; + break; + case JCS_RGB: +#if RGB_PIXELSIZE != 3 + cinfo->out_color_components = RGB_PIXELSIZE; + break; +#endif /* else share code with YCbCr */ +#ifdef ANDROID_RGB + case JCS_RGB_565: +#endif + case JCS_YCbCr: + cinfo->out_color_components = 3; + break; + case JCS_CMYK: + case JCS_YCCK: +#ifdef ANDROID_RGB + case JCS_RGBA_8888: +#endif + cinfo->out_color_components = 4; + break; + default: /* else must be same colorspace as in file */ + cinfo->out_color_components = cinfo->num_components; + break; + } + cinfo->output_components = (cinfo->quantize_colors ? 1 : + cinfo->out_color_components); + + /* See if upsampler will want to emit more than one row at a time */ + if (use_merged_upsample(cinfo)) + cinfo->rec_outbuf_height = cinfo->max_v_samp_factor; + else + cinfo->rec_outbuf_height = 1; +} + + +/* + * Several decompression processes need to range-limit values to the range + * 0..MAXJSAMPLE; the input value may fall somewhat outside this range + * due to noise introduced by quantization, roundoff error, etc. These + * processes are inner loops and need to be as fast as possible. On most + * machines, particularly CPUs with pipelines or instruction prefetch, + * a (subscript-check-less) C table lookup + * x = sample_range_limit[x]; + * is faster than explicit tests + * if (x < 0) x = 0; + * else if (x > MAXJSAMPLE) x = MAXJSAMPLE; + * These processes all use a common table prepared by the routine below. + * + * For most steps we can mathematically guarantee that the initial value + * of x is within MAXJSAMPLE+1 of the legal range, so a table running from + * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial + * limiting step (just after the IDCT), a wildly out-of-range value is + * possible if the input data is corrupt. To avoid any chance of indexing + * off the end of memory and getting a bad-pointer trap, we perform the + * post-IDCT limiting thus: + * x = range_limit[x & MASK]; + * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit + * samples. Under normal circumstances this is more than enough range and + * a correct output will be generated; with bogus input data the mask will + * cause wraparound, and we will safely generate a bogus-but-in-range output. + * For the post-IDCT step, we want to convert the data from signed to unsigned + * representation by adding CENTERJSAMPLE at the same time that we limit it. + * So the post-IDCT limiting table ends up looking like this: + * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE, + * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), + * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), + * 0,1,...,CENTERJSAMPLE-1 + * Negative inputs select values from the upper half of the table after + * masking. + * + * We can save some space by overlapping the start of the post-IDCT table + * with the simpler range limiting table. The post-IDCT table begins at + * sample_range_limit + CENTERJSAMPLE. + * + * Note that the table is allocated in near data space on PCs; it's small + * enough and used often enough to justify this. + */ + +LOCAL(void) +prepare_range_limit_table (j_decompress_ptr cinfo) +/* Allocate and fill in the sample_range_limit table */ +{ + JSAMPLE * table; + int i; + + table = (JSAMPLE *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE)); + table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */ + cinfo->sample_range_limit = table; + /* First segment of "simple" table: limit[x] = 0 for x < 0 */ + MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE)); + /* Main part of "simple" table: limit[x] = x */ + for (i = 0; i <= MAXJSAMPLE; i++) + table[i] = (JSAMPLE) i; + table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */ + /* End of simple table, rest of first half of post-IDCT table */ + for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++) + table[i] = MAXJSAMPLE; + /* Second half of post-IDCT table */ + MEMZERO(table + (2 * (MAXJSAMPLE+1)), + (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE)); + MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE), + cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE)); +} + + +/* + * Master selection of decompression modules. + * This is done once at jpeg_start_decompress time. We determine + * which modules will be used and give them appropriate initialization calls. + * We also initialize the decompressor input side to begin consuming data. + * + * Since jpeg_read_header has finished, we know what is in the SOF + * and (first) SOS markers. We also have all the application parameter + * settings. + */ + +LOCAL(void) +master_selection (j_decompress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + boolean use_c_buffer; + long samplesperrow; + JDIMENSION jd_samplesperrow; + + /* Initialize dimensions and other stuff */ + jpeg_calc_output_dimensions(cinfo); + prepare_range_limit_table(cinfo); + + /* Width of an output scanline must be representable as JDIMENSION. */ + samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components; + jd_samplesperrow = (JDIMENSION) samplesperrow; + if ((long) jd_samplesperrow != samplesperrow) + ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); + + /* Initialize my private state */ + master->pass_number = 0; + master->using_merged_upsample = use_merged_upsample(cinfo); + + /* Color quantizer selection */ + master->quantizer_1pass = NULL; + master->quantizer_2pass = NULL; + /* No mode changes if not using buffered-image mode. */ + if (! cinfo->quantize_colors || ! cinfo->buffered_image) { + cinfo->enable_1pass_quant = FALSE; + cinfo->enable_external_quant = FALSE; + cinfo->enable_2pass_quant = FALSE; + } + if (cinfo->quantize_colors) { + if (cinfo->raw_data_out) + ERREXIT(cinfo, JERR_NOTIMPL); + /* 2-pass quantizer only works in 3-component color space. */ + if (cinfo->out_color_components != 3) { + cinfo->enable_1pass_quant = TRUE; + cinfo->enable_external_quant = FALSE; + cinfo->enable_2pass_quant = FALSE; + cinfo->colormap = NULL; + } else if (cinfo->colormap != NULL) { + cinfo->enable_external_quant = TRUE; + } else if (cinfo->two_pass_quantize) { + cinfo->enable_2pass_quant = TRUE; + } else { + cinfo->enable_1pass_quant = TRUE; + } + + if (cinfo->enable_1pass_quant) { +#ifdef QUANT_1PASS_SUPPORTED + jinit_1pass_quantizer(cinfo); + master->quantizer_1pass = cinfo->cquantize; +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } + + /* We use the 2-pass code to map to external colormaps. */ + if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) { +#ifdef QUANT_2PASS_SUPPORTED + jinit_2pass_quantizer(cinfo); + master->quantizer_2pass = cinfo->cquantize; +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } + /* If both quantizers are initialized, the 2-pass one is left active; + * this is necessary for starting with quantization to an external map. + */ + } + + /* Post-processing: in particular, color conversion first */ + if (! cinfo->raw_data_out) { + if (master->using_merged_upsample) { +#ifdef UPSAMPLE_MERGING_SUPPORTED + jinit_merged_upsampler(cinfo); /* does color conversion too */ +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + jinit_color_deconverter(cinfo); + jinit_upsampler(cinfo); + } + jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant); + } + /* Inverse DCT */ + jinit_inverse_dct(cinfo); + /* Entropy decoding: either Huffman or arithmetic coding. */ + if (cinfo->arith_code) { + ERREXIT(cinfo, JERR_ARITH_NOTIMPL); + } else { + if (cinfo->progressive_mode) { +#ifdef D_PROGRESSIVE_SUPPORTED + jinit_phuff_decoder(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else + jinit_huff_decoder(cinfo); + } + + /* Initialize principal buffer controllers. */ + use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image; + jinit_d_coef_controller(cinfo, use_c_buffer); + + if (! cinfo->raw_data_out) + jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */); + + /* We can now tell the memory manager to allocate virtual arrays. */ + (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); + + /* Initialize input side of decompressor to consume first scan. */ + (*cinfo->inputctl->start_input_pass) (cinfo); + +#ifdef D_MULTISCAN_FILES_SUPPORTED + /* If jpeg_start_decompress will read the whole file, initialize + * progress monitoring appropriately. The input step is counted + * as one pass. + */ + if (cinfo->progress != NULL && ! cinfo->buffered_image && + cinfo->inputctl->has_multiple_scans) { + int nscans; + /* Estimate number of scans to set pass_limit. */ + if (cinfo->progressive_mode) { + /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */ + nscans = 2 + 3 * cinfo->num_components; + } else { + /* For a nonprogressive multiscan file, estimate 1 scan per component. */ + nscans = cinfo->num_components; + } + cinfo->progress->pass_counter = 0L; + cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans; + cinfo->progress->completed_passes = 0; + cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2); + /* Count the input pass as done */ + master->pass_number++; + } +#endif /* D_MULTISCAN_FILES_SUPPORTED */ +} + + +/* + * Per-pass setup. + * This is called at the beginning of each output pass. We determine which + * modules will be active during this pass and give them appropriate + * start_pass calls. We also set is_dummy_pass to indicate whether this + * is a "real" output pass or a dummy pass for color quantization. + * (In the latter case, jdapistd.c will crank the pass to completion.) + */ + +METHODDEF(void) +prepare_for_output_pass (j_decompress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + + if (master->pub.is_dummy_pass) { +#ifdef QUANT_2PASS_SUPPORTED + /* Final pass of 2-pass quantization */ + master->pub.is_dummy_pass = FALSE; + (*cinfo->cquantize->start_pass) (cinfo, FALSE); + (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST); + (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif /* QUANT_2PASS_SUPPORTED */ + } else { + if (cinfo->quantize_colors && cinfo->colormap == NULL) { + /* Select new quantization method */ + if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) { + cinfo->cquantize = master->quantizer_2pass; + master->pub.is_dummy_pass = TRUE; + } else if (cinfo->enable_1pass_quant) { + cinfo->cquantize = master->quantizer_1pass; + } else { + ERREXIT(cinfo, JERR_MODE_CHANGE); + } + } + (*cinfo->idct->start_pass) (cinfo); + (*cinfo->coef->start_output_pass) (cinfo); + if (! cinfo->raw_data_out) { + if (! master->using_merged_upsample) + (*cinfo->cconvert->start_pass) (cinfo); + (*cinfo->upsample->start_pass) (cinfo); + if (cinfo->quantize_colors) + (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass); + (*cinfo->post->start_pass) (cinfo, + (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); + (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); + } + } + + /* Set up progress monitor's pass info if present */ + if (cinfo->progress != NULL) { + cinfo->progress->completed_passes = master->pass_number; + cinfo->progress->total_passes = master->pass_number + + (master->pub.is_dummy_pass ? 2 : 1); + /* In buffered-image mode, we assume one more output pass if EOI not + * yet reached, but no more passes if EOI has been reached. + */ + if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) { + cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1); + } + } +} + + +/* + * Finish up at end of an output pass. + */ + +METHODDEF(void) +finish_output_pass (j_decompress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + + if (cinfo->quantize_colors) + (*cinfo->cquantize->finish_pass) (cinfo); + master->pass_number++; +} + + +#ifdef D_MULTISCAN_FILES_SUPPORTED + +/* + * Switch to a new external colormap between output passes. + */ + +GLOBAL(void) +jpeg_new_colormap (j_decompress_ptr cinfo) +{ + my_master_ptr master = (my_master_ptr) cinfo->master; + + /* Prevent application from calling me at wrong times */ + if (cinfo->global_state != DSTATE_BUFIMAGE) + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + + if (cinfo->quantize_colors && cinfo->enable_external_quant && + cinfo->colormap != NULL) { + /* Select 2-pass quantizer for external colormap use */ + cinfo->cquantize = master->quantizer_2pass; + /* Notify quantizer of colormap change */ + (*cinfo->cquantize->new_color_map) (cinfo); + master->pub.is_dummy_pass = FALSE; /* just in case */ + } else + ERREXIT(cinfo, JERR_MODE_CHANGE); +} + +#endif /* D_MULTISCAN_FILES_SUPPORTED */ + + +/* + * Initialize master decompression control and select active modules. + * This is performed at the start of jpeg_start_decompress. + */ + +GLOBAL(void) +jinit_master_decompress (j_decompress_ptr cinfo) +{ + my_master_ptr master; + + master = (my_master_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_decomp_master)); + cinfo->master = (struct jpeg_decomp_master *) master; + master->pub.prepare_for_output_pass = prepare_for_output_pass; + master->pub.finish_output_pass = finish_output_pass; + + master->pub.is_dummy_pass = FALSE; + + master_selection(cinfo); +} diff --git a/TMessagesProj/jni/libjpeg/jdmerge.c b/TMessagesProj/jni/libjpeg/jdmerge.c new file mode 100755 index 000000000..77f33083a --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdmerge.c @@ -0,0 +1,757 @@ +/* + * jdmerge.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains code for merged upsampling/color conversion. + * + * This file combines functions from jdsample.c and jdcolor.c; + * read those files first to understand what's going on. + * + * When the chroma components are to be upsampled by simple replication + * (ie, box filtering), we can save some work in color conversion by + * calculating all the output pixels corresponding to a pair of chroma + * samples at one time. In the conversion equations + * R = Y + K1 * Cr + * G = Y + K2 * Cb + K3 * Cr + * B = Y + K4 * Cb + * only the Y term varies among the group of pixels corresponding to a pair + * of chroma samples, so the rest of the terms can be calculated just once. + * At typical sampling ratios, this eliminates half or three-quarters of the + * multiplications needed for color conversion. + * + * This file currently provides implementations for the following cases: + * YCbCr => RGB color conversion only. + * Sampling ratios of 2h1v or 2h2v. + * No scaling needed at upsample time. + * Corner-aligned (non-CCIR601) sampling alignment. + * Other special cases could be added, but in most applications these are + * the only common cases. (For uncommon cases we fall back on the more + * general code in jdsample.c and jdcolor.c.) + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + +#ifdef UPSAMPLE_MERGING_SUPPORTED + +#ifdef ANDROID_RGB + +/* Declarations for ordered dithering. + * + * We use 4x4 ordered dither array packed into 32 bits. This array is + * sufficent for dithering RGB_888 to RGB_565. + */ + +#define DITHER_MASK 0x3 +#define DITHER_ROTATE(x) (((x)<<24) | (((x)>>8)&0x00FFFFFF)) +static const INT32 dither_matrix[4] = { + 0x0008020A, + 0x0C040E06, + 0x030B0109, + 0x0F070D05 +}; + +#endif + +/* Private subobject */ + +typedef struct { + struct jpeg_upsampler pub; /* public fields */ + + /* Pointer to routine to do actual upsampling/conversion of one row group */ + JMETHOD(void, upmethod, (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf)); + + /* Private state for YCC->RGB conversion */ + int * Cr_r_tab; /* => table for Cr to R conversion */ + int * Cb_b_tab; /* => table for Cb to B conversion */ + INT32 * Cr_g_tab; /* => table for Cr to G conversion */ + INT32 * Cb_g_tab; /* => table for Cb to G conversion */ + + /* For 2:1 vertical sampling, we produce two output rows at a time. + * We need a "spare" row buffer to hold the second output row if the + * application provides just a one-row buffer; we also use the spare + * to discard the dummy last row if the image height is odd. + */ + JSAMPROW spare_row; + boolean spare_full; /* T if spare buffer is occupied */ + + JDIMENSION out_row_width; /* samples per output row */ + JDIMENSION rows_to_go; /* counts rows remaining in image */ +} my_upsampler; + +typedef my_upsampler * my_upsample_ptr; + +#define SCALEBITS 16 /* speediest right-shift on some machines */ +#define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) +#define FIX(x) ((INT32) ((x) * (1L<RGB colorspace conversion. + * This is taken directly from jdcolor.c; see that file for more info. + */ + +LOCAL(void) +build_ycc_rgb_table (j_decompress_ptr cinfo) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + int i; + INT32 x; + SHIFT_TEMPS + + upsample->Cr_r_tab = (int *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(int)); + upsample->Cb_b_tab = (int *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(int)); + upsample->Cr_g_tab = (INT32 *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(INT32)); + upsample->Cb_g_tab = (INT32 *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (MAXJSAMPLE+1) * SIZEOF(INT32)); + + for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { + /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ + /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ + /* Cr=>R value is nearest int to 1.40200 * x */ + upsample->Cr_r_tab[i] = (int) + RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); + /* Cb=>B value is nearest int to 1.77200 * x */ + upsample->Cb_b_tab[i] = (int) + RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); + /* Cr=>G value is scaled-up -0.71414 * x */ + upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x; + /* Cb=>G value is scaled-up -0.34414 * x */ + /* We also add in ONE_HALF so that need not do it in inner loop */ + upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; + } +} + + +/* + * Initialize for an upsampling pass. + */ + +METHODDEF(void) +start_pass_merged_upsample (j_decompress_ptr cinfo) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + + /* Mark the spare buffer empty */ + upsample->spare_full = FALSE; + /* Initialize total-height counter for detecting bottom of image */ + upsample->rows_to_go = cinfo->output_height; +} + + +/* + * Control routine to do upsampling (and color conversion). + * + * The control routine just handles the row buffering considerations. + */ + +METHODDEF(void) +merged_2v_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +/* 2:1 vertical sampling case: may need a spare row. */ +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + JSAMPROW work_ptrs[2]; + JDIMENSION num_rows; /* number of rows returned to caller */ + + if (upsample->spare_full) { + /* If we have a spare row saved from a previous cycle, just return it. */ + JDIMENSION size = upsample->out_row_width; +#ifdef ANDROID_RGB + if (cinfo->out_color_space == JCS_RGB_565) + size = cinfo->output_width*2; +#endif + jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0, + 1, size); + + num_rows = 1; + upsample->spare_full = FALSE; + } else { + /* Figure number of rows to return to caller. */ + num_rows = 2; + /* Not more than the distance to the end of the image. */ + if (num_rows > upsample->rows_to_go) + num_rows = upsample->rows_to_go; + /* And not more than what the client can accept: */ + out_rows_avail -= *out_row_ctr; + if (num_rows > out_rows_avail) + num_rows = out_rows_avail; + /* Create output pointer array for upsampler. */ + work_ptrs[0] = output_buf[*out_row_ctr]; + if (num_rows > 1) { + work_ptrs[1] = output_buf[*out_row_ctr + 1]; + } else { + work_ptrs[1] = upsample->spare_row; + upsample->spare_full = TRUE; + } + /* Now do the upsampling. */ + (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs); + } + + /* Adjust counts */ + *out_row_ctr += num_rows; + upsample->rows_to_go -= num_rows; + /* When the buffer is emptied, declare this input row group consumed */ + if (! upsample->spare_full) + (*in_row_group_ctr)++; +} + + +METHODDEF(void) +merged_1v_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +/* 1:1 vertical sampling case: much easier, never need a spare row. */ +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + + /* Just do the upsampling. */ + (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, + output_buf + *out_row_ctr); + /* Adjust counts */ + (*out_row_ctr)++; + (*in_row_group_ctr)++; +} + + +/* + * These are the routines invoked by the control routines to do + * the actual upsampling/conversion. One row group is processed per call. + * + * Note: since we may be writing directly into application-supplied buffers, + * we have to be honest about the output width; we can't assume the buffer + * has been rounded up to an even width. + */ + + +/* + * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical. + */ + +METHODDEF(void) +h2v1_merged_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr; + JSAMPROW inptr0, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + SHIFT_TEMPS + + inptr0 = input_buf[0][in_row_group_ctr]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr = output_buf[0]; + /* Loop for each pair of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 2 Y values and emit 2 pixels */ + y = GETJSAMPLE(*inptr0++); + outptr[RGB_RED] = range_limit[y + cred]; + outptr[RGB_GREEN] = range_limit[y + cgreen]; + outptr[RGB_BLUE] = range_limit[y + cblue]; + outptr += RGB_PIXELSIZE; + y = GETJSAMPLE(*inptr0++); + outptr[RGB_RED] = range_limit[y + cred]; + outptr[RGB_GREEN] = range_limit[y + cgreen]; + outptr[RGB_BLUE] = range_limit[y + cblue]; + outptr += RGB_PIXELSIZE; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr0); + outptr[RGB_RED] = range_limit[y + cred]; + outptr[RGB_GREEN] = range_limit[y + cgreen]; + outptr[RGB_BLUE] = range_limit[y + cblue]; + } +} + + +#ifdef ANDROID_RGB +METHODDEF(void) +h2v1_merged_upsample_565 (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr; + JSAMPROW inptr0, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + unsigned int r, g, b; + INT32 rgb; + SHIFT_TEMPS + + inptr0 = input_buf[0][in_row_group_ctr]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr = output_buf[0]; + /* Loop for each pair of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 2 Y values and emit 2 pixels */ + y = GETJSAMPLE(*inptr0++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr0++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr, rgb); + outptr += 4; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr0); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } +} + + +METHODDEF(void) +h2v1_merged_upsample_565D (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr; + JSAMPROW inptr0, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + JDIMENSION col_index = 0; + INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; + unsigned int r, g, b; + INT32 rgb; + SHIFT_TEMPS + + inptr0 = input_buf[0][in_row_group_ctr]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr = output_buf[0]; + /* Loop for each pair of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 2 Y values and emit 2 pixels */ + y = GETJSAMPLE(*inptr0++); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr0++); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr, rgb); + outptr += 4; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr0); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr = rgb; + } +} + + +#endif + +/* + * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical. + */ + +METHODDEF(void) +h2v2_merged_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr0, outptr1; + JSAMPROW inptr00, inptr01, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + SHIFT_TEMPS + + inptr00 = input_buf[0][in_row_group_ctr*2]; + inptr01 = input_buf[0][in_row_group_ctr*2 + 1]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr0 = output_buf[0]; + outptr1 = output_buf[1]; + /* Loop for each group of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 4 Y values and emit 4 pixels */ + y = GETJSAMPLE(*inptr00++); + outptr0[RGB_RED] = range_limit[y + cred]; + outptr0[RGB_GREEN] = range_limit[y + cgreen]; + outptr0[RGB_BLUE] = range_limit[y + cblue]; + outptr0 += RGB_PIXELSIZE; + y = GETJSAMPLE(*inptr00++); + outptr0[RGB_RED] = range_limit[y + cred]; + outptr0[RGB_GREEN] = range_limit[y + cgreen]; + outptr0[RGB_BLUE] = range_limit[y + cblue]; + outptr0 += RGB_PIXELSIZE; + y = GETJSAMPLE(*inptr01++); + outptr1[RGB_RED] = range_limit[y + cred]; + outptr1[RGB_GREEN] = range_limit[y + cgreen]; + outptr1[RGB_BLUE] = range_limit[y + cblue]; + outptr1 += RGB_PIXELSIZE; + y = GETJSAMPLE(*inptr01++); + outptr1[RGB_RED] = range_limit[y + cred]; + outptr1[RGB_GREEN] = range_limit[y + cgreen]; + outptr1[RGB_BLUE] = range_limit[y + cblue]; + outptr1 += RGB_PIXELSIZE; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr00); + outptr0[RGB_RED] = range_limit[y + cred]; + outptr0[RGB_GREEN] = range_limit[y + cgreen]; + outptr0[RGB_BLUE] = range_limit[y + cblue]; + y = GETJSAMPLE(*inptr01); + outptr1[RGB_RED] = range_limit[y + cred]; + outptr1[RGB_GREEN] = range_limit[y + cgreen]; + outptr1[RGB_BLUE] = range_limit[y + cblue]; + } +} + + +#ifdef ANDROID_RGB + +METHODDEF(void) +h2v2_merged_upsample_565 (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr0, outptr1; + JSAMPROW inptr00, inptr01, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + unsigned int r, g, b; + INT32 rgb; + SHIFT_TEMPS + + inptr00 = input_buf[0][in_row_group_ctr*2]; + inptr01 = input_buf[0][in_row_group_ctr*2 + 1]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr0 = output_buf[0]; + outptr1 = output_buf[1]; + /* Loop for each group of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 4 Y values and emit 4 pixels */ + y = GETJSAMPLE(*inptr00++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr00++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr0, rgb); + outptr0 += 4; + y = GETJSAMPLE(*inptr01++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr01++); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr1, rgb); + outptr1 += 4; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr00); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr0 = rgb; + y = GETJSAMPLE(*inptr01); + r = range_limit[y + cred]; + g = range_limit[y + cgreen]; + b = range_limit[y + cblue]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr1 = rgb; + } +} + + + +METHODDEF(void) +h2v2_merged_upsample_565D (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + register int y, cred, cgreen, cblue; + int cb, cr; + register JSAMPROW outptr0, outptr1; + JSAMPROW inptr00, inptr01, inptr1, inptr2; + JDIMENSION col; + /* copy these pointers into registers if possible */ + register JSAMPLE * range_limit = cinfo->sample_range_limit; + int * Crrtab = upsample->Cr_r_tab; + int * Cbbtab = upsample->Cb_b_tab; + INT32 * Crgtab = upsample->Cr_g_tab; + INT32 * Cbgtab = upsample->Cb_g_tab; + JDIMENSION col_index = 0; + INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; + INT32 d1 = dither_matrix[(cinfo->output_scanline+1) & DITHER_MASK]; + unsigned int r, g, b; + INT32 rgb; + SHIFT_TEMPS + + inptr00 = input_buf[0][in_row_group_ctr*2]; + inptr01 = input_buf[0][in_row_group_ctr*2 + 1]; + inptr1 = input_buf[1][in_row_group_ctr]; + inptr2 = input_buf[2][in_row_group_ctr]; + outptr0 = output_buf[0]; + outptr1 = output_buf[1]; + /* Loop for each group of output pixels */ + for (col = cinfo->output_width >> 1; col > 0; col--) { + + /* Do the chroma part of the calculation */ + cb = GETJSAMPLE(*inptr1++); + cr = GETJSAMPLE(*inptr2++); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + /* Fetch 4 Y values and emit 4 pixels */ + y = GETJSAMPLE(*inptr00++); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr00++); + r = range_limit[DITHER_565_R(y + cred, d1)]; + g = range_limit[DITHER_565_G(y + cgreen, d1)]; + b = range_limit[DITHER_565_B(y + cblue, d1)]; + d1 = DITHER_ROTATE(d1); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr0, rgb); + outptr0 += 4; + y = GETJSAMPLE(*inptr01++); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + d0 = DITHER_ROTATE(d0); + rgb = PACK_SHORT_565(r,g,b); + y = GETJSAMPLE(*inptr01++); + r = range_limit[DITHER_565_R(y + cred, d1)]; + g = range_limit[DITHER_565_G(y + cgreen, d1)]; + b = range_limit[DITHER_565_B(y + cblue, d1)]; + d1 = DITHER_ROTATE(d1); + rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r,g,b)); + WRITE_TWO_PIXELS(outptr1, rgb); + outptr1 += 4; + } + /* If image width is odd, do the last output column separately */ + if (cinfo->output_width & 1) { + cb = GETJSAMPLE(*inptr1); + cr = GETJSAMPLE(*inptr2); + cred = Crrtab[cr]; + cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); + cblue = Cbbtab[cb]; + y = GETJSAMPLE(*inptr00); + r = range_limit[DITHER_565_R(y + cred, d0)]; + g = range_limit[DITHER_565_G(y + cgreen, d0)]; + b = range_limit[DITHER_565_B(y + cblue, d0)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr0 = rgb; + y = GETJSAMPLE(*inptr01); + r = range_limit[DITHER_565_R(y + cred, d1)]; + g = range_limit[DITHER_565_G(y + cgreen, d1)]; + b = range_limit[DITHER_565_B(y + cblue, d1)]; + rgb = PACK_SHORT_565(r,g,b); + *(INT16*)outptr1 = rgb; + } +} + +#endif + +/* + * Module initialization routine for merged upsampling/color conversion. + * + * NB: this is called under the conditions determined by use_merged_upsample() + * in jdmaster.c. That routine MUST correspond to the actual capabilities + * of this module; no safety checks are made here. + */ + +GLOBAL(void) +jinit_merged_upsampler (j_decompress_ptr cinfo) +{ + my_upsample_ptr upsample; + + upsample = (my_upsample_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_upsampler)); + cinfo->upsample = (struct jpeg_upsampler *) upsample; + upsample->pub.start_pass = start_pass_merged_upsample; + upsample->pub.need_context_rows = FALSE; + + upsample->out_row_width = cinfo->output_width * cinfo->out_color_components; + + if (cinfo->max_v_samp_factor == 2) { + upsample->pub.upsample = merged_2v_upsample; + upsample->upmethod = h2v2_merged_upsample; +#ifdef ANDROID_RGB + if (cinfo->out_color_space == JCS_RGB_565) { + if (cinfo->dither_mode == JDITHER_NONE) { + upsample->upmethod = h2v2_merged_upsample_565; + } else { + upsample->upmethod = h2v2_merged_upsample_565D; + } + } +#endif + /* Allocate a spare row buffer */ + upsample->spare_row = (JSAMPROW) + (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, + (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE))); + } else { + upsample->pub.upsample = merged_1v_upsample; + upsample->upmethod = h2v1_merged_upsample; +#ifdef ANDROID_RGB + if (cinfo->out_color_space == JCS_RGB_565) { + if (cinfo->dither_mode == JDITHER_NONE) { + upsample->upmethod = h2v1_merged_upsample_565; + } else { + upsample->upmethod = h2v1_merged_upsample_565D; + } + } +#endif + /* No spare row needed */ + upsample->spare_row = NULL; + } + + build_ycc_rgb_table(cinfo); +} + +#endif /* UPSAMPLE_MERGING_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jdphuff.c b/TMessagesProj/jni/libjpeg/jdphuff.c new file mode 100755 index 000000000..2f856e07b --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdphuff.c @@ -0,0 +1,770 @@ +/* + * jdphuff.c + * + * Copyright (C) 1995-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains Huffman entropy decoding routines for progressive JPEG. + * + * Much of the complexity here has to do with supporting input suspension. + * If the data source module demands suspension, we want to be able to back + * up to the start of the current MCU. To do this, we copy state variables + * into local working storage, and update them back to the permanent + * storage only upon successful completion of an MCU. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdhuff.h" /* Declarations shared with jdhuff.c */ + + +#ifdef D_PROGRESSIVE_SUPPORTED + +/* + * Expanded entropy decoder object for progressive Huffman decoding. + * + * The savable_state subrecord contains fields that change within an MCU, + * but must not be updated permanently until we complete the MCU. + */ + +typedef struct { + unsigned int EOBRUN; /* remaining EOBs in EOBRUN */ + int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ +} savable_state; + +/* This macro is to work around compilers with missing or broken + * structure assignment. You'll need to fix this code if you have + * such a compiler and you change MAX_COMPS_IN_SCAN. + */ + +#ifndef NO_STRUCT_ASSIGN +#define ASSIGN_STATE(dest,src) ((dest) = (src)) +#else +#if MAX_COMPS_IN_SCAN == 4 +#define ASSIGN_STATE(dest,src) \ + ((dest).EOBRUN = (src).EOBRUN, \ + (dest).last_dc_val[0] = (src).last_dc_val[0], \ + (dest).last_dc_val[1] = (src).last_dc_val[1], \ + (dest).last_dc_val[2] = (src).last_dc_val[2], \ + (dest).last_dc_val[3] = (src).last_dc_val[3]) +#endif +#endif + + +typedef struct { + struct jpeg_entropy_decoder pub; /* public fields */ + + /* These fields are loaded into local variables at start of each MCU. + * In case of suspension, we exit WITHOUT updating them. + */ + bitread_perm_state bitstate; /* Bit buffer at start of MCU */ + savable_state saved; /* Other state at start of MCU */ + + /* These fields are NOT loaded into local working state. */ + unsigned int restarts_to_go; /* MCUs left in this restart interval */ + + /* Pointers to derived tables (these workspaces have image lifespan) */ + d_derived_tbl * derived_tbls[NUM_HUFF_TBLS]; + + d_derived_tbl * ac_derived_tbl; /* active table during an AC scan */ +} phuff_entropy_decoder; + +typedef phuff_entropy_decoder * phuff_entropy_ptr; + +/* Forward declarations */ +METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo, + JBLOCKROW *MCU_data)); +METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo, + JBLOCKROW *MCU_data)); + +/* + * Initialize for a Huffman-compressed scan. + */ + +METHODDEF(void) +start_pass_phuff_decoder (j_decompress_ptr cinfo) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + boolean is_DC_band, bad; + int ci, coefi, tbl; + int *coef_bit_ptr; + jpeg_component_info * compptr; + + is_DC_band = (cinfo->Ss == 0); + + /* Validate scan parameters */ + bad = FALSE; + if (is_DC_band) { + if (cinfo->Se != 0) + bad = TRUE; + } else { + /* need not check Ss/Se < 0 since they came from unsigned bytes */ + if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2) + bad = TRUE; + /* AC scans may have only one component */ + if (cinfo->comps_in_scan != 1) + bad = TRUE; + } + if (cinfo->Ah != 0) { + /* Successive approximation refinement scan: must have Al = Ah-1. */ + if (cinfo->Al != cinfo->Ah-1) + bad = TRUE; + } + if (cinfo->Al > 13) /* need not check for < 0 */ + bad = TRUE; + /* Arguably the maximum Al value should be less than 13 for 8-bit precision, + * but the spec doesn't say so, and we try to be liberal about what we + * accept. Note: large Al values could result in out-of-range DC + * coefficients during early scans, leading to bizarre displays due to + * overflows in the IDCT math. But we won't crash. + */ + if (bad) + ERREXIT4(cinfo, JERR_BAD_PROGRESSION, + cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al); + /* Update progression status, and verify that scan order is legal. + * Note that inter-scan inconsistencies are treated as warnings + * not fatal errors ... not clear if this is right way to behave. + */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + int cindex = cinfo->cur_comp_info[ci]->component_index; + coef_bit_ptr = & cinfo->coef_bits[cindex][0]; + if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */ + WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0); + for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) { + int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi]; + if (cinfo->Ah != expected) + WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi); + coef_bit_ptr[coefi] = cinfo->Al; + } + } + + /* Select MCU decoding routine */ + if (cinfo->Ah == 0) { + if (is_DC_band) + entropy->pub.decode_mcu = decode_mcu_DC_first; + else + entropy->pub.decode_mcu = decode_mcu_AC_first; + } else { + if (is_DC_band) + entropy->pub.decode_mcu = decode_mcu_DC_refine; + else + entropy->pub.decode_mcu = decode_mcu_AC_refine; + } + + for (ci = 0; ci < cinfo->comps_in_scan; ci++) { + compptr = cinfo->cur_comp_info[ci]; + /* Make sure requested tables are present, and compute derived tables. + * We may build same derived table more than once, but it's not expensive. + */ + if (is_DC_band) { + if (cinfo->Ah == 0) { /* DC refinement needs no table */ + tbl = compptr->dc_tbl_no; + jpeg_make_d_derived_tbl(cinfo, TRUE, tbl, + & entropy->derived_tbls[tbl]); + } + } else { + tbl = compptr->ac_tbl_no; + jpeg_make_d_derived_tbl(cinfo, FALSE, tbl, + & entropy->derived_tbls[tbl]); + /* remember the single active table */ + entropy->ac_derived_tbl = entropy->derived_tbls[tbl]; + } + /* Initialize DC predictions to 0 */ + entropy->saved.last_dc_val[ci] = 0; + } + + /* Initialize bitread state variables */ + entropy->bitstate.bits_left = 0; + entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */ + entropy->pub.insufficient_data = FALSE; + + /* Initialize private state variables */ + entropy->saved.EOBRUN = 0; + + /* Initialize restart counter */ + entropy->restarts_to_go = cinfo->restart_interval; +} + + +/* + * Figure F.12: extend sign bit. + * On some machines, a shift and add will be faster than a table lookup. + */ + +#ifdef AVOID_TABLES + +#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x)) + +#else + +#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x)) + +static const int extend_test[16] = /* entry n is 2**(n-1) */ + { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, + 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 }; + +static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */ + { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1, + ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1, + ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1, + ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 }; + +#endif /* AVOID_TABLES */ + + +/* + * Check for a restart marker & resynchronize decoder. + * Returns FALSE if must suspend. + */ + +LOCAL(boolean) +process_restart (j_decompress_ptr cinfo) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + int ci; + + /* Throw away any unused bits remaining in bit buffer; */ + /* include any full bytes in next_marker's count of discarded bytes */ + cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8; + entropy->bitstate.bits_left = 0; + + /* Advance past the RSTn marker */ + if (! (*cinfo->marker->read_restart_marker) (cinfo)) + return FALSE; + + /* Re-initialize DC predictions to 0 */ + for (ci = 0; ci < cinfo->comps_in_scan; ci++) + entropy->saved.last_dc_val[ci] = 0; + /* Re-init EOB run count, too */ + entropy->saved.EOBRUN = 0; + + /* Reset restart counter */ + entropy->restarts_to_go = cinfo->restart_interval; + + /* Reset out-of-data flag, unless read_restart_marker left us smack up + * against a marker. In that case we will end up treating the next data + * segment as empty, and we can avoid producing bogus output pixels by + * leaving the flag set. + */ + if (cinfo->unread_marker == 0) + entropy->pub.insufficient_data = FALSE; + + return TRUE; +} + + +/* + * Huffman MCU decoding. + * Each of these routines decodes and returns one MCU's worth of + * Huffman-compressed coefficients. + * The coefficients are reordered from zigzag order into natural array order, + * but are not dequantized. + * + * The i'th block of the MCU is stored into the block pointed to by + * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER. + * + * We return FALSE if data source requested suspension. In that case no + * changes have been made to permanent state. (Exception: some output + * coefficients may already have been assigned. This is harmless for + * spectral selection, since we'll just re-assign them on the next call. + * Successive approximation AC refinement has to be more careful, however.) + */ + +/* + * MCU decoding for DC initial scan (either spectral selection, + * or first pass of successive approximation). + */ + +METHODDEF(boolean) +decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + int Al = cinfo->Al; + register int s, r; + int blkn, ci; + JBLOCKROW block; + BITREAD_STATE_VARS; + savable_state state; + d_derived_tbl * tbl; + jpeg_component_info * compptr; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + /* If we've run out of data, just leave the MCU set to zeroes. + * This way, we return uniform gray for the remainder of the segment. + */ + if (! entropy->pub.insufficient_data) { + + /* Load up working state */ + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(state, entropy->saved); + + /* Outer loop handles each block in the MCU */ + + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + block = MCU_data[blkn]; + ci = cinfo->MCU_membership[blkn]; + compptr = cinfo->cur_comp_info[ci]; + tbl = entropy->derived_tbls[compptr->dc_tbl_no]; + + /* Decode a single block's worth of coefficients */ + + /* Section F.2.2.1: decode the DC coefficient difference */ + HUFF_DECODE(s, br_state, tbl, return FALSE, label1); + if (s) { + CHECK_BIT_BUFFER(br_state, s, return FALSE); + r = GET_BITS(s); + s = HUFF_EXTEND(r, s); + } + + /* Convert DC difference to actual value, update last_dc_val */ + s += state.last_dc_val[ci]; + state.last_dc_val[ci] = s; + /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */ + (*block)[0] = (JCOEF) (s << Al); + } + + /* Completed MCU, so update state */ + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + ASSIGN_STATE(entropy->saved, state); + } + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; +} + + +/* + * MCU decoding for AC initial scan (either spectral selection, + * or first pass of successive approximation). + */ + +METHODDEF(boolean) +decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + int Se = cinfo->Se; + int Al = cinfo->Al; + register int s, k, r; + unsigned int EOBRUN; + JBLOCKROW block; + BITREAD_STATE_VARS; + d_derived_tbl * tbl; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + /* If we've run out of data, just leave the MCU set to zeroes. + * This way, we return uniform gray for the remainder of the segment. + */ + if (! entropy->pub.insufficient_data) { + + /* Load up working state. + * We can avoid loading/saving bitread state if in an EOB run. + */ + EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */ + + /* There is always only one block per MCU */ + + if (EOBRUN > 0) /* if it's a band of zeroes... */ + EOBRUN--; /* ...process it now (we do nothing) */ + else { + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + block = MCU_data[0]; + tbl = entropy->ac_derived_tbl; + + for (k = cinfo->Ss; k <= Se; k++) { + HUFF_DECODE(s, br_state, tbl, return FALSE, label2); + r = s >> 4; + s &= 15; + if (s) { + k += r; + CHECK_BIT_BUFFER(br_state, s, return FALSE); + r = GET_BITS(s); + s = HUFF_EXTEND(r, s); + /* Scale and output coefficient in natural (dezigzagged) order */ + (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al); + } else { + if (r == 15) { /* ZRL */ + k += 15; /* skip 15 zeroes in band */ + } else { /* EOBr, run length is 2^r + appended bits */ + EOBRUN = 1 << r; + if (r) { /* EOBr, r > 0 */ + CHECK_BIT_BUFFER(br_state, r, return FALSE); + r = GET_BITS(r); + EOBRUN += r; + } + EOBRUN--; /* this band is processed at this moment */ + break; /* force end-of-band */ + } + } + } + + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + } + + /* Completed MCU, so update state */ + entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */ + } + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; +} + + +/* + * MCU decoding for DC successive approximation refinement scan. + * Note: we assume such scans can be multi-component, although the spec + * is not very clear on the point. + */ + +METHODDEF(boolean) +decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ + int blkn; + JBLOCKROW block; + BITREAD_STATE_VARS; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + /* Not worth the cycles to check insufficient_data here, + * since we will not change the data anyway if we read zeroes. + */ + + /* Load up working state */ + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + + /* Outer loop handles each block in the MCU */ + + for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { + block = MCU_data[blkn]; + + /* Encoded data is simply the next bit of the two's-complement DC value */ + CHECK_BIT_BUFFER(br_state, 1, return FALSE); + if (GET_BITS(1)) + (*block)[0] |= p1; + /* Note: since we use |=, repeating the assignment later is safe */ + } + + /* Completed MCU, so update state */ + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; +} + + +/* + * MCU decoding for AC successive approximation refinement scan. + */ + +METHODDEF(boolean) +decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + int Se = cinfo->Se; + int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ + int m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */ + register int s, k, r; + unsigned int EOBRUN; + JBLOCKROW block; + JCOEFPTR thiscoef; + BITREAD_STATE_VARS; + d_derived_tbl * tbl; + int num_newnz; + int newnz_pos[DCTSIZE2]; + + /* Process restart marker if needed; may have to suspend */ + if (cinfo->restart_interval) { + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return FALSE; + } + + /* If we've run out of data, don't modify the MCU. + */ + if (! entropy->pub.insufficient_data) { + + /* Load up working state */ + BITREAD_LOAD_STATE(cinfo,entropy->bitstate); + EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */ + + /* There is always only one block per MCU */ + block = MCU_data[0]; + tbl = entropy->ac_derived_tbl; + + /* If we are forced to suspend, we must undo the assignments to any newly + * nonzero coefficients in the block, because otherwise we'd get confused + * next time about which coefficients were already nonzero. + * But we need not undo addition of bits to already-nonzero coefficients; + * instead, we can test the current bit to see if we already did it. + */ + num_newnz = 0; + + /* initialize coefficient loop counter to start of band */ + k = cinfo->Ss; + + if (EOBRUN == 0) { + for (; k <= Se; k++) { + HUFF_DECODE(s, br_state, tbl, goto undoit, label3); + r = s >> 4; + s &= 15; + if (s) { + if (s != 1) /* size of new coef should always be 1 */ + WARNMS(cinfo, JWRN_HUFF_BAD_CODE); + CHECK_BIT_BUFFER(br_state, 1, goto undoit); + if (GET_BITS(1)) + s = p1; /* newly nonzero coef is positive */ + else + s = m1; /* newly nonzero coef is negative */ + } else { + if (r != 15) { + EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */ + if (r) { + CHECK_BIT_BUFFER(br_state, r, goto undoit); + r = GET_BITS(r); + EOBRUN += r; + } + break; /* rest of block is handled by EOB logic */ + } + /* note s = 0 for processing ZRL */ + } + /* Advance over already-nonzero coefs and r still-zero coefs, + * appending correction bits to the nonzeroes. A correction bit is 1 + * if the absolute value of the coefficient must be increased. + */ + do { + thiscoef = *block + jpeg_natural_order[k]; + if (*thiscoef != 0) { + CHECK_BIT_BUFFER(br_state, 1, goto undoit); + if (GET_BITS(1)) { + if ((*thiscoef & p1) == 0) { /* do nothing if already set it */ + if (*thiscoef >= 0) + *thiscoef += p1; + else + *thiscoef += m1; + } + } + } else { + if (--r < 0) + break; /* reached target zero coefficient */ + } + k++; + } while (k <= Se); + if (s) { + int pos = jpeg_natural_order[k]; + /* Output newly nonzero coefficient */ + (*block)[pos] = (JCOEF) s; + /* Remember its position in case we have to suspend */ + newnz_pos[num_newnz++] = pos; + } + } + } + + if (EOBRUN > 0) { + /* Scan any remaining coefficient positions after the end-of-band + * (the last newly nonzero coefficient, if any). Append a correction + * bit to each already-nonzero coefficient. A correction bit is 1 + * if the absolute value of the coefficient must be increased. + */ + for (; k <= Se; k++) { + thiscoef = *block + jpeg_natural_order[k]; + if (*thiscoef != 0) { + CHECK_BIT_BUFFER(br_state, 1, goto undoit); + if (GET_BITS(1)) { + if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */ + if (*thiscoef >= 0) + *thiscoef += p1; + else + *thiscoef += m1; + } + } + } + } + /* Count one block completed in EOB run */ + EOBRUN--; + } + + /* Completed MCU, so update state */ + BITREAD_SAVE_STATE(cinfo,entropy->bitstate); + entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */ + } + + /* Account for restart interval (no-op if not using restarts) */ + entropy->restarts_to_go--; + + return TRUE; + +undoit: + /* Re-zero any output coefficients that we made newly nonzero */ + while (num_newnz > 0) + (*block)[newnz_pos[--num_newnz]] = 0; + + return FALSE; +} + +/* + * Save the current Huffman decoder position and the bit buffer + * into bitstream_offset and get_buffer, respectively. + */ +GLOBAL(void) +jpeg_get_huffman_decoder_configuration_progressive(j_decompress_ptr cinfo, + huffman_offset_data *offset) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + + if (cinfo->restart_interval) { + // We are at the end of a data segment + if (entropy->restarts_to_go == 0) + if (! process_restart(cinfo)) + return; + } + + // Save restarts_to_go and next_restart_num. + offset->restarts_to_go = (unsigned short) entropy->restarts_to_go; + offset->next_restart_num = cinfo->marker->next_restart_num; + + offset->bitstream_offset = + (jget_input_stream_position(cinfo) << LOG_TWO_BIT_BUF_SIZE) + + entropy->bitstate.bits_left; + + offset->get_buffer = entropy->bitstate.get_buffer; +} + +/* + * Save the current Huffman deocde position and the DC coefficients + * for each component into bitstream_offset and dc_info[], respectively. + */ +METHODDEF(void) +get_huffman_decoder_configuration(j_decompress_ptr cinfo, + huffman_offset_data *offset) +{ + int i; + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + jpeg_get_huffman_decoder_configuration_progressive(cinfo, offset); + offset->EOBRUN = entropy->saved.EOBRUN; + for (i = 0; i < cinfo->comps_in_scan; i++) + offset->prev_dc[i] = entropy->saved.last_dc_val[i]; +} + +/* + * Configure the Huffman decoder reader position and bit buffer. + */ +GLOBAL(void) +jpeg_configure_huffman_decoder_progressive(j_decompress_ptr cinfo, + huffman_offset_data offset) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + + // Restore restarts_to_go and next_restart_num + cinfo->unread_marker = 0; + entropy->restarts_to_go = offset.restarts_to_go; + cinfo->marker->next_restart_num = offset.next_restart_num; + + unsigned int bitstream_offset = offset.bitstream_offset; + int blkn, i; + + unsigned int byte_offset = bitstream_offset >> LOG_TWO_BIT_BUF_SIZE; + unsigned int bit_in_bit_buffer = + bitstream_offset & ((1 << LOG_TWO_BIT_BUF_SIZE) - 1); + + jset_input_stream_position_bit(cinfo, byte_offset, + bit_in_bit_buffer, offset.get_buffer); +} + +/* + * Configure the Huffman decoder to decode the image + * starting from (iMCU_row_offset, iMCU_col_offset). + */ +METHODDEF(void) +configure_huffman_decoder(j_decompress_ptr cinfo, huffman_offset_data offset) +{ + int i; + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + jpeg_configure_huffman_decoder_progressive(cinfo, offset); + entropy->saved.EOBRUN = offset.EOBRUN; + for (i = 0; i < cinfo->comps_in_scan; i++) + entropy->saved.last_dc_val[i] = offset.prev_dc[i]; +} + +GLOBAL(void) +jpeg_configure_huffman_index_scan(j_decompress_ptr cinfo, + huffman_index *index, int scan_no, int offset) +{ + phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; + if (scan_no >= index->scan_count) { + index->scan = realloc(index->scan, + (scan_no + 1) * sizeof(huffman_scan_header)); + index->mem_used += (scan_no - index->scan_count + 1) + * (sizeof(huffman_scan_header) + cinfo->total_iMCU_rows + * sizeof(huffman_offset_data*)); + index->scan_count = scan_no + 1; + } + index->scan[scan_no].offset = (huffman_offset_data**)malloc( + cinfo->total_iMCU_rows * sizeof(huffman_offset_data*)); + index->scan[scan_no].bitstream_offset = offset; +} + +/* + * Module initialization routine for progressive Huffman entropy decoding. + */ +GLOBAL(void) +jinit_phuff_decoder (j_decompress_ptr cinfo) +{ + phuff_entropy_ptr entropy; + int *coef_bit_ptr; + int ci, i; + + entropy = (phuff_entropy_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(phuff_entropy_decoder)); + cinfo->entropy = (struct jpeg_entropy_decoder *) entropy; + entropy->pub.start_pass = start_pass_phuff_decoder; + entropy->pub.configure_huffman_decoder = configure_huffman_decoder; + entropy->pub.get_huffman_decoder_configuration = + get_huffman_decoder_configuration; + + /* Mark derived tables unallocated */ + for (i = 0; i < NUM_HUFF_TBLS; i++) { + entropy->derived_tbls[i] = NULL; + } + + /* Create progression status table */ + cinfo->coef_bits = (int (*)[DCTSIZE2]) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + cinfo->num_components*DCTSIZE2*SIZEOF(int)); + coef_bit_ptr = & cinfo->coef_bits[0][0]; + for (ci = 0; ci < cinfo->num_components; ci++) + for (i = 0; i < DCTSIZE2; i++) + *coef_bit_ptr++ = -1; +} + +#endif /* D_PROGRESSIVE_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jdpostct.c b/TMessagesProj/jni/libjpeg/jdpostct.c new file mode 100755 index 000000000..571563d72 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdpostct.c @@ -0,0 +1,290 @@ +/* + * jdpostct.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the decompression postprocessing controller. + * This controller manages the upsampling, color conversion, and color + * quantization/reduction steps; specifically, it controls the buffering + * between upsample/color conversion and color quantization/reduction. + * + * If no color quantization/reduction is required, then this module has no + * work to do, and it just hands off to the upsample/color conversion code. + * An integrated upsample/convert/quantize process would replace this module + * entirely. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Private buffer controller object */ + +typedef struct { + struct jpeg_d_post_controller pub; /* public fields */ + + /* Color quantization source buffer: this holds output data from + * the upsample/color conversion step to be passed to the quantizer. + * For two-pass color quantization, we need a full-image buffer; + * for one-pass operation, a strip buffer is sufficient. + */ + jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */ + JSAMPARRAY buffer; /* strip buffer, or current strip of virtual */ + JDIMENSION strip_height; /* buffer size in rows */ + /* for two-pass mode only: */ + JDIMENSION starting_row; /* row # of first row in current strip */ + JDIMENSION next_row; /* index of next row to fill/empty in strip */ +} my_post_controller; + +typedef my_post_controller * my_post_ptr; + + +/* Forward declarations */ +METHODDEF(void) post_process_1pass + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); +#ifdef QUANT_2PASS_SUPPORTED +METHODDEF(void) post_process_prepass + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); +METHODDEF(void) post_process_2pass + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); +#endif + + +/* + * Initialize for a processing pass. + */ + +METHODDEF(void) +start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) +{ + my_post_ptr post = (my_post_ptr) cinfo->post; + + switch (pass_mode) { + case JBUF_PASS_THRU: + if (cinfo->quantize_colors) { + /* Single-pass processing with color quantization. */ + post->pub.post_process_data = post_process_1pass; + /* We could be doing buffered-image output before starting a 2-pass + * color quantization; in that case, jinit_d_post_controller did not + * allocate a strip buffer. Use the virtual-array buffer as workspace. + */ + if (post->buffer == NULL) { + post->buffer = (*cinfo->mem->access_virt_sarray) + ((j_common_ptr) cinfo, post->whole_image, + (JDIMENSION) 0, post->strip_height, TRUE); + } + } else { + /* For single-pass processing without color quantization, + * I have no work to do; just call the upsampler directly. + */ + post->pub.post_process_data = cinfo->upsample->upsample; + } + break; +#ifdef QUANT_2PASS_SUPPORTED + case JBUF_SAVE_AND_PASS: + /* First pass of 2-pass quantization */ + if (post->whole_image == NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + post->pub.post_process_data = post_process_prepass; + break; + case JBUF_CRANK_DEST: + /* Second pass of 2-pass quantization */ + if (post->whole_image == NULL) + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + post->pub.post_process_data = post_process_2pass; + break; +#endif /* QUANT_2PASS_SUPPORTED */ + default: + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); + break; + } + post->starting_row = post->next_row = 0; +} + + +/* + * Process some data in the one-pass (strip buffer) case. + * This is used for color precision reduction as well as one-pass quantization. + */ + +METHODDEF(void) +post_process_1pass (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_post_ptr post = (my_post_ptr) cinfo->post; + JDIMENSION num_rows, max_rows; + + /* Fill the buffer, but not more than what we can dump out in one go. */ + /* Note we rely on the upsampler to detect bottom of image. */ + max_rows = out_rows_avail - *out_row_ctr; + if (max_rows > post->strip_height) + max_rows = post->strip_height; + num_rows = 0; + (*cinfo->upsample->upsample) (cinfo, + input_buf, in_row_group_ctr, in_row_groups_avail, + post->buffer, &num_rows, max_rows); + /* Quantize and emit data. */ + (*cinfo->cquantize->color_quantize) (cinfo, + post->buffer, output_buf + *out_row_ctr, (int) num_rows); + *out_row_ctr += num_rows; +} + + +#ifdef QUANT_2PASS_SUPPORTED + +/* + * Process some data in the first pass of 2-pass quantization. + */ + +METHODDEF(void) +post_process_prepass (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_post_ptr post = (my_post_ptr) cinfo->post; + JDIMENSION old_next_row, num_rows; + + /* Reposition virtual buffer if at start of strip. */ + if (post->next_row == 0) { + post->buffer = (*cinfo->mem->access_virt_sarray) + ((j_common_ptr) cinfo, post->whole_image, + post->starting_row, post->strip_height, TRUE); + } + + /* Upsample some data (up to a strip height's worth). */ + old_next_row = post->next_row; + (*cinfo->upsample->upsample) (cinfo, + input_buf, in_row_group_ctr, in_row_groups_avail, + post->buffer, &post->next_row, post->strip_height); + + /* Allow quantizer to scan new data. No data is emitted, */ + /* but we advance out_row_ctr so outer loop can tell when we're done. */ + if (post->next_row > old_next_row) { + num_rows = post->next_row - old_next_row; + (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row, + (JSAMPARRAY) NULL, (int) num_rows); + *out_row_ctr += num_rows; + } + + /* Advance if we filled the strip. */ + if (post->next_row >= post->strip_height) { + post->starting_row += post->strip_height; + post->next_row = 0; + } +} + + +/* + * Process some data in the second pass of 2-pass quantization. + */ + +METHODDEF(void) +post_process_2pass (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_post_ptr post = (my_post_ptr) cinfo->post; + JDIMENSION num_rows, max_rows; + + /* Reposition virtual buffer if at start of strip. */ + if (post->next_row == 0) { + post->buffer = (*cinfo->mem->access_virt_sarray) + ((j_common_ptr) cinfo, post->whole_image, + post->starting_row, post->strip_height, FALSE); + } + + /* Determine number of rows to emit. */ + num_rows = post->strip_height - post->next_row; /* available in strip */ + max_rows = out_rows_avail - *out_row_ctr; /* available in output area */ + if (num_rows > max_rows) + num_rows = max_rows; + /* We have to check bottom of image here, can't depend on upsampler. */ + max_rows = cinfo->output_height - post->starting_row; + if (num_rows > max_rows) + num_rows = max_rows; + + /* Quantize and emit data. */ + (*cinfo->cquantize->color_quantize) (cinfo, + post->buffer + post->next_row, output_buf + *out_row_ctr, + (int) num_rows); + *out_row_ctr += num_rows; + + /* Advance if we filled the strip. */ + post->next_row += num_rows; + if (post->next_row >= post->strip_height) { + post->starting_row += post->strip_height; + post->next_row = 0; + } +} + +#endif /* QUANT_2PASS_SUPPORTED */ + + +/* + * Initialize postprocessing controller. + */ + +GLOBAL(void) +jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer) +{ + my_post_ptr post; + + post = (my_post_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_post_controller)); + cinfo->post = (struct jpeg_d_post_controller *) post; + post->pub.start_pass = start_pass_dpost; + post->whole_image = NULL; /* flag for no virtual arrays */ + post->buffer = NULL; /* flag for no strip buffer */ + + /* Create the quantization buffer, if needed */ + if (cinfo->quantize_colors) { + /* The buffer strip height is max_v_samp_factor, which is typically + * an efficient number of rows for upsampling to return. + * (In the presence of output rescaling, we might want to be smarter?) + */ + post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor; + if (need_full_buffer) { + /* Two-pass color quantization: need full-image storage. */ + /* We round up the number of rows to a multiple of the strip height. */ +#ifdef QUANT_2PASS_SUPPORTED + post->whole_image = (*cinfo->mem->request_virt_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, + cinfo->output_width * cinfo->out_color_components, + (JDIMENSION) jround_up((long) cinfo->output_height, + (long) post->strip_height), + post->strip_height); +#else + ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); +#endif /* QUANT_2PASS_SUPPORTED */ + } else { + /* One-pass color quantization: just make a strip buffer. */ + post->buffer = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + cinfo->output_width * cinfo->out_color_components, + post->strip_height); + } + } +} diff --git a/TMessagesProj/jni/libjpeg/jdsample.c b/TMessagesProj/jni/libjpeg/jdsample.c new file mode 100755 index 000000000..80ffefb2a --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdsample.c @@ -0,0 +1,478 @@ +/* + * jdsample.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains upsampling routines. + * + * Upsampling input data is counted in "row groups". A row group + * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size) + * sample rows of each component. Upsampling will normally produce + * max_v_samp_factor pixel rows from each row group (but this could vary + * if the upsampler is applying a scale factor of its own). + * + * An excellent reference for image resampling is + * Digital Image Warping, George Wolberg, 1990. + * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Pointer to routine to upsample a single component */ +typedef JMETHOD(void, upsample1_ptr, + (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); + +/* Private subobject */ + +typedef struct { + struct jpeg_upsampler pub; /* public fields */ + + /* Color conversion buffer. When using separate upsampling and color + * conversion steps, this buffer holds one upsampled row group until it + * has been color converted and output. + * Note: we do not allocate any storage for component(s) which are full-size, + * ie do not need rescaling. The corresponding entry of color_buf[] is + * simply set to point to the input data array, thereby avoiding copying. + */ + JSAMPARRAY color_buf[MAX_COMPONENTS]; + + /* Per-component upsampling method pointers */ + upsample1_ptr methods[MAX_COMPONENTS]; + + int next_row_out; /* counts rows emitted from color_buf */ + JDIMENSION rows_to_go; /* counts rows remaining in image */ + + /* Height of an input row group for each component. */ + int rowgroup_height[MAX_COMPONENTS]; + + /* These arrays save pixel expansion factors so that int_expand need not + * recompute them each time. They are unused for other upsampling methods. + */ + UINT8 h_expand[MAX_COMPONENTS]; + UINT8 v_expand[MAX_COMPONENTS]; +} my_upsampler; + +typedef my_upsampler * my_upsample_ptr; + + +/* + * Initialize for an upsampling pass. + */ + +METHODDEF(void) +start_pass_upsample (j_decompress_ptr cinfo) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + + /* Mark the conversion buffer empty */ + upsample->next_row_out = cinfo->max_v_samp_factor; + /* Initialize total-height counter for detecting bottom of image */ + upsample->rows_to_go = cinfo->output_height; +} + + +/* + * Control routine to do upsampling (and color conversion). + * + * In this version we upsample each component independently. + * We upsample one row group into the conversion buffer, then apply + * color conversion a row at a time. + */ + +METHODDEF(void) +sep_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + int ci; + jpeg_component_info * compptr; + JDIMENSION num_rows; + + /* Fill the conversion buffer, if it's empty */ + if (upsample->next_row_out >= cinfo->max_v_samp_factor) { + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Invoke per-component upsample method. Notice we pass a POINTER + * to color_buf[ci], so that fullsize_upsample can change it. + */ + (*upsample->methods[ci]) (cinfo, compptr, + input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]), + upsample->color_buf + ci); + } + upsample->next_row_out = 0; + } + + /* Color-convert and emit rows */ + + /* How many we have in the buffer: */ + num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out); + /* Not more than the distance to the end of the image. Need this test + * in case the image height is not a multiple of max_v_samp_factor: + */ + if (num_rows > upsample->rows_to_go) + num_rows = upsample->rows_to_go; + /* And not more than what the client can accept: */ + out_rows_avail -= *out_row_ctr; + if (num_rows > out_rows_avail) + num_rows = out_rows_avail; + + (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf, + (JDIMENSION) upsample->next_row_out, + output_buf + *out_row_ctr, + (int) num_rows); + + /* Adjust counts */ + *out_row_ctr += num_rows; + upsample->rows_to_go -= num_rows; + upsample->next_row_out += num_rows; + /* When the buffer is emptied, declare this input row group consumed */ + if (upsample->next_row_out >= cinfo->max_v_samp_factor) + (*in_row_group_ctr)++; +} + + +/* + * These are the routines invoked by sep_upsample to upsample pixel values + * of a single component. One row group is processed per call. + */ + + +/* + * For full-size components, we just make color_buf[ci] point at the + * input buffer, and thus avoid copying any data. Note that this is + * safe only because sep_upsample doesn't declare the input row group + * "consumed" until we are done color converting and emitting it. + */ + +METHODDEF(void) +fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + *output_data_ptr = input_data; +} + + +/* + * This is a no-op version used for "uninteresting" components. + * These components will not be referenced by color conversion. + */ + +METHODDEF(void) +noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + *output_data_ptr = NULL; /* safety check */ +} + + +/* + * This version handles any integral sampling ratios. + * This is not used for typical JPEG files, so it need not be fast. + * Nor, for that matter, is it particularly accurate: the algorithm is + * simple replication of the input pixel onto the corresponding output + * pixels. The hi-falutin sampling literature refers to this as a + * "box filter". A box filter tends to introduce visible artifacts, + * so if you are actually going to use 3:1 or 4:1 sampling ratios + * you would be well advised to improve this code. + */ + +METHODDEF(void) +int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; + JSAMPARRAY output_data = *output_data_ptr; + register JSAMPROW inptr, outptr; + register JSAMPLE invalue; + register int h; + JSAMPROW outend; + int h_expand, v_expand; + int inrow, outrow; + + h_expand = upsample->h_expand[compptr->component_index]; + v_expand = upsample->v_expand[compptr->component_index]; + + inrow = outrow = 0; + while (outrow < cinfo->max_v_samp_factor) { + /* Generate one output row with proper horizontal expansion */ + inptr = input_data[inrow]; + outptr = output_data[outrow]; + outend = outptr + cinfo->output_width; + while (outptr < outend) { + invalue = *inptr++; /* don't need GETJSAMPLE() here */ + for (h = h_expand; h > 0; h--) { + *outptr++ = invalue; + } + } + /* Generate any additional output rows by duplicating the first one */ + if (v_expand > 1) { + jcopy_sample_rows(output_data, outrow, output_data, outrow+1, + v_expand-1, cinfo->output_width); + } + inrow++; + outrow += v_expand; + } +} + + +/* + * Fast processing for the common case of 2:1 horizontal and 1:1 vertical. + * It's still a box filter. + */ + +METHODDEF(void) +h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + JSAMPARRAY output_data = *output_data_ptr; + register JSAMPROW inptr, outptr; + register JSAMPLE invalue; + JSAMPROW outend; + int inrow; + + for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { + inptr = input_data[inrow]; + outptr = output_data[inrow]; + outend = outptr + cinfo->output_width; + while (outptr < outend) { + invalue = *inptr++; /* don't need GETJSAMPLE() here */ + *outptr++ = invalue; + *outptr++ = invalue; + } + } +} + + +/* + * Fast processing for the common case of 2:1 horizontal and 2:1 vertical. + * It's still a box filter. + */ + +METHODDEF(void) +h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + JSAMPARRAY output_data = *output_data_ptr; + register JSAMPROW inptr, outptr; + register JSAMPLE invalue; + JSAMPROW outend; + int inrow, outrow; + + inrow = outrow = 0; + while (outrow < cinfo->max_v_samp_factor) { + inptr = input_data[inrow]; + outptr = output_data[outrow]; + outend = outptr + cinfo->output_width; + while (outptr < outend) { + invalue = *inptr++; /* don't need GETJSAMPLE() here */ + *outptr++ = invalue; + *outptr++ = invalue; + } + jcopy_sample_rows(output_data, outrow, output_data, outrow+1, + 1, cinfo->output_width); + inrow++; + outrow += 2; + } +} + + +/* + * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical. + * + * The upsampling algorithm is linear interpolation between pixel centers, + * also known as a "triangle filter". This is a good compromise between + * speed and visual quality. The centers of the output pixels are 1/4 and 3/4 + * of the way between input pixel centers. + * + * A note about the "bias" calculations: when rounding fractional values to + * integer, we do not want to always round 0.5 up to the next integer. + * If we did that, we'd introduce a noticeable bias towards larger values. + * Instead, this code is arranged so that 0.5 will be rounded up or down at + * alternate pixel locations (a simple ordered dither pattern). + */ + +METHODDEF(void) +h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + JSAMPARRAY output_data = *output_data_ptr; + register JSAMPROW inptr, outptr; + register int invalue; + register JDIMENSION colctr; + int inrow; + + for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { + inptr = input_data[inrow]; + outptr = output_data[inrow]; + /* Special case for first column */ + invalue = GETJSAMPLE(*inptr++); + *outptr++ = (JSAMPLE) invalue; + *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2); + + for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { + /* General case: 3/4 * nearer pixel + 1/4 * further pixel */ + invalue = GETJSAMPLE(*inptr++) * 3; + *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2); + *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2); + } + + /* Special case for last column */ + invalue = GETJSAMPLE(*inptr); + *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2); + *outptr++ = (JSAMPLE) invalue; + } +} + + +/* + * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical. + * Again a triangle filter; see comments for h2v1 case, above. + * + * It is OK for us to reference the adjacent input rows because we demanded + * context from the main buffer controller (see initialization code). + */ + +METHODDEF(void) +h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) +{ + JSAMPARRAY output_data = *output_data_ptr; + register JSAMPROW inptr0, inptr1, outptr; +#if BITS_IN_JSAMPLE == 8 + register int thiscolsum, lastcolsum, nextcolsum; +#else + register INT32 thiscolsum, lastcolsum, nextcolsum; +#endif + register JDIMENSION colctr; + int inrow, outrow, v; + + inrow = outrow = 0; + while (outrow < cinfo->max_v_samp_factor) { + for (v = 0; v < 2; v++) { + /* inptr0 points to nearest input row, inptr1 points to next nearest */ + inptr0 = input_data[inrow]; + if (v == 0) /* next nearest is row above */ + inptr1 = input_data[inrow-1]; + else /* next nearest is row below */ + inptr1 = input_data[inrow+1]; + outptr = output_data[outrow++]; + + /* Special case for first column */ + thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); + nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); + *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4); + *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); + lastcolsum = thiscolsum; thiscolsum = nextcolsum; + + for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { + /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */ + /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */ + nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); + *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); + *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); + lastcolsum = thiscolsum; thiscolsum = nextcolsum; + } + + /* Special case for last column */ + *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); + *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4); + } + inrow++; + } +} + + +/* + * Module initialization routine for upsampling. + */ + +GLOBAL(void) +jinit_upsampler (j_decompress_ptr cinfo) +{ + my_upsample_ptr upsample; + int ci; + jpeg_component_info * compptr; + boolean need_buffer, do_fancy; + int h_in_group, v_in_group, h_out_group, v_out_group; + + upsample = (my_upsample_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_upsampler)); + cinfo->upsample = (struct jpeg_upsampler *) upsample; + upsample->pub.start_pass = start_pass_upsample; + upsample->pub.upsample = sep_upsample; + upsample->pub.need_context_rows = FALSE; /* until we find out differently */ + + if (cinfo->CCIR601_sampling) /* this isn't supported */ + ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); + + /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1, + * so don't ask for it. + */ + do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1; + + /* Verify we can handle the sampling factors, select per-component methods, + * and create storage as needed. + */ + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + /* Compute size of an "input group" after IDCT scaling. This many samples + * are to be converted to max_h_samp_factor * max_v_samp_factor pixels. + */ + h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; + v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) / + cinfo->min_DCT_scaled_size; + h_out_group = cinfo->max_h_samp_factor; + v_out_group = cinfo->max_v_samp_factor; + upsample->rowgroup_height[ci] = v_in_group; /* save for use later */ + need_buffer = TRUE; + if (! compptr->component_needed) { + /* Don't bother to upsample an uninteresting component. */ + upsample->methods[ci] = noop_upsample; + need_buffer = FALSE; + } else if (h_in_group == h_out_group && v_in_group == v_out_group) { + /* Fullsize components can be processed without any work. */ + upsample->methods[ci] = fullsize_upsample; + need_buffer = FALSE; + } else if (h_in_group * 2 == h_out_group && + v_in_group == v_out_group) { + /* Special cases for 2h1v upsampling */ + if (do_fancy && compptr->downsampled_width > 2) + upsample->methods[ci] = h2v1_fancy_upsample; + else + upsample->methods[ci] = h2v1_upsample; + } else if (h_in_group * 2 == h_out_group && + v_in_group * 2 == v_out_group) { + /* Special cases for 2h2v upsampling */ + if (do_fancy && compptr->downsampled_width > 2) { + upsample->methods[ci] = h2v2_fancy_upsample; + upsample->pub.need_context_rows = TRUE; + } else + upsample->methods[ci] = h2v2_upsample; + } else if ((h_out_group % h_in_group) == 0 && + (v_out_group % v_in_group) == 0) { + /* Generic integral-factors upsampling method */ + upsample->methods[ci] = int_upsample; + upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group); + upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group); + } else + ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); + if (need_buffer) { + upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (JDIMENSION) jround_up((long) cinfo->output_width, + (long) cinfo->max_h_samp_factor), + (JDIMENSION) cinfo->max_v_samp_factor); + } + } +} diff --git a/TMessagesProj/jni/libjpeg/jdtrans.c b/TMessagesProj/jni/libjpeg/jdtrans.c new file mode 100755 index 000000000..586909cb6 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jdtrans.c @@ -0,0 +1,270 @@ +/* + * jdtrans.c + * + * Copyright (C) 1995-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains library routines for transcoding decompression, + * that is, reading raw DCT coefficient arrays from an input JPEG file. + * The routines in jdapimin.c will also be needed by a transcoder. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* Forward declarations */ +LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo)); + + +/* + * Read the coefficient arrays from a JPEG file. + * jpeg_read_header must be completed before calling this. + * + * The entire image is read into a set of virtual coefficient-block arrays, + * one per component. The return value is a pointer to the array of + * virtual-array descriptors. These can be manipulated directly via the + * JPEG memory manager, or handed off to jpeg_write_coefficients(). + * To release the memory occupied by the virtual arrays, call + * jpeg_finish_decompress() when done with the data. + * + * An alternative usage is to simply obtain access to the coefficient arrays + * during a buffered-image-mode decompression operation. This is allowed + * after any jpeg_finish_output() call. The arrays can be accessed until + * jpeg_finish_decompress() is called. (Note that any call to the library + * may reposition the arrays, so don't rely on access_virt_barray() results + * to stay valid across library calls.) + * + * Returns NULL if suspended. This case need be checked only if + * a suspending data source is used. + */ + +GLOBAL(jvirt_barray_ptr *) +jpeg_read_coefficients (j_decompress_ptr cinfo) +{ + if (cinfo->global_state == DSTATE_READY) { + /* First call: initialize active modules */ + transdecode_master_selection(cinfo); + cinfo->global_state = DSTATE_RDCOEFS; + } + if (cinfo->global_state == DSTATE_RDCOEFS) { + /* Absorb whole file into the coef buffer */ + for (;;) { + int retcode; + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + /* Absorb some more input */ + retcode = (*cinfo->inputctl->consume_input) (cinfo); + if (retcode == JPEG_SUSPENDED) + return NULL; + if (retcode == JPEG_REACHED_EOI) + break; + /* Advance progress counter if appropriate */ + if (cinfo->progress != NULL && + (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { + if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { + /* startup underestimated number of scans; ratchet up one scan */ + cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; + } + } + } + /* Set state so that jpeg_finish_decompress does the right thing */ + cinfo->global_state = DSTATE_STOPPING; + } + /* At this point we should be in state DSTATE_STOPPING if being used + * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access + * to the coefficients during a full buffered-image-mode decompression. + */ + if ((cinfo->global_state == DSTATE_STOPPING || + cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) { + return cinfo->coef->coef_arrays; + } + /* Oops, improper usage */ + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + return NULL; /* keep compiler happy */ +} + +LOCAL(boolean) +jpeg_build_huffman_index_progressive(j_decompress_ptr cinfo, + huffman_index *index) +{ + if (cinfo->global_state == DSTATE_READY) { + printf("Progressive Mode\n"); + /* First call: initialize active modules */ + transdecode_master_selection(cinfo); + cinfo->global_state = DSTATE_RDCOEFS; + } + if (cinfo->global_state == DSTATE_RDCOEFS) { + int mcu, i; + cinfo->marker->get_sos_marker_position(cinfo, index); + + /* Absorb whole file into the coef buffer */ + for (mcu = 0; mcu < cinfo->total_iMCU_rows; mcu++) { + int retcode = 0; + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + /* Absorb some more input */ + jinit_phuff_decoder(cinfo); + for (i = 0; i < index->scan_count; i++) { + (*cinfo->inputctl->finish_input_pass) (cinfo); + jset_input_stream_position(cinfo, index->scan[i].bitstream_offset); + cinfo->unread_marker = 0; + retcode = (*cinfo->inputctl->consume_input_build_huffman_index) + (cinfo, index, i); + if (retcode == JPEG_REACHED_EOI) + break; + cinfo->input_iMCU_row = mcu; + if (mcu != 0) + (*cinfo->entropy->configure_huffman_decoder) + (cinfo, index->scan[i].prev_MCU_offset); + cinfo->input_scan_number = i; + retcode = (*cinfo->inputctl->consume_input_build_huffman_index) + (cinfo, index, i); + } + if (retcode == JPEG_SUSPENDED) + return FALSE; + if (retcode == JPEG_REACHED_EOI) + break; + /* Advance progress counter if appropriate */ + if (cinfo->progress != NULL && + (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { + if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { + /* startup underestimated number of scans; ratchet up one scan */ + cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; + } + } + } + cinfo->global_state = DSTATE_STOPPING; + } + /* At this point we should be in state DSTATE_STOPPING if being used + * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access + * to the coefficients during a full buffered-image-mode decompression. + */ + if ((cinfo->global_state == DSTATE_STOPPING || + cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) { + return TRUE; + } + /* Oops, improper usage */ + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + return FALSE; /* keep compiler happy */ +} + +LOCAL(boolean) +jpeg_build_huffman_index_baseline(j_decompress_ptr cinfo, huffman_index *index) +{ + if (cinfo->global_state == DSTATE_READY) { + printf("Baseline Mode\n"); + /* First call: initialize active modules */ + transdecode_master_selection(cinfo); + cinfo->global_state = DSTATE_RDCOEFS; + } + if (cinfo->global_state == DSTATE_RDCOEFS) { + /* Absorb whole file into the coef buffer */ + for (;;) { + int retcode; + /* Call progress monitor hook if present */ + if (cinfo->progress != NULL) + (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); + /* Absorb some more input */ + retcode = (*cinfo->inputctl->consume_input_build_huffman_index) + (cinfo, index, 0); + if (retcode == JPEG_SUSPENDED) + return FALSE; + if (retcode == JPEG_REACHED_EOI) + break; + if (retcode == JPEG_SCAN_COMPLETED) + break; + + /* Advance progress counter if appropriate */ + if (cinfo->progress != NULL && + (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { + if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { + /* startup underestimated number of scans; ratchet up one scan */ + cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; + } + } + } + /* Set state so that jpeg_finish_decompress does the right thing */ + cinfo->global_state = DSTATE_STOPPING; + } + /* At this point we should be in state DSTATE_STOPPING if being used + * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access + * to the coefficients during a full buffered-image-mode decompression. + */ + if ((cinfo->global_state == DSTATE_STOPPING || + cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) { + return TRUE; + } + /* Oops, improper usage */ + ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); + return FALSE; /* keep compiler happy */ +} + +GLOBAL(boolean) +jpeg_build_huffman_index(j_decompress_ptr cinfo, huffman_index *index) +{ + cinfo->tile_decode = TRUE; + if (cinfo->progressive_mode) + return jpeg_build_huffman_index_progressive(cinfo, index); + else + return jpeg_build_huffman_index_baseline(cinfo, index); +} + +/* + * Master selection of decompression modules for transcoding. + * This substitutes for jdmaster.c's initialization of the full decompressor. + */ + +LOCAL(void) +transdecode_master_selection (j_decompress_ptr cinfo) +{ + /* This is effectively a buffered-image operation. */ + cinfo->buffered_image = TRUE; + + /* Entropy decoding: either Huffman or arithmetic coding. */ + if (cinfo->arith_code) { + ERREXIT(cinfo, JERR_ARITH_NOTIMPL); + } else { + if (cinfo->progressive_mode) { +#ifdef D_PROGRESSIVE_SUPPORTED + jinit_phuff_decoder(cinfo); +#else + ERREXIT(cinfo, JERR_NOT_COMPILED); +#endif + } else { + jinit_huff_decoder(cinfo); + } + } + + /* Always get a full-image coefficient buffer. */ + jinit_d_coef_controller(cinfo, TRUE); + + /* We can now tell the memory manager to allocate virtual arrays. */ + (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); + + /* Initialize input side of decompressor to consume first scan. */ + (*cinfo->inputctl->start_input_pass) (cinfo); + + /* Initialize progress monitoring. */ + if (cinfo->progress != NULL) { + int nscans; + /* Estimate number of scans to set pass_limit. */ + if (cinfo->progressive_mode) { + /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */ + nscans = 2 + 3 * cinfo->num_components; + } else if (cinfo->inputctl->has_multiple_scans) { + /* For a nonprogressive multiscan file, estimate 1 scan per component. */ + nscans = cinfo->num_components; + } else { + nscans = 1; + } + cinfo->progress->pass_counter = 0L; + cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans; + cinfo->progress->completed_passes = 0; + cinfo->progress->total_passes = 1; + } +} diff --git a/TMessagesProj/jni/libjpeg/jerror.c b/TMessagesProj/jni/libjpeg/jerror.c new file mode 100755 index 000000000..3da7be86a --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jerror.c @@ -0,0 +1,252 @@ +/* + * jerror.c + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains simple error-reporting and trace-message routines. + * These are suitable for Unix-like systems and others where writing to + * stderr is the right thing to do. Many applications will want to replace + * some or all of these routines. + * + * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile, + * you get a Windows-specific hack to display error messages in a dialog box. + * It ain't much, but it beats dropping error messages into the bit bucket, + * which is what happens to output to stderr under most Windows C compilers. + * + * These routines are used by both the compression and decompression code. + */ + +/* this is not a core library module, so it doesn't define JPEG_INTERNALS */ +#include "jinclude.h" +#include "jpeglib.h" +#include "jversion.h" +#include "jerror.h" + +#ifdef USE_WINDOWS_MESSAGEBOX +#include +#endif + +#ifndef EXIT_FAILURE /* define exit() codes if not provided */ +#define EXIT_FAILURE 1 +#endif + + +/* + * Create the message string table. + * We do this from the master message list in jerror.h by re-reading + * jerror.h with a suitable definition for macro JMESSAGE. + * The message table is made an external symbol just in case any applications + * want to refer to it directly. + */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_std_message_table jMsgTable +#endif + +#define JMESSAGE(code,string) string , + +const char * const jpeg_std_message_table[] = { +#include "jerror.h" + NULL +}; + + +/* + * Error exit handler: must not return to caller. + * + * Applications may override this if they want to get control back after + * an error. Typically one would longjmp somewhere instead of exiting. + * The setjmp buffer can be made a private field within an expanded error + * handler object. Note that the info needed to generate an error message + * is stored in the error object, so you can generate the message now or + * later, at your convenience. + * You should make sure that the JPEG object is cleaned up (with jpeg_abort + * or jpeg_destroy) at some point. + */ + +METHODDEF(void) +error_exit (j_common_ptr cinfo) +{ + /* Always display the message */ + (*cinfo->err->output_message) (cinfo); + + /* Let the memory manager delete any temp files before we die */ + jpeg_destroy(cinfo); + + exit(EXIT_FAILURE); +} + + +/* + * Actual output of an error or trace message. + * Applications may override this method to send JPEG messages somewhere + * other than stderr. + * + * On Windows, printing to stderr is generally completely useless, + * so we provide optional code to produce an error-dialog popup. + * Most Windows applications will still prefer to override this routine, + * but if they don't, it'll do something at least marginally useful. + * + * NOTE: to use the library in an environment that doesn't support the + * C stdio library, you may have to delete the call to fprintf() entirely, + * not just not use this routine. + */ + +METHODDEF(void) +output_message (j_common_ptr cinfo) +{ + char buffer[JMSG_LENGTH_MAX]; + + /* Create the message */ + (*cinfo->err->format_message) (cinfo, buffer); + +#ifdef USE_WINDOWS_MESSAGEBOX + /* Display it in a message dialog box */ + MessageBox(GetActiveWindow(), buffer, "JPEG Library Error", + MB_OK | MB_ICONERROR); +#else + /* Send it to stderr, adding a newline */ + fprintf(stderr, "%s\n", buffer); +#endif +} + + +/* + * Decide whether to emit a trace or warning message. + * msg_level is one of: + * -1: recoverable corrupt-data warning, may want to abort. + * 0: important advisory messages (always display to user). + * 1: first level of tracing detail. + * 2,3,...: successively more detailed tracing messages. + * An application might override this method if it wanted to abort on warnings + * or change the policy about which messages to display. + */ + +METHODDEF(void) +emit_message (j_common_ptr cinfo, int msg_level) +{ + struct jpeg_error_mgr * err = cinfo->err; + + if (msg_level < 0) { + /* It's a warning message. Since corrupt files may generate many warnings, + * the policy implemented here is to show only the first warning, + * unless trace_level >= 3. + */ + if (err->num_warnings == 0 || err->trace_level >= 3) + (*err->output_message) (cinfo); + /* Always count warnings in num_warnings. */ + err->num_warnings++; + } else { + /* It's a trace message. Show it if trace_level >= msg_level. */ + if (err->trace_level >= msg_level) + (*err->output_message) (cinfo); + } +} + + +/* + * Format a message string for the most recent JPEG error or message. + * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX + * characters. Note that no '\n' character is added to the string. + * Few applications should need to override this method. + */ + +METHODDEF(void) +format_message (j_common_ptr cinfo, char * buffer) +{ + struct jpeg_error_mgr * err = cinfo->err; + int msg_code = err->msg_code; + const char * msgtext = NULL; + const char * msgptr; + char ch; + boolean isstring; + + /* Look up message string in proper table */ + if (msg_code > 0 && msg_code <= err->last_jpeg_message) { + msgtext = err->jpeg_message_table[msg_code]; + } else if (err->addon_message_table != NULL && + msg_code >= err->first_addon_message && + msg_code <= err->last_addon_message) { + msgtext = err->addon_message_table[msg_code - err->first_addon_message]; + } + + /* Defend against bogus message number */ + if (msgtext == NULL) { + err->msg_parm.i[0] = msg_code; + msgtext = err->jpeg_message_table[0]; + } + + /* Check for string parameter, as indicated by %s in the message text */ + isstring = FALSE; + msgptr = msgtext; + while ((ch = *msgptr++) != '\0') { + if (ch == '%') { + if (*msgptr == 's') isstring = TRUE; + break; + } + } + + /* Format the message into the passed buffer */ + if (isstring) + sprintf(buffer, msgtext, err->msg_parm.s); + else + sprintf(buffer, msgtext, + err->msg_parm.i[0], err->msg_parm.i[1], + err->msg_parm.i[2], err->msg_parm.i[3], + err->msg_parm.i[4], err->msg_parm.i[5], + err->msg_parm.i[6], err->msg_parm.i[7]); +} + + +/* + * Reset error state variables at start of a new image. + * This is called during compression startup to reset trace/error + * processing to default state, without losing any application-specific + * method pointers. An application might possibly want to override + * this method if it has additional error processing state. + */ + +METHODDEF(void) +reset_error_mgr (j_common_ptr cinfo) +{ + cinfo->err->num_warnings = 0; + /* trace_level is not reset since it is an application-supplied parameter */ + cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */ +} + + +/* + * Fill in the standard error-handling methods in a jpeg_error_mgr object. + * Typical call is: + * struct jpeg_compress_struct cinfo; + * struct jpeg_error_mgr err; + * + * cinfo.err = jpeg_std_error(&err); + * after which the application may override some of the methods. + */ + +GLOBAL(struct jpeg_error_mgr *) +jpeg_std_error (struct jpeg_error_mgr * err) +{ + err->error_exit = error_exit; + err->emit_message = emit_message; + err->output_message = output_message; + err->format_message = format_message; + err->reset_error_mgr = reset_error_mgr; + + err->trace_level = 0; /* default = no tracing */ + err->num_warnings = 0; /* no warnings emitted yet */ + err->msg_code = 0; /* may be useful as a flag for "no error" */ + + /* Initialize message table pointers */ + err->jpeg_message_table = jpeg_std_message_table; + err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1; + + err->addon_message_table = NULL; + err->first_addon_message = 0; /* for safety */ + err->last_addon_message = 0; + + return err; +} diff --git a/TMessagesProj/jni/libjpeg/jerror.h b/TMessagesProj/jni/libjpeg/jerror.h new file mode 100755 index 000000000..fc2fffeac --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jerror.h @@ -0,0 +1,291 @@ +/* + * jerror.h + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the error and message codes for the JPEG library. + * Edit this file to add new codes, or to translate the message strings to + * some other language. + * A set of error-reporting macros are defined too. Some applications using + * the JPEG library may wish to include this file to get the error codes + * and/or the macros. + */ + +/* + * To define the enum list of message codes, include this file without + * defining macro JMESSAGE. To create a message string table, include it + * again with a suitable JMESSAGE definition (see jerror.c for an example). + */ +#ifndef JMESSAGE +#ifndef JERROR_H +/* First time through, define the enum list */ +#define JMAKE_ENUM_LIST +#else +/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */ +#define JMESSAGE(code,string) +#endif /* JERROR_H */ +#endif /* JMESSAGE */ + +#ifdef JMAKE_ENUM_LIST + +typedef enum { + +#define JMESSAGE(code,string) code , + +#endif /* JMAKE_ENUM_LIST */ + +JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */ + +/* For maintenance convenience, list is alphabetical by message code name */ +JMESSAGE(JERR_ARITH_NOTIMPL, + "Sorry, there are legal restrictions on arithmetic coding") +JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix") +JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix") +JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode") +JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS") +JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range") +JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported") +JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition") +JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace") +JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace") +JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length") +JMESSAGE(JERR_BAD_LIB_VERSION, + "Wrong JPEG library version: library is %d, caller expects %d") +JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan") +JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d") +JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d") +JMESSAGE(JERR_BAD_PROGRESSION, + "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d") +JMESSAGE(JERR_BAD_PROG_SCRIPT, + "Invalid progressive parameters at scan script entry %d") +JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors") +JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d") +JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d") +JMESSAGE(JERR_BAD_STRUCT_SIZE, + "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u") +JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access") +JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small") +JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here") +JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet") +JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d") +JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request") +JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d") +JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x") +JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d") +JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d") +JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)") +JMESSAGE(JERR_EMS_READ, "Read from EMS failed") +JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed") +JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan") +JMESSAGE(JERR_FILE_READ, "Input file read error") +JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?") +JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet") +JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow") +JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry") +JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels") +JMESSAGE(JERR_INPUT_EMPTY, "Empty input file") +JMESSAGE(JERR_INPUT_EOF, "Premature end of input file") +JMESSAGE(JERR_MISMATCHED_QUANT_TABLE, + "Cannot transcode due to multiple use of quantization table %d") +JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data") +JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change") +JMESSAGE(JERR_NOTIMPL, "Not implemented yet") +JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time") +JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported") +JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined") +JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image") +JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined") +JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x") +JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)") +JMESSAGE(JERR_QUANT_COMPONENTS, + "Cannot quantize more than %d color components") +JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors") +JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors") +JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers") +JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker") +JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x") +JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers") +JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF") +JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s") +JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file") +JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file") +JMESSAGE(JERR_TFILE_WRITE, + "Write failed on temporary file --- out of disk space?") +JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines") +JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x") +JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up") +JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation") +JMESSAGE(JERR_XMS_READ, "Read from XMS failed") +JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed") +JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT) +JMESSAGE(JMSG_VERSION, JVERSION) +JMESSAGE(JTRC_16BIT_TABLES, + "Caution: quantization tables are too coarse for baseline JPEG") +JMESSAGE(JTRC_ADOBE, + "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d") +JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u") +JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u") +JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x") +JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x") +JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d") +JMESSAGE(JTRC_DRI, "Define Restart Interval %u") +JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u") +JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u") +JMESSAGE(JTRC_EOI, "End Of Image") +JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d") +JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d") +JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE, + "Warning: thumbnail image size does not match data length %u") +JMESSAGE(JTRC_JFIF_EXTENSION, + "JFIF extension marker: type 0x%02x, length %u") +JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image") +JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u") +JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x") +JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u") +JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors") +JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors") +JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization") +JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d") +JMESSAGE(JTRC_RST, "RST%d") +JMESSAGE(JTRC_SMOOTH_NOTIMPL, + "Smoothing not supported with nonstandard sampling ratios") +JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d") +JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d") +JMESSAGE(JTRC_SOI, "Start of Image") +JMESSAGE(JTRC_SOS, "Start Of Scan: %d components") +JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d") +JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d") +JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s") +JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s") +JMESSAGE(JTRC_THUMB_JPEG, + "JFIF extension marker: JPEG-compressed thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_PALETTE, + "JFIF extension marker: palette thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_RGB, + "JFIF extension marker: RGB thumbnail image, length %u") +JMESSAGE(JTRC_UNKNOWN_IDS, + "Unrecognized component IDs %d %d %d, assuming YCbCr") +JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u") +JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u") +JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d") +JMESSAGE(JWRN_BOGUS_PROGRESSION, + "Inconsistent progression sequence for component %d coefficient %d") +JMESSAGE(JWRN_EXTRANEOUS_DATA, + "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x") +JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment") +JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code") +JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d") +JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file") +JMESSAGE(JWRN_MUST_RESYNC, + "Corrupt JPEG data: found marker 0x%02x instead of RST%d") +JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG") +JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines") + +#ifdef JMAKE_ENUM_LIST + + JMSG_LASTMSGCODE +} J_MESSAGE_CODE; + +#undef JMAKE_ENUM_LIST +#endif /* JMAKE_ENUM_LIST */ + +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ +#undef JMESSAGE + + +#ifndef JERROR_H +#define JERROR_H + +/* Macros to simplify using the error and trace message stuff */ +/* The first parameter is either type of cinfo pointer */ + +/* Fatal errors (print message and exit) */ +#define ERREXIT(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT3(cinfo,code,p1,p2,p3) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (cinfo)->err->msg_parm.i[3] = (p4), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXITS(cinfo,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) + +#define MAKESTMT(stuff) do { stuff } while (0) + +/* Nonfatal errors (we can keep going, but the data is probably corrupt) */ +#define WARNMS(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) + +/* Informational/debugging messages */ +#define TRACEMS(cinfo,lvl,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS1(cinfo,lvl,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS2(cinfo,lvl,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMSS(cinfo,lvl,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) + +#endif /* JERROR_H */ diff --git a/TMessagesProj/jni/libjpeg/jfdctflt.c b/TMessagesProj/jni/libjpeg/jfdctflt.c new file mode 100755 index 000000000..79d7a0078 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jfdctflt.c @@ -0,0 +1,168 @@ +/* + * jfdctflt.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a floating-point implementation of the + * forward DCT (Discrete Cosine Transform). + * + * This implementation should be more accurate than either of the integer + * DCT implementations. However, it may not give the same results on all + * machines because of differences in roundoff behavior. Speed will depend + * on the hardware's floating point capacity. + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on Arai, Agui, and Nakajima's algorithm for + * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in + * Japanese, but the algorithm is described in the Pennebaker & Mitchell + * JPEG textbook (see REFERENCES section in file README). The following code + * is based directly on figure 4-8 in P&M. + * While an 8-point DCT cannot be done in less than 11 multiplies, it is + * possible to arrange the computation so that many of the multiplies are + * simple scalings of the final outputs. These multiplies can then be + * folded into the multiplications or divisions by the JPEG quantization + * table entries. The AA&N method leaves only 5 multiplies and 29 adds + * to be done in the DCT itself. + * The primary disadvantage of this method is that with a fixed-point + * implementation, accuracy is lost due to imprecise representation of the + * scaled quantization values. However, that problem does not arise if + * we use floating point arithmetic. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_FLOAT_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* + * Perform the forward DCT on one block of samples. + */ + +GLOBAL(void) +jpeg_fdct_float (FAST_FLOAT * data) +{ + FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + FAST_FLOAT tmp10, tmp11, tmp12, tmp13; + FAST_FLOAT z1, z2, z3, z4, z5, z11, z13; + FAST_FLOAT *dataptr; + int ctr; + + /* Pass 1: process rows. */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[0] + dataptr[7]; + tmp7 = dataptr[0] - dataptr[7]; + tmp1 = dataptr[1] + dataptr[6]; + tmp6 = dataptr[1] - dataptr[6]; + tmp2 = dataptr[2] + dataptr[5]; + tmp5 = dataptr[2] - dataptr[5]; + tmp3 = dataptr[3] + dataptr[4]; + tmp4 = dataptr[3] - dataptr[4]; + + /* Even part */ + + tmp10 = tmp0 + tmp3; /* phase 2 */ + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[0] = tmp10 + tmp11; /* phase 3 */ + dataptr[4] = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ + dataptr[2] = tmp13 + z1; /* phase 5 */ + dataptr[6] = tmp13 - z1; + + /* Odd part */ + + tmp10 = tmp4 + tmp5; /* phase 2 */ + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + /* The rotator is modified from fig 4-8 to avoid extra negations. */ + z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ + z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ + z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ + z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ + + z11 = tmp7 + z3; /* phase 5 */ + z13 = tmp7 - z3; + + dataptr[5] = z13 + z2; /* phase 6 */ + dataptr[3] = z13 - z2; + dataptr[1] = z11 + z4; + dataptr[7] = z11 - z4; + + dataptr += DCTSIZE; /* advance pointer to next row */ + } + + /* Pass 2: process columns. */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; + tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; + tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; + tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; + tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; + tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; + tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; + tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; + + /* Even part */ + + tmp10 = tmp0 + tmp3; /* phase 2 */ + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ + dataptr[DCTSIZE*4] = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ + dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ + dataptr[DCTSIZE*6] = tmp13 - z1; + + /* Odd part */ + + tmp10 = tmp4 + tmp5; /* phase 2 */ + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + /* The rotator is modified from fig 4-8 to avoid extra negations. */ + z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ + z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ + z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ + z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ + + z11 = tmp7 + z3; /* phase 5 */ + z13 = tmp7 - z3; + + dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ + dataptr[DCTSIZE*3] = z13 - z2; + dataptr[DCTSIZE*1] = z11 + z4; + dataptr[DCTSIZE*7] = z11 - z4; + + dataptr++; /* advance pointer to next column */ + } +} + +#endif /* DCT_FLOAT_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jfdctfst.c b/TMessagesProj/jni/libjpeg/jfdctfst.c new file mode 100755 index 000000000..ccb378a3b --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jfdctfst.c @@ -0,0 +1,224 @@ +/* + * jfdctfst.c + * + * Copyright (C) 1994-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a fast, not so accurate integer implementation of the + * forward DCT (Discrete Cosine Transform). + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on Arai, Agui, and Nakajima's algorithm for + * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in + * Japanese, but the algorithm is described in the Pennebaker & Mitchell + * JPEG textbook (see REFERENCES section in file README). The following code + * is based directly on figure 4-8 in P&M. + * While an 8-point DCT cannot be done in less than 11 multiplies, it is + * possible to arrange the computation so that many of the multiplies are + * simple scalings of the final outputs. These multiplies can then be + * folded into the multiplications or divisions by the JPEG quantization + * table entries. The AA&N method leaves only 5 multiplies and 29 adds + * to be done in the DCT itself. + * The primary disadvantage of this method is that with fixed-point math, + * accuracy is lost due to imprecise representation of the scaled + * quantization values. The smaller the quantization table entry, the less + * precise the scaled value, so this implementation does worse with high- + * quality-setting files than with low-quality ones. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_IFAST_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* Scaling decisions are generally the same as in the LL&M algorithm; + * see jfdctint.c for more details. However, we choose to descale + * (right shift) multiplication products as soon as they are formed, + * rather than carrying additional fractional bits into subsequent additions. + * This compromises accuracy slightly, but it lets us save a few shifts. + * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) + * everywhere except in the multiplications proper; this saves a good deal + * of work on 16-bit-int machines. + * + * Again to save a few shifts, the intermediate results between pass 1 and + * pass 2 are not upscaled, but are represented only to integral precision. + * + * A final compromise is to represent the multiplicative constants to only + * 8 fractional bits, rather than 13. This saves some shifting work on some + * machines, and may also reduce the cost of multiplication (since there + * are fewer one-bits in the constants). + */ + +#define CONST_BITS 8 + + +/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus + * causing a lot of useless floating-point operations at run time. + * To get around this we use the following pre-calculated constants. + * If you change CONST_BITS you may want to add appropriate values. + * (With a reasonable C compiler, you can just rely on the FIX() macro...) + */ + +#if CONST_BITS == 8 +#define FIX_0_382683433 ((INT32) 98) /* FIX(0.382683433) */ +#define FIX_0_541196100 ((INT32) 139) /* FIX(0.541196100) */ +#define FIX_0_707106781 ((INT32) 181) /* FIX(0.707106781) */ +#define FIX_1_306562965 ((INT32) 334) /* FIX(1.306562965) */ +#else +#define FIX_0_382683433 FIX(0.382683433) +#define FIX_0_541196100 FIX(0.541196100) +#define FIX_0_707106781 FIX(0.707106781) +#define FIX_1_306562965 FIX(1.306562965) +#endif + + +/* We can gain a little more speed, with a further compromise in accuracy, + * by omitting the addition in a descaling shift. This yields an incorrectly + * rounded result half the time... + */ + +#ifndef USE_ACCURATE_ROUNDING +#undef DESCALE +#define DESCALE(x,n) RIGHT_SHIFT(x, n) +#endif + + +/* Multiply a DCTELEM variable by an INT32 constant, and immediately + * descale to yield a DCTELEM result. + */ + +#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) + + +/* + * Perform the forward DCT on one block of samples. + */ + +GLOBAL(void) +jpeg_fdct_ifast (DCTELEM * data) +{ + DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + DCTELEM tmp10, tmp11, tmp12, tmp13; + DCTELEM z1, z2, z3, z4, z5, z11, z13; + DCTELEM *dataptr; + int ctr; + SHIFT_TEMPS + + /* Pass 1: process rows. */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[0] + dataptr[7]; + tmp7 = dataptr[0] - dataptr[7]; + tmp1 = dataptr[1] + dataptr[6]; + tmp6 = dataptr[1] - dataptr[6]; + tmp2 = dataptr[2] + dataptr[5]; + tmp5 = dataptr[2] - dataptr[5]; + tmp3 = dataptr[3] + dataptr[4]; + tmp4 = dataptr[3] - dataptr[4]; + + /* Even part */ + + tmp10 = tmp0 + tmp3; /* phase 2 */ + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[0] = tmp10 + tmp11; /* phase 3 */ + dataptr[4] = tmp10 - tmp11; + + z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ + dataptr[2] = tmp13 + z1; /* phase 5 */ + dataptr[6] = tmp13 - z1; + + /* Odd part */ + + tmp10 = tmp4 + tmp5; /* phase 2 */ + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + /* The rotator is modified from fig 4-8 to avoid extra negations. */ + z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ + z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ + z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ + z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ + + z11 = tmp7 + z3; /* phase 5 */ + z13 = tmp7 - z3; + + dataptr[5] = z13 + z2; /* phase 6 */ + dataptr[3] = z13 - z2; + dataptr[1] = z11 + z4; + dataptr[7] = z11 - z4; + + dataptr += DCTSIZE; /* advance pointer to next row */ + } + + /* Pass 2: process columns. */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; + tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; + tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; + tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; + tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; + tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; + tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; + tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; + + /* Even part */ + + tmp10 = tmp0 + tmp3; /* phase 2 */ + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ + dataptr[DCTSIZE*4] = tmp10 - tmp11; + + z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ + dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ + dataptr[DCTSIZE*6] = tmp13 - z1; + + /* Odd part */ + + tmp10 = tmp4 + tmp5; /* phase 2 */ + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + /* The rotator is modified from fig 4-8 to avoid extra negations. */ + z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ + z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ + z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ + z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ + + z11 = tmp7 + z3; /* phase 5 */ + z13 = tmp7 - z3; + + dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ + dataptr[DCTSIZE*3] = z13 - z2; + dataptr[DCTSIZE*1] = z11 + z4; + dataptr[DCTSIZE*7] = z11 - z4; + + dataptr++; /* advance pointer to next column */ + } +} + +#endif /* DCT_IFAST_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jfdctint.c b/TMessagesProj/jni/libjpeg/jfdctint.c new file mode 100755 index 000000000..0a78b64ae --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jfdctint.c @@ -0,0 +1,283 @@ +/* + * jfdctint.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a slow-but-accurate integer implementation of the + * forward DCT (Discrete Cosine Transform). + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on an algorithm described in + * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT + * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, + * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. + * The primary algorithm described there uses 11 multiplies and 29 adds. + * We use their alternate method with 12 multiplies and 32 adds. + * The advantage of this method is that no data path contains more than one + * multiplication; this allows a very simple and accurate implementation in + * scaled fixed-point arithmetic, with a minimal number of shifts. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_ISLOW_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* + * The poop on this scaling stuff is as follows: + * + * Each 1-D DCT step produces outputs which are a factor of sqrt(N) + * larger than the true DCT outputs. The final outputs are therefore + * a factor of N larger than desired; since N=8 this can be cured by + * a simple right shift at the end of the algorithm. The advantage of + * this arrangement is that we save two multiplications per 1-D DCT, + * because the y0 and y4 outputs need not be divided by sqrt(N). + * In the IJG code, this factor of 8 is removed by the quantization step + * (in jcdctmgr.c), NOT in this module. + * + * We have to do addition and subtraction of the integer inputs, which + * is no problem, and multiplication by fractional constants, which is + * a problem to do in integer arithmetic. We multiply all the constants + * by CONST_SCALE and convert them to integer constants (thus retaining + * CONST_BITS bits of precision in the constants). After doing a + * multiplication we have to divide the product by CONST_SCALE, with proper + * rounding, to produce the correct output. This division can be done + * cheaply as a right shift of CONST_BITS bits. We postpone shifting + * as long as possible so that partial sums can be added together with + * full fractional precision. + * + * The outputs of the first pass are scaled up by PASS1_BITS bits so that + * they are represented to better-than-integral precision. These outputs + * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word + * with the recommended scaling. (For 12-bit sample data, the intermediate + * array is INT32 anyway.) + * + * To avoid overflow of the 32-bit intermediate results in pass 2, we must + * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis + * shows that the values given below are the most effective. + */ + +#if BITS_IN_JSAMPLE == 8 +#define CONST_BITS 13 +#define PASS1_BITS 2 +#else +#define CONST_BITS 13 +#define PASS1_BITS 1 /* lose a little precision to avoid overflow */ +#endif + +/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus + * causing a lot of useless floating-point operations at run time. + * To get around this we use the following pre-calculated constants. + * If you change CONST_BITS you may want to add appropriate values. + * (With a reasonable C compiler, you can just rely on the FIX() macro...) + */ + +#if CONST_BITS == 13 +#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */ +#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */ +#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */ +#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ +#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ +#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */ +#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */ +#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ +#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */ +#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */ +#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ +#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */ +#else +#define FIX_0_298631336 FIX(0.298631336) +#define FIX_0_390180644 FIX(0.390180644) +#define FIX_0_541196100 FIX(0.541196100) +#define FIX_0_765366865 FIX(0.765366865) +#define FIX_0_899976223 FIX(0.899976223) +#define FIX_1_175875602 FIX(1.175875602) +#define FIX_1_501321110 FIX(1.501321110) +#define FIX_1_847759065 FIX(1.847759065) +#define FIX_1_961570560 FIX(1.961570560) +#define FIX_2_053119869 FIX(2.053119869) +#define FIX_2_562915447 FIX(2.562915447) +#define FIX_3_072711026 FIX(3.072711026) +#endif + + +/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. + * For 8-bit samples with the recommended scaling, all the variable + * and constant values involved are no more than 16 bits wide, so a + * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. + * For 12-bit samples, a full 32-bit multiplication will be needed. + */ + +#if BITS_IN_JSAMPLE == 8 +#define MULTIPLY(var,const) MULTIPLY16C16(var,const) +#else +#define MULTIPLY(var,const) ((var) * (const)) +#endif + + +/* + * Perform the forward DCT on one block of samples. + */ + +GLOBAL(void) +jpeg_fdct_islow (DCTELEM * data) +{ + INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + INT32 tmp10, tmp11, tmp12, tmp13; + INT32 z1, z2, z3, z4, z5; + DCTELEM *dataptr; + int ctr; + SHIFT_TEMPS + + /* Pass 1: process rows. */ + /* Note results are scaled up by sqrt(8) compared to a true DCT; */ + /* furthermore, we scale the results by 2**PASS1_BITS. */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[0] + dataptr[7]; + tmp7 = dataptr[0] - dataptr[7]; + tmp1 = dataptr[1] + dataptr[6]; + tmp6 = dataptr[1] - dataptr[6]; + tmp2 = dataptr[2] + dataptr[5]; + tmp5 = dataptr[2] - dataptr[5]; + tmp3 = dataptr[3] + dataptr[4]; + tmp4 = dataptr[3] - dataptr[4]; + + /* Even part per LL&M figure 1 --- note that published figure is faulty; + * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". + */ + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS); + dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS); + + z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); + dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865), + CONST_BITS-PASS1_BITS); + dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065), + CONST_BITS-PASS1_BITS); + + /* Odd part per figure 8 --- note paper omits factor of sqrt(2). + * cK represents cos(K*pi/16). + * i0..i3 in the paper are tmp4..tmp7 here. + */ + + z1 = tmp4 + tmp7; + z2 = tmp5 + tmp6; + z3 = tmp4 + tmp6; + z4 = tmp5 + tmp7; + z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ + + tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS); + dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS); + dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS); + dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS); + + dataptr += DCTSIZE; /* advance pointer to next row */ + } + + /* Pass 2: process columns. + * We remove the PASS1_BITS scaling, but leave the results scaled up + * by an overall factor of 8. + */ + + dataptr = data; + for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { + tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; + tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; + tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; + tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; + tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; + tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; + tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; + tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; + + /* Even part per LL&M figure 1 --- note that published figure is faulty; + * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". + */ + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS); + dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS); + + z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); + dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865), + CONST_BITS+PASS1_BITS); + dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065), + CONST_BITS+PASS1_BITS); + + /* Odd part per figure 8 --- note paper omits factor of sqrt(2). + * cK represents cos(K*pi/16). + * i0..i3 in the paper are tmp4..tmp7 here. + */ + + z1 = tmp4 + tmp7; + z2 = tmp5 + tmp6; + z3 = tmp4 + tmp6; + z4 = tmp5 + tmp7; + z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ + + tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, + CONST_BITS+PASS1_BITS); + dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, + CONST_BITS+PASS1_BITS); + dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, + CONST_BITS+PASS1_BITS); + dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, + CONST_BITS+PASS1_BITS); + + dataptr++; /* advance pointer to next column */ + } +} + +#endif /* DCT_ISLOW_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jidctflt.c b/TMessagesProj/jni/libjpeg/jidctflt.c new file mode 100755 index 000000000..0188ce3df --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jidctflt.c @@ -0,0 +1,242 @@ +/* + * jidctflt.c + * + * Copyright (C) 1994-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a floating-point implementation of the + * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine + * must also perform dequantization of the input coefficients. + * + * This implementation should be more accurate than either of the integer + * IDCT implementations. However, it may not give the same results on all + * machines because of differences in roundoff behavior. Speed will depend + * on the hardware's floating point capacity. + * + * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT + * on each row (or vice versa, but it's more convenient to emit a row at + * a time). Direct algorithms are also available, but they are much more + * complex and seem not to be any faster when reduced to code. + * + * This implementation is based on Arai, Agui, and Nakajima's algorithm for + * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in + * Japanese, but the algorithm is described in the Pennebaker & Mitchell + * JPEG textbook (see REFERENCES section in file README). The following code + * is based directly on figure 4-8 in P&M. + * While an 8-point DCT cannot be done in less than 11 multiplies, it is + * possible to arrange the computation so that many of the multiplies are + * simple scalings of the final outputs. These multiplies can then be + * folded into the multiplications or divisions by the JPEG quantization + * table entries. The AA&N method leaves only 5 multiplies and 29 adds + * to be done in the DCT itself. + * The primary disadvantage of this method is that with a fixed-point + * implementation, accuracy is lost due to imprecise representation of the + * scaled quantization values. However, that problem does not arise if + * we use floating point arithmetic. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_FLOAT_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* Dequantize a coefficient by multiplying it by the multiplier-table + * entry; produce a float result. + */ + +#define DEQUANTIZE(coef,quantval) (((FAST_FLOAT) (coef)) * (quantval)) + + +/* + * Perform dequantization and inverse DCT on one block of coefficients. + */ + +GLOBAL(void) +jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + FAST_FLOAT tmp10, tmp11, tmp12, tmp13; + FAST_FLOAT z5, z10, z11, z12, z13; + JCOEFPTR inptr; + FLOAT_MULT_TYPE * quantptr; + FAST_FLOAT * wsptr; + JSAMPROW outptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + int ctr; + FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */ + SHIFT_TEMPS + + /* Pass 1: process columns from input, store into work array. */ + + inptr = coef_block; + quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table; + wsptr = workspace; + for (ctr = DCTSIZE; ctr > 0; ctr--) { + /* Due to quantization, we will usually find that many of the input + * coefficients are zero, especially the AC terms. We can exploit this + * by short-circuiting the IDCT calculation for any column in which all + * the AC terms are zero. In that case each output is equal to the + * DC coefficient (with scale factor as needed). + * With typical images and quantization tables, half or more of the + * column DCT calculations can be simplified this way. + */ + + if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && + inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && + inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && + inptr[DCTSIZE*7] == 0) { + /* AC terms all zero */ + FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + + wsptr[DCTSIZE*0] = dcval; + wsptr[DCTSIZE*1] = dcval; + wsptr[DCTSIZE*2] = dcval; + wsptr[DCTSIZE*3] = dcval; + wsptr[DCTSIZE*4] = dcval; + wsptr[DCTSIZE*5] = dcval; + wsptr[DCTSIZE*6] = dcval; + wsptr[DCTSIZE*7] = dcval; + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + continue; + } + + /* Even part */ + + tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); + tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); + tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); + + tmp10 = tmp0 + tmp2; /* phase 3 */ + tmp11 = tmp0 - tmp2; + + tmp13 = tmp1 + tmp3; /* phases 5-3 */ + tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */ + + tmp0 = tmp10 + tmp13; /* phase 2 */ + tmp3 = tmp10 - tmp13; + tmp1 = tmp11 + tmp12; + tmp2 = tmp11 - tmp12; + + /* Odd part */ + + tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); + tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); + tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); + tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); + + z13 = tmp6 + tmp5; /* phase 6 */ + z10 = tmp6 - tmp5; + z11 = tmp4 + tmp7; + z12 = tmp4 - tmp7; + + tmp7 = z11 + z13; /* phase 5 */ + tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */ + + z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */ + tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */ + tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */ + + tmp6 = tmp12 - tmp7; /* phase 2 */ + tmp5 = tmp11 - tmp6; + tmp4 = tmp10 + tmp5; + + wsptr[DCTSIZE*0] = tmp0 + tmp7; + wsptr[DCTSIZE*7] = tmp0 - tmp7; + wsptr[DCTSIZE*1] = tmp1 + tmp6; + wsptr[DCTSIZE*6] = tmp1 - tmp6; + wsptr[DCTSIZE*2] = tmp2 + tmp5; + wsptr[DCTSIZE*5] = tmp2 - tmp5; + wsptr[DCTSIZE*4] = tmp3 + tmp4; + wsptr[DCTSIZE*3] = tmp3 - tmp4; + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + } + + /* Pass 2: process rows from work array, store into output array. */ + /* Note that we must descale the results by a factor of 8 == 2**3. */ + + wsptr = workspace; + for (ctr = 0; ctr < DCTSIZE; ctr++) { + outptr = output_buf[ctr] + output_col; + /* Rows of zeroes can be exploited in the same way as we did with columns. + * However, the column calculation has created many nonzero AC terms, so + * the simplification applies less often (typically 5% to 10% of the time). + * And testing floats for zero is relatively expensive, so we don't bother. + */ + + /* Even part */ + + tmp10 = wsptr[0] + wsptr[4]; + tmp11 = wsptr[0] - wsptr[4]; + + tmp13 = wsptr[2] + wsptr[6]; + tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13; + + tmp0 = tmp10 + tmp13; + tmp3 = tmp10 - tmp13; + tmp1 = tmp11 + tmp12; + tmp2 = tmp11 - tmp12; + + /* Odd part */ + + z13 = wsptr[5] + wsptr[3]; + z10 = wsptr[5] - wsptr[3]; + z11 = wsptr[1] + wsptr[7]; + z12 = wsptr[1] - wsptr[7]; + + tmp7 = z11 + z13; + tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); + + z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */ + tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */ + tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */ + + tmp6 = tmp12 - tmp7; + tmp5 = tmp11 - tmp6; + tmp4 = tmp10 + tmp5; + + /* Final output stage: scale down by a factor of 8 and range-limit */ + + outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3) + & RANGE_MASK]; + outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3) + & RANGE_MASK]; + outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3) + & RANGE_MASK]; + outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3) + & RANGE_MASK]; + outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3) + & RANGE_MASK]; + outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3) + & RANGE_MASK]; + outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3) + & RANGE_MASK]; + outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3) + & RANGE_MASK]; + + wsptr += DCTSIZE; /* advance pointer to next row */ + } +} + +#endif /* DCT_FLOAT_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jidctfst.c b/TMessagesProj/jni/libjpeg/jidctfst.c new file mode 100755 index 000000000..dba4216fb --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jidctfst.c @@ -0,0 +1,368 @@ +/* + * jidctfst.c + * + * Copyright (C) 1994-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a fast, not so accurate integer implementation of the + * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine + * must also perform dequantization of the input coefficients. + * + * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT + * on each row (or vice versa, but it's more convenient to emit a row at + * a time). Direct algorithms are also available, but they are much more + * complex and seem not to be any faster when reduced to code. + * + * This implementation is based on Arai, Agui, and Nakajima's algorithm for + * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in + * Japanese, but the algorithm is described in the Pennebaker & Mitchell + * JPEG textbook (see REFERENCES section in file README). The following code + * is based directly on figure 4-8 in P&M. + * While an 8-point DCT cannot be done in less than 11 multiplies, it is + * possible to arrange the computation so that many of the multiplies are + * simple scalings of the final outputs. These multiplies can then be + * folded into the multiplications or divisions by the JPEG quantization + * table entries. The AA&N method leaves only 5 multiplies and 29 adds + * to be done in the DCT itself. + * The primary disadvantage of this method is that with fixed-point math, + * accuracy is lost due to imprecise representation of the scaled + * quantization values. The smaller the quantization table entry, the less + * precise the scaled value, so this implementation does worse with high- + * quality-setting files than with low-quality ones. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_IFAST_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* Scaling decisions are generally the same as in the LL&M algorithm; + * see jidctint.c for more details. However, we choose to descale + * (right shift) multiplication products as soon as they are formed, + * rather than carrying additional fractional bits into subsequent additions. + * This compromises accuracy slightly, but it lets us save a few shifts. + * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) + * everywhere except in the multiplications proper; this saves a good deal + * of work on 16-bit-int machines. + * + * The dequantized coefficients are not integers because the AA&N scaling + * factors have been incorporated. We represent them scaled up by PASS1_BITS, + * so that the first and second IDCT rounds have the same input scaling. + * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to + * avoid a descaling shift; this compromises accuracy rather drastically + * for small quantization table entries, but it saves a lot of shifts. + * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway, + * so we use a much larger scaling factor to preserve accuracy. + * + * A final compromise is to represent the multiplicative constants to only + * 8 fractional bits, rather than 13. This saves some shifting work on some + * machines, and may also reduce the cost of multiplication (since there + * are fewer one-bits in the constants). + */ + +#if BITS_IN_JSAMPLE == 8 +#define CONST_BITS 8 +#define PASS1_BITS 2 +#else +#define CONST_BITS 8 +#define PASS1_BITS 1 /* lose a little precision to avoid overflow */ +#endif + +/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus + * causing a lot of useless floating-point operations at run time. + * To get around this we use the following pre-calculated constants. + * If you change CONST_BITS you may want to add appropriate values. + * (With a reasonable C compiler, you can just rely on the FIX() macro...) + */ + +#if CONST_BITS == 8 +#define FIX_1_082392200 ((INT32) 277) /* FIX(1.082392200) */ +#define FIX_1_414213562 ((INT32) 362) /* FIX(1.414213562) */ +#define FIX_1_847759065 ((INT32) 473) /* FIX(1.847759065) */ +#define FIX_2_613125930 ((INT32) 669) /* FIX(2.613125930) */ +#else +#define FIX_1_082392200 FIX(1.082392200) +#define FIX_1_414213562 FIX(1.414213562) +#define FIX_1_847759065 FIX(1.847759065) +#define FIX_2_613125930 FIX(2.613125930) +#endif + + +/* We can gain a little more speed, with a further compromise in accuracy, + * by omitting the addition in a descaling shift. This yields an incorrectly + * rounded result half the time... + */ + +#ifndef USE_ACCURATE_ROUNDING +#undef DESCALE +#define DESCALE(x,n) RIGHT_SHIFT(x, n) +#endif + + +/* Multiply a DCTELEM variable by an INT32 constant, and immediately + * descale to yield a DCTELEM result. + */ + +#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) + + +/* Dequantize a coefficient by multiplying it by the multiplier-table + * entry; produce a DCTELEM result. For 8-bit data a 16x16->16 + * multiplication will do. For 12-bit data, the multiplier table is + * declared INT32, so a 32-bit multiply will be used. + */ + +#if BITS_IN_JSAMPLE == 8 +#define DEQUANTIZE(coef,quantval) (((IFAST_MULT_TYPE) (coef)) * (quantval)) +#else +#define DEQUANTIZE(coef,quantval) \ + DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS) +#endif + + +/* Like DESCALE, but applies to a DCTELEM and produces an int. + * We assume that int right shift is unsigned if INT32 right shift is. + */ + +#ifdef RIGHT_SHIFT_IS_UNSIGNED +#define ISHIFT_TEMPS DCTELEM ishift_temp; +#if BITS_IN_JSAMPLE == 8 +#define DCTELEMBITS 16 /* DCTELEM may be 16 or 32 bits */ +#else +#define DCTELEMBITS 32 /* DCTELEM must be 32 bits */ +#endif +#define IRIGHT_SHIFT(x,shft) \ + ((ishift_temp = (x)) < 0 ? \ + (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \ + (ishift_temp >> (shft))) +#else +#define ISHIFT_TEMPS +#define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) +#endif + +#ifdef USE_ACCURATE_ROUNDING +#define IDESCALE(x,n) ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n)) +#else +#define IDESCALE(x,n) ((int) IRIGHT_SHIFT(x, n)) +#endif + + +/* + * Perform dequantization and inverse DCT on one block of coefficients. + */ + +GLOBAL(void) +jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + DCTELEM tmp10, tmp11, tmp12, tmp13; + DCTELEM z5, z10, z11, z12, z13; + JCOEFPTR inptr; + IFAST_MULT_TYPE * quantptr; + int * wsptr; + JSAMPROW outptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + int ctr; + int workspace[DCTSIZE2]; /* buffers data between passes */ + SHIFT_TEMPS /* for DESCALE */ + ISHIFT_TEMPS /* for IDESCALE */ + + /* Pass 1: process columns from input, store into work array. */ + + inptr = coef_block; + quantptr = (IFAST_MULT_TYPE *) compptr->dct_table; + wsptr = workspace; + for (ctr = DCTSIZE; ctr > 0; ctr--) { + /* Due to quantization, we will usually find that many of the input + * coefficients are zero, especially the AC terms. We can exploit this + * by short-circuiting the IDCT calculation for any column in which all + * the AC terms are zero. In that case each output is equal to the + * DC coefficient (with scale factor as needed). + * With typical images and quantization tables, half or more of the + * column DCT calculations can be simplified this way. + */ + + if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && + inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && + inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && + inptr[DCTSIZE*7] == 0) { + /* AC terms all zero */ + int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + + wsptr[DCTSIZE*0] = dcval; + wsptr[DCTSIZE*1] = dcval; + wsptr[DCTSIZE*2] = dcval; + wsptr[DCTSIZE*3] = dcval; + wsptr[DCTSIZE*4] = dcval; + wsptr[DCTSIZE*5] = dcval; + wsptr[DCTSIZE*6] = dcval; + wsptr[DCTSIZE*7] = dcval; + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + continue; + } + + /* Even part */ + + tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); + tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); + tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); + + tmp10 = tmp0 + tmp2; /* phase 3 */ + tmp11 = tmp0 - tmp2; + + tmp13 = tmp1 + tmp3; /* phases 5-3 */ + tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */ + + tmp0 = tmp10 + tmp13; /* phase 2 */ + tmp3 = tmp10 - tmp13; + tmp1 = tmp11 + tmp12; + tmp2 = tmp11 - tmp12; + + /* Odd part */ + + tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); + tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); + tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); + tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); + + z13 = tmp6 + tmp5; /* phase 6 */ + z10 = tmp6 - tmp5; + z11 = tmp4 + tmp7; + z12 = tmp4 - tmp7; + + tmp7 = z11 + z13; /* phase 5 */ + tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ + + z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */ + tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */ + tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */ + + tmp6 = tmp12 - tmp7; /* phase 2 */ + tmp5 = tmp11 - tmp6; + tmp4 = tmp10 + tmp5; + + wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7); + wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7); + wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6); + wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6); + wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5); + wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5); + wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4); + wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4); + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + } + + /* Pass 2: process rows from work array, store into output array. */ + /* Note that we must descale the results by a factor of 8 == 2**3, */ + /* and also undo the PASS1_BITS scaling. */ + + wsptr = workspace; + for (ctr = 0; ctr < DCTSIZE; ctr++) { + outptr = output_buf[ctr] + output_col; + /* Rows of zeroes can be exploited in the same way as we did with columns. + * However, the column calculation has created many nonzero AC terms, so + * the simplification applies less often (typically 5% to 10% of the time). + * On machines with very fast multiplication, it's possible that the + * test takes more time than it's worth. In that case this section + * may be commented out. + */ + +#ifndef NO_ZERO_ROW_TEST + if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && + wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { + /* AC terms all zero */ + JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3) + & RANGE_MASK]; + + outptr[0] = dcval; + outptr[1] = dcval; + outptr[2] = dcval; + outptr[3] = dcval; + outptr[4] = dcval; + outptr[5] = dcval; + outptr[6] = dcval; + outptr[7] = dcval; + + wsptr += DCTSIZE; /* advance pointer to next row */ + continue; + } +#endif + + /* Even part */ + + tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]); + tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]); + + tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]); + tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562) + - tmp13; + + tmp0 = tmp10 + tmp13; + tmp3 = tmp10 - tmp13; + tmp1 = tmp11 + tmp12; + tmp2 = tmp11 - tmp12; + + /* Odd part */ + + z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3]; + z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3]; + z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7]; + z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7]; + + tmp7 = z11 + z13; /* phase 5 */ + tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ + + z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */ + tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */ + tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */ + + tmp6 = tmp12 - tmp7; /* phase 2 */ + tmp5 = tmp11 - tmp6; + tmp4 = tmp10 + tmp5; + + /* Final output stage: scale down by a factor of 8 and range-limit */ + + outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3) + & RANGE_MASK]; + outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3) + & RANGE_MASK]; + outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3) + & RANGE_MASK]; + outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3) + & RANGE_MASK]; + outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3) + & RANGE_MASK]; + outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3) + & RANGE_MASK]; + outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3) + & RANGE_MASK]; + outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3) + & RANGE_MASK]; + + wsptr += DCTSIZE; /* advance pointer to next row */ + } +} + +#endif /* DCT_IFAST_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jidctint.c b/TMessagesProj/jni/libjpeg/jidctint.c new file mode 100755 index 000000000..a72b3207c --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jidctint.c @@ -0,0 +1,389 @@ +/* + * jidctint.c + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains a slow-but-accurate integer implementation of the + * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine + * must also perform dequantization of the input coefficients. + * + * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT + * on each row (or vice versa, but it's more convenient to emit a row at + * a time). Direct algorithms are also available, but they are much more + * complex and seem not to be any faster when reduced to code. + * + * This implementation is based on an algorithm described in + * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT + * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, + * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. + * The primary algorithm described there uses 11 multiplies and 29 adds. + * We use their alternate method with 12 multiplies and 32 adds. + * The advantage of this method is that no data path contains more than one + * multiplication; this allows a very simple and accurate implementation in + * scaled fixed-point arithmetic, with a minimal number of shifts. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef DCT_ISLOW_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* + * The poop on this scaling stuff is as follows: + * + * Each 1-D IDCT step produces outputs which are a factor of sqrt(N) + * larger than the true IDCT outputs. The final outputs are therefore + * a factor of N larger than desired; since N=8 this can be cured by + * a simple right shift at the end of the algorithm. The advantage of + * this arrangement is that we save two multiplications per 1-D IDCT, + * because the y0 and y4 inputs need not be divided by sqrt(N). + * + * We have to do addition and subtraction of the integer inputs, which + * is no problem, and multiplication by fractional constants, which is + * a problem to do in integer arithmetic. We multiply all the constants + * by CONST_SCALE and convert them to integer constants (thus retaining + * CONST_BITS bits of precision in the constants). After doing a + * multiplication we have to divide the product by CONST_SCALE, with proper + * rounding, to produce the correct output. This division can be done + * cheaply as a right shift of CONST_BITS bits. We postpone shifting + * as long as possible so that partial sums can be added together with + * full fractional precision. + * + * The outputs of the first pass are scaled up by PASS1_BITS bits so that + * they are represented to better-than-integral precision. These outputs + * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word + * with the recommended scaling. (To scale up 12-bit sample data further, an + * intermediate INT32 array would be needed.) + * + * To avoid overflow of the 32-bit intermediate results in pass 2, we must + * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis + * shows that the values given below are the most effective. + */ + +#if BITS_IN_JSAMPLE == 8 +#define CONST_BITS 13 +#define PASS1_BITS 2 +#else +#define CONST_BITS 13 +#define PASS1_BITS 1 /* lose a little precision to avoid overflow */ +#endif + +/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus + * causing a lot of useless floating-point operations at run time. + * To get around this we use the following pre-calculated constants. + * If you change CONST_BITS you may want to add appropriate values. + * (With a reasonable C compiler, you can just rely on the FIX() macro...) + */ + +#if CONST_BITS == 13 +#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */ +#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */ +#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */ +#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ +#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ +#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */ +#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */ +#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ +#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */ +#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */ +#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ +#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */ +#else +#define FIX_0_298631336 FIX(0.298631336) +#define FIX_0_390180644 FIX(0.390180644) +#define FIX_0_541196100 FIX(0.541196100) +#define FIX_0_765366865 FIX(0.765366865) +#define FIX_0_899976223 FIX(0.899976223) +#define FIX_1_175875602 FIX(1.175875602) +#define FIX_1_501321110 FIX(1.501321110) +#define FIX_1_847759065 FIX(1.847759065) +#define FIX_1_961570560 FIX(1.961570560) +#define FIX_2_053119869 FIX(2.053119869) +#define FIX_2_562915447 FIX(2.562915447) +#define FIX_3_072711026 FIX(3.072711026) +#endif + + +/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. + * For 8-bit samples with the recommended scaling, all the variable + * and constant values involved are no more than 16 bits wide, so a + * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. + * For 12-bit samples, a full 32-bit multiplication will be needed. + */ + +#if BITS_IN_JSAMPLE == 8 +#define MULTIPLY(var,const) MULTIPLY16C16(var,const) +#else +#define MULTIPLY(var,const) ((var) * (const)) +#endif + + +/* Dequantize a coefficient by multiplying it by the multiplier-table + * entry; produce an int result. In this module, both inputs and result + * are 16 bits or less, so either int or short multiply will work. + */ + +#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval)) + + +/* + * Perform dequantization and inverse DCT on one block of coefficients. + */ + +GLOBAL(void) +jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + INT32 tmp0, tmp1, tmp2, tmp3; + INT32 tmp10, tmp11, tmp12, tmp13; + INT32 z1, z2, z3, z4, z5; + JCOEFPTR inptr; + ISLOW_MULT_TYPE * quantptr; + int * wsptr; + JSAMPROW outptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + int ctr; + int workspace[DCTSIZE2]; /* buffers data between passes */ + SHIFT_TEMPS + + /* Pass 1: process columns from input, store into work array. */ + /* Note results are scaled up by sqrt(8) compared to a true IDCT; */ + /* furthermore, we scale the results by 2**PASS1_BITS. */ + + inptr = coef_block; + quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; + wsptr = workspace; + for (ctr = DCTSIZE; ctr > 0; ctr--) { + /* Due to quantization, we will usually find that many of the input + * coefficients are zero, especially the AC terms. We can exploit this + * by short-circuiting the IDCT calculation for any column in which all + * the AC terms are zero. In that case each output is equal to the + * DC coefficient (with scale factor as needed). + * With typical images and quantization tables, half or more of the + * column DCT calculations can be simplified this way. + */ + + if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && + inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && + inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && + inptr[DCTSIZE*7] == 0) { + /* AC terms all zero */ + int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; + + wsptr[DCTSIZE*0] = dcval; + wsptr[DCTSIZE*1] = dcval; + wsptr[DCTSIZE*2] = dcval; + wsptr[DCTSIZE*3] = dcval; + wsptr[DCTSIZE*4] = dcval; + wsptr[DCTSIZE*5] = dcval; + wsptr[DCTSIZE*6] = dcval; + wsptr[DCTSIZE*7] = dcval; + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + continue; + } + + /* Even part: reverse the even part of the forward DCT. */ + /* The rotator is sqrt(2)*c(-6). */ + + z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); + z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); + + z1 = MULTIPLY(z2 + z3, FIX_0_541196100); + tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065); + tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); + + z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); + + tmp0 = (z2 + z3) << CONST_BITS; + tmp1 = (z2 - z3) << CONST_BITS; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + /* Odd part per figure 8; the matrix is unitary and hence its + * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. + */ + + tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); + tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); + tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); + tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); + + z1 = tmp0 + tmp3; + z2 = tmp1 + tmp2; + z3 = tmp0 + tmp2; + z4 = tmp1 + tmp3; + z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ + + tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + tmp0 += z1 + z3; + tmp1 += z2 + z4; + tmp2 += z2 + z3; + tmp3 += z1 + z4; + + /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ + + wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*7] = (int) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*1] = (int) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*6] = (int) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*5] = (int) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*3] = (int) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS); + wsptr[DCTSIZE*4] = (int) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS); + + inptr++; /* advance pointers to next column */ + quantptr++; + wsptr++; + } + + /* Pass 2: process rows from work array, store into output array. */ + /* Note that we must descale the results by a factor of 8 == 2**3, */ + /* and also undo the PASS1_BITS scaling. */ + + wsptr = workspace; + for (ctr = 0; ctr < DCTSIZE; ctr++) { + outptr = output_buf[ctr] + output_col; + /* Rows of zeroes can be exploited in the same way as we did with columns. + * However, the column calculation has created many nonzero AC terms, so + * the simplification applies less often (typically 5% to 10% of the time). + * On machines with very fast multiplication, it's possible that the + * test takes more time than it's worth. In that case this section + * may be commented out. + */ + +#ifndef NO_ZERO_ROW_TEST + if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && + wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { + /* AC terms all zero */ + JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) + & RANGE_MASK]; + + outptr[0] = dcval; + outptr[1] = dcval; + outptr[2] = dcval; + outptr[3] = dcval; + outptr[4] = dcval; + outptr[5] = dcval; + outptr[6] = dcval; + outptr[7] = dcval; + + wsptr += DCTSIZE; /* advance pointer to next row */ + continue; + } +#endif + + /* Even part: reverse the even part of the forward DCT. */ + /* The rotator is sqrt(2)*c(-6). */ + + z2 = (INT32) wsptr[2]; + z3 = (INT32) wsptr[6]; + + z1 = MULTIPLY(z2 + z3, FIX_0_541196100); + tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065); + tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); + + tmp0 = ((INT32) wsptr[0] + (INT32) wsptr[4]) << CONST_BITS; + tmp1 = ((INT32) wsptr[0] - (INT32) wsptr[4]) << CONST_BITS; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + /* Odd part per figure 8; the matrix is unitary and hence its + * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. + */ + + tmp0 = (INT32) wsptr[7]; + tmp1 = (INT32) wsptr[5]; + tmp2 = (INT32) wsptr[3]; + tmp3 = (INT32) wsptr[1]; + + z1 = tmp0 + tmp3; + z2 = tmp1 + tmp2; + z3 = tmp0 + tmp2; + z4 = tmp1 + tmp3; + z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ + + tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + tmp0 += z1 + z3; + tmp1 += z2 + z4; + tmp2 += z2 + z3; + tmp3 += z1 + z4; + + /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ + + outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp3, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[7] = range_limit[(int) DESCALE(tmp10 - tmp3, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[1] = range_limit[(int) DESCALE(tmp11 + tmp2, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[6] = range_limit[(int) DESCALE(tmp11 - tmp2, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[2] = range_limit[(int) DESCALE(tmp12 + tmp1, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[5] = range_limit[(int) DESCALE(tmp12 - tmp1, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[3] = range_limit[(int) DESCALE(tmp13 + tmp0, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + outptr[4] = range_limit[(int) DESCALE(tmp13 - tmp0, + CONST_BITS+PASS1_BITS+3) + & RANGE_MASK]; + + wsptr += DCTSIZE; /* advance pointer to next row */ + } +} + +#endif /* DCT_ISLOW_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jidctred.c b/TMessagesProj/jni/libjpeg/jidctred.c new file mode 100755 index 000000000..421f3c7ca --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jidctred.c @@ -0,0 +1,398 @@ +/* + * jidctred.c + * + * Copyright (C) 1994-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains inverse-DCT routines that produce reduced-size output: + * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block. + * + * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M) + * algorithm used in jidctint.c. We simply replace each 8-to-8 1-D IDCT step + * with an 8-to-4 step that produces the four averages of two adjacent outputs + * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output). + * These steps were derived by computing the corresponding values at the end + * of the normal LL&M code, then simplifying as much as possible. + * + * 1x1 is trivial: just take the DC coefficient divided by 8. + * + * See jidctint.c for additional comments. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" /* Private declarations for DCT subsystem */ + +#ifdef IDCT_SCALING_SUPPORTED + + +/* + * This module is specialized to the case DCTSIZE = 8. + */ + +#if DCTSIZE != 8 + Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ +#endif + + +/* Scaling is the same as in jidctint.c. */ + +#if BITS_IN_JSAMPLE == 8 +#define CONST_BITS 13 +#define PASS1_BITS 2 +#else +#define CONST_BITS 13 +#define PASS1_BITS 1 /* lose a little precision to avoid overflow */ +#endif + +/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus + * causing a lot of useless floating-point operations at run time. + * To get around this we use the following pre-calculated constants. + * If you change CONST_BITS you may want to add appropriate values. + * (With a reasonable C compiler, you can just rely on the FIX() macro...) + */ + +#if CONST_BITS == 13 +#define FIX_0_211164243 ((INT32) 1730) /* FIX(0.211164243) */ +#define FIX_0_509795579 ((INT32) 4176) /* FIX(0.509795579) */ +#define FIX_0_601344887 ((INT32) 4926) /* FIX(0.601344887) */ +#define FIX_0_720959822 ((INT32) 5906) /* FIX(0.720959822) */ +#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ +#define FIX_0_850430095 ((INT32) 6967) /* FIX(0.850430095) */ +#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ +#define FIX_1_061594337 ((INT32) 8697) /* FIX(1.061594337) */ +#define FIX_1_272758580 ((INT32) 10426) /* FIX(1.272758580) */ +#define FIX_1_451774981 ((INT32) 11893) /* FIX(1.451774981) */ +#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ +#define FIX_2_172734803 ((INT32) 17799) /* FIX(2.172734803) */ +#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ +#define FIX_3_624509785 ((INT32) 29692) /* FIX(3.624509785) */ +#else +#define FIX_0_211164243 FIX(0.211164243) +#define FIX_0_509795579 FIX(0.509795579) +#define FIX_0_601344887 FIX(0.601344887) +#define FIX_0_720959822 FIX(0.720959822) +#define FIX_0_765366865 FIX(0.765366865) +#define FIX_0_850430095 FIX(0.850430095) +#define FIX_0_899976223 FIX(0.899976223) +#define FIX_1_061594337 FIX(1.061594337) +#define FIX_1_272758580 FIX(1.272758580) +#define FIX_1_451774981 FIX(1.451774981) +#define FIX_1_847759065 FIX(1.847759065) +#define FIX_2_172734803 FIX(2.172734803) +#define FIX_2_562915447 FIX(2.562915447) +#define FIX_3_624509785 FIX(3.624509785) +#endif + + +/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. + * For 8-bit samples with the recommended scaling, all the variable + * and constant values involved are no more than 16 bits wide, so a + * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. + * For 12-bit samples, a full 32-bit multiplication will be needed. + */ + +#if BITS_IN_JSAMPLE == 8 +#define MULTIPLY(var,const) MULTIPLY16C16(var,const) +#else +#define MULTIPLY(var,const) ((var) * (const)) +#endif + + +/* Dequantize a coefficient by multiplying it by the multiplier-table + * entry; produce an int result. In this module, both inputs and result + * are 16 bits or less, so either int or short multiply will work. + */ + +#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval)) + + +/* + * Perform dequantization and inverse DCT on one block of coefficients, + * producing a reduced-size 4x4 output block. + */ + +GLOBAL(void) +jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + INT32 tmp0, tmp2, tmp10, tmp12; + INT32 z1, z2, z3, z4; + JCOEFPTR inptr; + ISLOW_MULT_TYPE * quantptr; + int * wsptr; + JSAMPROW outptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + int ctr; + int workspace[DCTSIZE*4]; /* buffers data between passes */ + SHIFT_TEMPS + + /* Pass 1: process columns from input, store into work array. */ + + inptr = coef_block; + quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; + wsptr = workspace; + for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) { + /* Don't bother to process column 4, because second pass won't use it */ + if (ctr == DCTSIZE-4) + continue; + if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && + inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 && + inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { + /* AC terms all zero; we need not examine term 4 for 4x4 output */ + int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; + + wsptr[DCTSIZE*0] = dcval; + wsptr[DCTSIZE*1] = dcval; + wsptr[DCTSIZE*2] = dcval; + wsptr[DCTSIZE*3] = dcval; + + continue; + } + + /* Even part */ + + tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + tmp0 <<= (CONST_BITS+1); + + z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); + z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); + + tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, - FIX_0_765366865); + + tmp10 = tmp0 + tmp2; + tmp12 = tmp0 - tmp2; + + /* Odd part */ + + z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); + z2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); + z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); + z4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); + + tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */ + + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */ + + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ + + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */ + + tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */ + + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */ + + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */ + + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */ + + /* Final output stage */ + + wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1); + wsptr[DCTSIZE*3] = (int) DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1); + wsptr[DCTSIZE*1] = (int) DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1); + wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1); + } + + /* Pass 2: process 4 rows from work array, store into output array. */ + + wsptr = workspace; + for (ctr = 0; ctr < 4; ctr++) { + outptr = output_buf[ctr] + output_col; + /* It's not clear whether a zero row test is worthwhile here ... */ + +#ifndef NO_ZERO_ROW_TEST + if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && + wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { + /* AC terms all zero */ + JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) + & RANGE_MASK]; + + outptr[0] = dcval; + outptr[1] = dcval; + outptr[2] = dcval; + outptr[3] = dcval; + + wsptr += DCTSIZE; /* advance pointer to next row */ + continue; + } +#endif + + /* Even part */ + + tmp0 = ((INT32) wsptr[0]) << (CONST_BITS+1); + + tmp2 = MULTIPLY((INT32) wsptr[2], FIX_1_847759065) + + MULTIPLY((INT32) wsptr[6], - FIX_0_765366865); + + tmp10 = tmp0 + tmp2; + tmp12 = tmp0 - tmp2; + + /* Odd part */ + + z1 = (INT32) wsptr[7]; + z2 = (INT32) wsptr[5]; + z3 = (INT32) wsptr[3]; + z4 = (INT32) wsptr[1]; + + tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */ + + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */ + + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ + + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */ + + tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */ + + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */ + + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */ + + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */ + + /* Final output stage */ + + outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp2, + CONST_BITS+PASS1_BITS+3+1) + & RANGE_MASK]; + outptr[3] = range_limit[(int) DESCALE(tmp10 - tmp2, + CONST_BITS+PASS1_BITS+3+1) + & RANGE_MASK]; + outptr[1] = range_limit[(int) DESCALE(tmp12 + tmp0, + CONST_BITS+PASS1_BITS+3+1) + & RANGE_MASK]; + outptr[2] = range_limit[(int) DESCALE(tmp12 - tmp0, + CONST_BITS+PASS1_BITS+3+1) + & RANGE_MASK]; + + wsptr += DCTSIZE; /* advance pointer to next row */ + } +} + + +/* + * Perform dequantization and inverse DCT on one block of coefficients, + * producing a reduced-size 2x2 output block. + */ + +GLOBAL(void) +jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + INT32 tmp0, tmp10, z1; + JCOEFPTR inptr; + ISLOW_MULT_TYPE * quantptr; + int * wsptr; + JSAMPROW outptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + int ctr; + int workspace[DCTSIZE*2]; /* buffers data between passes */ + SHIFT_TEMPS + + /* Pass 1: process columns from input, store into work array. */ + + inptr = coef_block; + quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; + wsptr = workspace; + for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) { + /* Don't bother to process columns 2,4,6 */ + if (ctr == DCTSIZE-2 || ctr == DCTSIZE-4 || ctr == DCTSIZE-6) + continue; + if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*3] == 0 && + inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*7] == 0) { + /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */ + int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; + + wsptr[DCTSIZE*0] = dcval; + wsptr[DCTSIZE*1] = dcval; + + continue; + } + + /* Even part */ + + z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); + tmp10 = z1 << (CONST_BITS+2); + + /* Odd part */ + + z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); + tmp0 = MULTIPLY(z1, - FIX_0_720959822); /* sqrt(2) * (c7-c5+c3-c1) */ + z1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); + tmp0 += MULTIPLY(z1, FIX_0_850430095); /* sqrt(2) * (-c1+c3+c5+c7) */ + z1 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); + tmp0 += MULTIPLY(z1, - FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */ + z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); + tmp0 += MULTIPLY(z1, FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */ + + /* Final output stage */ + + wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2); + wsptr[DCTSIZE*1] = (int) DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2); + } + + /* Pass 2: process 2 rows from work array, store into output array. */ + + wsptr = workspace; + for (ctr = 0; ctr < 2; ctr++) { + outptr = output_buf[ctr] + output_col; + /* It's not clear whether a zero row test is worthwhile here ... */ + +#ifndef NO_ZERO_ROW_TEST + if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) { + /* AC terms all zero */ + JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) + & RANGE_MASK]; + + outptr[0] = dcval; + outptr[1] = dcval; + + wsptr += DCTSIZE; /* advance pointer to next row */ + continue; + } +#endif + + /* Even part */ + + tmp10 = ((INT32) wsptr[0]) << (CONST_BITS+2); + + /* Odd part */ + + tmp0 = MULTIPLY((INT32) wsptr[7], - FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */ + + MULTIPLY((INT32) wsptr[5], FIX_0_850430095) /* sqrt(2) * (-c1+c3+c5+c7) */ + + MULTIPLY((INT32) wsptr[3], - FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */ + + MULTIPLY((INT32) wsptr[1], FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */ + + /* Final output stage */ + + outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp0, + CONST_BITS+PASS1_BITS+3+2) + & RANGE_MASK]; + outptr[1] = range_limit[(int) DESCALE(tmp10 - tmp0, + CONST_BITS+PASS1_BITS+3+2) + & RANGE_MASK]; + + wsptr += DCTSIZE; /* advance pointer to next row */ + } +} + + +/* + * Perform dequantization and inverse DCT on one block of coefficients, + * producing a reduced-size 1x1 output block. + */ + +GLOBAL(void) +jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col) +{ + int dcval; + ISLOW_MULT_TYPE * quantptr; + JSAMPLE *range_limit = IDCT_range_limit(cinfo); + SHIFT_TEMPS + + /* We hardly need an inverse DCT routine for this: just take the + * average pixel value, which is one-eighth of the DC coefficient. + */ + quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; + dcval = DEQUANTIZE(coef_block[0], quantptr[0]); + dcval = (int) DESCALE((INT32) dcval, 3); + + output_buf[0][output_col] = range_limit[dcval & RANGE_MASK]; +} + +#endif /* IDCT_SCALING_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jinclude.h b/TMessagesProj/jni/libjpeg/jinclude.h new file mode 100755 index 000000000..0a4f15146 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jinclude.h @@ -0,0 +1,91 @@ +/* + * jinclude.h + * + * Copyright (C) 1991-1994, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file exists to provide a single place to fix any problems with + * including the wrong system include files. (Common problems are taken + * care of by the standard jconfig symbols, but on really weird systems + * you may have to edit this file.) + * + * NOTE: this file is NOT intended to be included by applications using the + * JPEG library. Most applications need only include jpeglib.h. + */ + + +/* Include auto-config file to find out which system include files we need. */ + +#include "jconfig.h" /* auto configuration options */ +#define JCONFIG_INCLUDED /* so that jpeglib.h doesn't do it again */ + +/* + * We need the NULL macro and size_t typedef. + * On an ANSI-conforming system it is sufficient to include . + * Otherwise, we get them from or ; we may have to + * pull in as well. + * Note that the core JPEG library does not require ; + * only the default error handler and data source/destination modules do. + * But we must pull it in because of the references to FILE in jpeglib.h. + * You can remove those references if you want to compile without . + */ + +#ifdef HAVE_STDDEF_H +#include +#endif + +#ifdef HAVE_STDLIB_H +#include +#endif + +#ifdef NEED_SYS_TYPES_H +#include +#endif + +#include + +/* + * We need memory copying and zeroing functions, plus strncpy(). + * ANSI and System V implementations declare these in . + * BSD doesn't have the mem() functions, but it does have bcopy()/bzero(). + * Some systems may declare memset and memcpy in . + * + * NOTE: we assume the size parameters to these functions are of type size_t. + * Change the casts in these macros if not! + */ + +#ifdef NEED_BSD_STRINGS + +#include +#define MEMZERO(target,size) bzero((void *)(target), (size_t)(size)) +#define MEMCOPY(dest,src,size) bcopy((const void *)(src), (void *)(dest), (size_t)(size)) + +#else /* not BSD, assume ANSI/SysV string lib */ + +#include +#define MEMZERO(target,size) memset((void *)(target), 0, (size_t)(size)) +#define MEMCOPY(dest,src,size) memcpy((void *)(dest), (const void *)(src), (size_t)(size)) + +#endif + +/* + * In ANSI C, and indeed any rational implementation, size_t is also the + * type returned by sizeof(). However, it seems there are some irrational + * implementations out there, in which sizeof() returns an int even though + * size_t is defined as long or unsigned long. To ensure consistent results + * we always use this SIZEOF() macro in place of using sizeof() directly. + */ + +#define SIZEOF(object) ((size_t) sizeof(object)) + +/* + * The modules that use fread() and fwrite() always invoke them through + * these macros. On some systems you may need to twiddle the argument casts. + * CAUTION: argument order is different from underlying functions! + */ + +#define JFREAD(file,buf,sizeofbuf) \ + ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file))) +#define JFWRITE(file,buf,sizeofbuf) \ + ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file))) diff --git a/TMessagesProj/jni/libjpeg/jmemmgr.c b/TMessagesProj/jni/libjpeg/jmemmgr.c new file mode 100755 index 000000000..d801b322d --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jmemmgr.c @@ -0,0 +1,1118 @@ +/* + * jmemmgr.c + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains the JPEG system-independent memory management + * routines. This code is usable across a wide variety of machines; most + * of the system dependencies have been isolated in a separate file. + * The major functions provided here are: + * * pool-based allocation and freeing of memory; + * * policy decisions about how to divide available memory among the + * virtual arrays; + * * control logic for swapping virtual arrays between main memory and + * backing storage. + * The separate system-dependent file provides the actual backing-storage + * access code, and it contains the policy decision about how much total + * main memory to use. + * This file is system-dependent in the sense that some of its functions + * are unnecessary in some systems. For example, if there is enough virtual + * memory so that backing storage will never be used, much of the virtual + * array control logic could be removed. (Of course, if you have that much + * memory then you shouldn't care about a little bit of unused code...) + */ + +#define JPEG_INTERNALS +#define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */ +#include "jinclude.h" +#include "jpeglib.h" +#include "jmemsys.h" /* import the system-dependent declarations */ + +#ifndef NO_GETENV +#ifndef HAVE_STDLIB_H /* should declare getenv() */ +extern char * getenv JPP((const char * name)); +#endif +#endif + + +/* + * Some important notes: + * The allocation routines provided here must never return NULL. + * They should exit to error_exit if unsuccessful. + * + * It's not a good idea to try to merge the sarray and barray routines, + * even though they are textually almost the same, because samples are + * usually stored as bytes while coefficients are shorts or ints. Thus, + * in machines where byte pointers have a different representation from + * word pointers, the resulting machine code could not be the same. + */ + + +/* + * Many machines require storage alignment: longs must start on 4-byte + * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc() + * always returns pointers that are multiples of the worst-case alignment + * requirement, and we had better do so too. + * There isn't any really portable way to determine the worst-case alignment + * requirement. This module assumes that the alignment requirement is + * multiples of sizeof(ALIGN_TYPE). + * By default, we define ALIGN_TYPE as double. This is necessary on some + * workstations (where doubles really do need 8-byte alignment) and will work + * fine on nearly everything. If your machine has lesser alignment needs, + * you can save a few bytes by making ALIGN_TYPE smaller. + * The only place I know of where this will NOT work is certain Macintosh + * 680x0 compilers that define double as a 10-byte IEEE extended float. + * Doing 10-byte alignment is counterproductive because longwords won't be + * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have + * such a compiler. + */ + +#ifndef ALIGN_TYPE /* so can override from jconfig.h */ +#define ALIGN_TYPE double +#endif + + +/* + * We allocate objects from "pools", where each pool is gotten with a single + * request to jpeg_get_small() or jpeg_get_large(). There is no per-object + * overhead within a pool, except for alignment padding. Each pool has a + * header with a link to the next pool of the same class. + * Small and large pool headers are identical except that the latter's + * link pointer must be FAR on 80x86 machines. + * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE + * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple + * of the alignment requirement of ALIGN_TYPE. + */ + +typedef union small_pool_struct * small_pool_ptr; + +typedef union small_pool_struct { + struct { + small_pool_ptr next; /* next in list of pools */ + size_t bytes_used; /* how many bytes already used within pool */ + size_t bytes_left; /* bytes still available in this pool */ + } hdr; + ALIGN_TYPE dummy; /* included in union to ensure alignment */ +} small_pool_hdr; + +typedef union large_pool_struct FAR * large_pool_ptr; + +typedef union large_pool_struct { + struct { + large_pool_ptr next; /* next in list of pools */ + size_t bytes_used; /* how many bytes already used within pool */ + size_t bytes_left; /* bytes still available in this pool */ + } hdr; + ALIGN_TYPE dummy; /* included in union to ensure alignment */ +} large_pool_hdr; + + +/* + * Here is the full definition of a memory manager object. + */ + +typedef struct { + struct jpeg_memory_mgr pub; /* public fields */ + + /* Each pool identifier (lifetime class) names a linked list of pools. */ + small_pool_ptr small_list[JPOOL_NUMPOOLS]; + large_pool_ptr large_list[JPOOL_NUMPOOLS]; + + /* Since we only have one lifetime class of virtual arrays, only one + * linked list is necessary (for each datatype). Note that the virtual + * array control blocks being linked together are actually stored somewhere + * in the small-pool list. + */ + jvirt_sarray_ptr virt_sarray_list; + jvirt_barray_ptr virt_barray_list; + + /* This counts total space obtained from jpeg_get_small/large */ + long total_space_allocated; + + /* alloc_sarray and alloc_barray set this value for use by virtual + * array routines. + */ + JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */ +} my_memory_mgr; + +typedef my_memory_mgr * my_mem_ptr; + + +/* + * The control blocks for virtual arrays. + * Note that these blocks are allocated in the "small" pool area. + * System-dependent info for the associated backing store (if any) is hidden + * inside the backing_store_info struct. + */ + +struct jvirt_sarray_control { + JSAMPARRAY mem_buffer; /* => the in-memory buffer */ + JDIMENSION rows_in_array; /* total virtual array height */ + JDIMENSION samplesperrow; /* width of array (and of memory buffer) */ + JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */ + JDIMENSION rows_in_mem; /* height of memory buffer */ + JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ + JDIMENSION cur_start_row; /* first logical row # in the buffer */ + JDIMENSION first_undef_row; /* row # of first uninitialized row */ + boolean pre_zero; /* pre-zero mode requested? */ + boolean dirty; /* do current buffer contents need written? */ + boolean b_s_open; /* is backing-store data valid? */ + jvirt_sarray_ptr next; /* link to next virtual sarray control block */ + backing_store_info b_s_info; /* System-dependent control info */ +}; + +struct jvirt_barray_control { + JBLOCKARRAY mem_buffer; /* => the in-memory buffer */ + JDIMENSION rows_in_array; /* total virtual array height */ + JDIMENSION blocksperrow; /* width of array (and of memory buffer) */ + JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */ + JDIMENSION rows_in_mem; /* height of memory buffer */ + JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ + JDIMENSION cur_start_row; /* first logical row # in the buffer */ + JDIMENSION first_undef_row; /* row # of first uninitialized row */ + boolean pre_zero; /* pre-zero mode requested? */ + boolean dirty; /* do current buffer contents need written? */ + boolean b_s_open; /* is backing-store data valid? */ + jvirt_barray_ptr next; /* link to next virtual barray control block */ + backing_store_info b_s_info; /* System-dependent control info */ +}; + + +#ifdef MEM_STATS /* optional extra stuff for statistics */ + +LOCAL(void) +print_mem_stats (j_common_ptr cinfo, int pool_id) +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + small_pool_ptr shdr_ptr; + large_pool_ptr lhdr_ptr; + + /* Since this is only a debugging stub, we can cheat a little by using + * fprintf directly rather than going through the trace message code. + * This is helpful because message parm array can't handle longs. + */ + fprintf(stderr, "Freeing pool %d, total space = %ld\n", + pool_id, mem->total_space_allocated); + + for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL; + lhdr_ptr = lhdr_ptr->hdr.next) { + fprintf(stderr, " Large chunk used %ld\n", + (long) lhdr_ptr->hdr.bytes_used); + } + + for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL; + shdr_ptr = shdr_ptr->hdr.next) { + fprintf(stderr, " Small chunk used %ld free %ld\n", + (long) shdr_ptr->hdr.bytes_used, + (long) shdr_ptr->hdr.bytes_left); + } +} + +#endif /* MEM_STATS */ + + +LOCAL(void) +out_of_memory (j_common_ptr cinfo, int which) +/* Report an out-of-memory error and stop execution */ +/* If we compiled MEM_STATS support, report alloc requests before dying */ +{ +#ifdef MEM_STATS + cinfo->err->trace_level = 2; /* force self_destruct to report stats */ +#endif + ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which); +} + + +/* + * Allocation of "small" objects. + * + * For these, we use pooled storage. When a new pool must be created, + * we try to get enough space for the current request plus a "slop" factor, + * where the slop will be the amount of leftover space in the new pool. + * The speed vs. space tradeoff is largely determined by the slop values. + * A different slop value is provided for each pool class (lifetime), + * and we also distinguish the first pool of a class from later ones. + * NOTE: the values given work fairly well on both 16- and 32-bit-int + * machines, but may be too small if longs are 64 bits or more. + */ + +static const size_t first_pool_slop[JPOOL_NUMPOOLS] = +{ + 1600, /* first PERMANENT pool */ + 16000 /* first IMAGE pool */ +}; + +static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = +{ + 0, /* additional PERMANENT pools */ + 5000 /* additional IMAGE pools */ +}; + +#define MIN_SLOP 50 /* greater than 0 to avoid futile looping */ + + +METHODDEF(void *) +alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject) +/* Allocate a "small" object */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + small_pool_ptr hdr_ptr, prev_hdr_ptr; + char * data_ptr; + size_t odd_bytes, min_request, slop; + + /* Check for unsatisfiable request (do now to ensure no overflow below) */ + if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr))) + out_of_memory(cinfo, 1); /* request exceeds malloc's ability */ + + /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ + odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); + if (odd_bytes > 0) + sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; + + /* See if space is available in any existing pool */ + if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) + ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ + prev_hdr_ptr = NULL; + hdr_ptr = mem->small_list[pool_id]; + while (hdr_ptr != NULL) { + if (hdr_ptr->hdr.bytes_left >= sizeofobject) + break; /* found pool with enough space */ + prev_hdr_ptr = hdr_ptr; + hdr_ptr = hdr_ptr->hdr.next; + } + + /* Time to make a new pool? */ + if (hdr_ptr == NULL) { + /* min_request is what we need now, slop is what will be leftover */ + min_request = sizeofobject + SIZEOF(small_pool_hdr); + if (prev_hdr_ptr == NULL) /* first pool in class? */ + slop = first_pool_slop[pool_id]; + else + slop = extra_pool_slop[pool_id]; + /* Don't ask for more than MAX_ALLOC_CHUNK */ + if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request)) + slop = (size_t) (MAX_ALLOC_CHUNK-min_request); + /* Try to get space, if fail reduce slop and try again */ + for (;;) { + hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop); + if (hdr_ptr != NULL) + break; + slop /= 2; + if (slop < MIN_SLOP) /* give up when it gets real small */ + out_of_memory(cinfo, 2); /* jpeg_get_small failed */ + } + mem->total_space_allocated += min_request + slop; + /* Success, initialize the new pool header and add to end of list */ + hdr_ptr->hdr.next = NULL; + hdr_ptr->hdr.bytes_used = 0; + hdr_ptr->hdr.bytes_left = sizeofobject + slop; + if (prev_hdr_ptr == NULL) /* first pool in class? */ + mem->small_list[pool_id] = hdr_ptr; + else + prev_hdr_ptr->hdr.next = hdr_ptr; + } + + /* OK, allocate the object from the current pool */ + data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */ + data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */ + hdr_ptr->hdr.bytes_used += sizeofobject; + hdr_ptr->hdr.bytes_left -= sizeofobject; + + return (void *) data_ptr; +} + + +/* + * Allocation of "large" objects. + * + * The external semantics of these are the same as "small" objects, + * except that FAR pointers are used on 80x86. However the pool + * management heuristics are quite different. We assume that each + * request is large enough that it may as well be passed directly to + * jpeg_get_large; the pool management just links everything together + * so that we can free it all on demand. + * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY + * structures. The routines that create these structures (see below) + * deliberately bunch rows together to ensure a large request size. + */ + +METHODDEF(void FAR *) +alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) +/* Allocate a "large" object */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + large_pool_ptr hdr_ptr; + size_t odd_bytes; + + /* Check for unsatisfiable request (do now to ensure no overflow below) */ + if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) + out_of_memory(cinfo, 3); /* request exceeds malloc's ability */ + + /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ + odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); + if (odd_bytes > 0) + sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; + + /* Always make a new pool */ + if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) + ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ + + hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject + + SIZEOF(large_pool_hdr)); + if (hdr_ptr == NULL) + out_of_memory(cinfo, 4); /* jpeg_get_large failed */ + mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr); + + /* Success, initialize the new pool header and add to list */ + hdr_ptr->hdr.next = mem->large_list[pool_id]; + /* We maintain space counts in each pool header for statistical purposes, + * even though they are not needed for allocation. + */ + hdr_ptr->hdr.bytes_used = sizeofobject; + hdr_ptr->hdr.bytes_left = 0; + mem->large_list[pool_id] = hdr_ptr; + + return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */ +} + + +/* + * Creation of 2-D sample arrays. + * The pointers are in near heap, the samples themselves in FAR heap. + * + * To minimize allocation overhead and to allow I/O of large contiguous + * blocks, we allocate the sample rows in groups of as many rows as possible + * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. + * NB: the virtual array control routines, later in this file, know about + * this chunking of rows. The rowsperchunk value is left in the mem manager + * object so that it can be saved away if this sarray is the workspace for + * a virtual array. + */ + +METHODDEF(JSAMPARRAY) +alloc_sarray (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, JDIMENSION numrows) +/* Allocate a 2-D sample array */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + JSAMPARRAY result; + JSAMPROW workspace; + JDIMENSION rowsperchunk, currow, i; + long ltemp; + + /* Calculate max # of rows allowed in one allocation chunk */ + ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / + ((long) samplesperrow * SIZEOF(JSAMPLE)); + if (ltemp <= 0) + ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); + if (ltemp < (long) numrows) + rowsperchunk = (JDIMENSION) ltemp; + else + rowsperchunk = numrows; + mem->last_rowsperchunk = rowsperchunk; + + /* Get space for row pointers (small object) */ + result = (JSAMPARRAY) alloc_small(cinfo, pool_id, + (size_t) (numrows * SIZEOF(JSAMPROW))); + + /* Get the rows themselves (large objects) */ + currow = 0; + while (currow < numrows) { + rowsperchunk = MIN(rowsperchunk, numrows - currow); + workspace = (JSAMPROW) alloc_large(cinfo, pool_id, + (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow + * SIZEOF(JSAMPLE))); + for (i = rowsperchunk; i > 0; i--) { + result[currow++] = workspace; + workspace += samplesperrow; + } + } + + return result; +} + + +/* + * Creation of 2-D coefficient-block arrays. + * This is essentially the same as the code for sample arrays, above. + */ + +METHODDEF(JBLOCKARRAY) +alloc_barray (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, JDIMENSION numrows) +/* Allocate a 2-D coefficient-block array */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + JBLOCKARRAY result; + JBLOCKROW workspace; + JDIMENSION rowsperchunk, currow, i; + long ltemp; + + /* Calculate max # of rows allowed in one allocation chunk */ + ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / + ((long) blocksperrow * SIZEOF(JBLOCK)); + if (ltemp <= 0) + ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); + if (ltemp < (long) numrows) + rowsperchunk = (JDIMENSION) ltemp; + else + rowsperchunk = numrows; + mem->last_rowsperchunk = rowsperchunk; + + /* Get space for row pointers (small object) */ + result = (JBLOCKARRAY) alloc_small(cinfo, pool_id, + (size_t) (numrows * SIZEOF(JBLOCKROW))); + + /* Get the rows themselves (large objects) */ + currow = 0; + while (currow < numrows) { + rowsperchunk = MIN(rowsperchunk, numrows - currow); + workspace = (JBLOCKROW) alloc_large(cinfo, pool_id, + (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow + * SIZEOF(JBLOCK))); + for (i = rowsperchunk; i > 0; i--) { + result[currow++] = workspace; + workspace += blocksperrow; + } + } + + return result; +} + + +/* + * About virtual array management: + * + * The above "normal" array routines are only used to allocate strip buffers + * (as wide as the image, but just a few rows high). Full-image-sized buffers + * are handled as "virtual" arrays. The array is still accessed a strip at a + * time, but the memory manager must save the whole array for repeated + * accesses. The intended implementation is that there is a strip buffer in + * memory (as high as is possible given the desired memory limit), plus a + * backing file that holds the rest of the array. + * + * The request_virt_array routines are told the total size of the image and + * the maximum number of rows that will be accessed at once. The in-memory + * buffer must be at least as large as the maxaccess value. + * + * The request routines create control blocks but not the in-memory buffers. + * That is postponed until realize_virt_arrays is called. At that time the + * total amount of space needed is known (approximately, anyway), so free + * memory can be divided up fairly. + * + * The access_virt_array routines are responsible for making a specific strip + * area accessible (after reading or writing the backing file, if necessary). + * Note that the access routines are told whether the caller intends to modify + * the accessed strip; during a read-only pass this saves having to rewrite + * data to disk. The access routines are also responsible for pre-zeroing + * any newly accessed rows, if pre-zeroing was requested. + * + * In current usage, the access requests are usually for nonoverlapping + * strips; that is, successive access start_row numbers differ by exactly + * num_rows = maxaccess. This means we can get good performance with simple + * buffer dump/reload logic, by making the in-memory buffer be a multiple + * of the access height; then there will never be accesses across bufferload + * boundaries. The code will still work with overlapping access requests, + * but it doesn't handle bufferload overlaps very efficiently. + */ + + +METHODDEF(jvirt_sarray_ptr) +request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, + JDIMENSION samplesperrow, JDIMENSION numrows, + JDIMENSION maxaccess) +/* Request a virtual 2-D sample array */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + jvirt_sarray_ptr result; + + /* Only IMAGE-lifetime virtual arrays are currently supported */ + if (pool_id != JPOOL_IMAGE) + ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ + + /* get control block */ + result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id, + SIZEOF(struct jvirt_sarray_control)); + + result->mem_buffer = NULL; /* marks array not yet realized */ + result->rows_in_array = numrows; + result->samplesperrow = samplesperrow; + result->maxaccess = maxaccess; + result->pre_zero = pre_zero; + result->b_s_open = FALSE; /* no associated backing-store object */ + result->next = mem->virt_sarray_list; /* add to list of virtual arrays */ + mem->virt_sarray_list = result; + + return result; +} + + +METHODDEF(jvirt_barray_ptr) +request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, + JDIMENSION blocksperrow, JDIMENSION numrows, + JDIMENSION maxaccess) +/* Request a virtual 2-D coefficient-block array */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + jvirt_barray_ptr result; + + /* Only IMAGE-lifetime virtual arrays are currently supported */ + if (pool_id != JPOOL_IMAGE) + ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ + + /* get control block */ + result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id, + SIZEOF(struct jvirt_barray_control)); + + result->mem_buffer = NULL; /* marks array not yet realized */ + result->rows_in_array = numrows; + result->blocksperrow = blocksperrow; + result->maxaccess = maxaccess; + result->pre_zero = pre_zero; + result->b_s_open = FALSE; /* no associated backing-store object */ + result->next = mem->virt_barray_list; /* add to list of virtual arrays */ + mem->virt_barray_list = result; + + return result; +} + + +METHODDEF(void) +realize_virt_arrays (j_common_ptr cinfo) +/* Allocate the in-memory buffers for any unrealized virtual arrays */ +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + long space_per_minheight, maximum_space, avail_mem; + long minheights, max_minheights; + jvirt_sarray_ptr sptr; + jvirt_barray_ptr bptr; + + /* Compute the minimum space needed (maxaccess rows in each buffer) + * and the maximum space needed (full image height in each buffer). + * These may be of use to the system-dependent jpeg_mem_available routine. + */ + space_per_minheight = 0; + maximum_space = 0; + for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { + if (sptr->mem_buffer == NULL) { /* if not realized yet */ + space_per_minheight += (long) sptr->maxaccess * + (long) sptr->samplesperrow * SIZEOF(JSAMPLE); + maximum_space += (long) sptr->rows_in_array * + (long) sptr->samplesperrow * SIZEOF(JSAMPLE); + } + } + for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { + if (bptr->mem_buffer == NULL) { /* if not realized yet */ + space_per_minheight += (long) bptr->maxaccess * + (long) bptr->blocksperrow * SIZEOF(JBLOCK); + maximum_space += (long) bptr->rows_in_array * + (long) bptr->blocksperrow * SIZEOF(JBLOCK); + } + } + + if (space_per_minheight <= 0) + return; /* no unrealized arrays, no work */ + + /* Determine amount of memory to actually use; this is system-dependent. */ + avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space, + mem->total_space_allocated); + + /* If the maximum space needed is available, make all the buffers full + * height; otherwise parcel it out with the same number of minheights + * in each buffer. + */ + if (avail_mem >= maximum_space) + max_minheights = 1000000000L; + else { + max_minheights = avail_mem / space_per_minheight; + /* If there doesn't seem to be enough space, try to get the minimum + * anyway. This allows a "stub" implementation of jpeg_mem_available(). + */ + if (max_minheights <= 0) + max_minheights = 1; + } + + /* Allocate the in-memory buffers and initialize backing store as needed. */ + + for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { + if (sptr->mem_buffer == NULL) { /* if not realized yet */ + minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L; + if (minheights <= max_minheights) { + /* This buffer fits in memory */ + sptr->rows_in_mem = sptr->rows_in_array; + } else { + /* It doesn't fit in memory, create backing store. */ + sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess); + jpeg_open_backing_store(cinfo, & sptr->b_s_info, + (long) sptr->rows_in_array * + (long) sptr->samplesperrow * + (long) SIZEOF(JSAMPLE)); + sptr->b_s_open = TRUE; + } + sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE, + sptr->samplesperrow, sptr->rows_in_mem); + sptr->rowsperchunk = mem->last_rowsperchunk; + sptr->cur_start_row = 0; + sptr->first_undef_row = 0; + sptr->dirty = FALSE; + } + } + + for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { + if (bptr->mem_buffer == NULL) { /* if not realized yet */ + minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L; + if (minheights <= max_minheights) { + /* This buffer fits in memory */ + bptr->rows_in_mem = bptr->rows_in_array; + } else { + /* It doesn't fit in memory, create backing store. */ + bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess); + jpeg_open_backing_store(cinfo, & bptr->b_s_info, + (long) bptr->rows_in_array * + (long) bptr->blocksperrow * + (long) SIZEOF(JBLOCK)); + bptr->b_s_open = TRUE; + } + bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE, + bptr->blocksperrow, bptr->rows_in_mem); + bptr->rowsperchunk = mem->last_rowsperchunk; + bptr->cur_start_row = 0; + bptr->first_undef_row = 0; + bptr->dirty = FALSE; + } + } +} + + +LOCAL(void) +do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing) +/* Do backing store read or write of a virtual sample array */ +{ + long bytesperrow, file_offset, byte_count, rows, thisrow, i; + + bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE); + file_offset = ptr->cur_start_row * bytesperrow; + /* Loop to read or write each allocation chunk in mem_buffer */ + for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { + /* One chunk, but check for short chunk at end of buffer */ + rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); + /* Transfer no more than is currently defined */ + thisrow = (long) ptr->cur_start_row + i; + rows = MIN(rows, (long) ptr->first_undef_row - thisrow); + /* Transfer no more than fits in file */ + rows = MIN(rows, (long) ptr->rows_in_array - thisrow); + if (rows <= 0) /* this chunk might be past end of file! */ + break; + byte_count = rows * bytesperrow; + if (writing) + (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, + (void FAR *) ptr->mem_buffer[i], + file_offset, byte_count); + else + (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, + (void FAR *) ptr->mem_buffer[i], + file_offset, byte_count); + file_offset += byte_count; + } +} + + +LOCAL(void) +do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing) +/* Do backing store read or write of a virtual coefficient-block array */ +{ + long bytesperrow, file_offset, byte_count, rows, thisrow, i; + + bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK); + file_offset = ptr->cur_start_row * bytesperrow; + /* Loop to read or write each allocation chunk in mem_buffer */ + for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { + /* One chunk, but check for short chunk at end of buffer */ + rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); + /* Transfer no more than is currently defined */ + thisrow = (long) ptr->cur_start_row + i; + rows = MIN(rows, (long) ptr->first_undef_row - thisrow); + /* Transfer no more than fits in file */ + rows = MIN(rows, (long) ptr->rows_in_array - thisrow); + if (rows <= 0) /* this chunk might be past end of file! */ + break; + byte_count = rows * bytesperrow; + if (writing) + (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, + (void FAR *) ptr->mem_buffer[i], + file_offset, byte_count); + else + (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, + (void FAR *) ptr->mem_buffer[i], + file_offset, byte_count); + file_offset += byte_count; + } +} + + +METHODDEF(JSAMPARRAY) +access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, + JDIMENSION start_row, JDIMENSION num_rows, + boolean writable) +/* Access the part of a virtual sample array starting at start_row */ +/* and extending for num_rows rows. writable is true if */ +/* caller intends to modify the accessed area. */ +{ + JDIMENSION end_row = start_row + num_rows; + JDIMENSION undef_row; + + /* debugging check */ + if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || + ptr->mem_buffer == NULL) + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + + /* Make the desired part of the virtual array accessible */ + if (start_row < ptr->cur_start_row || + end_row > ptr->cur_start_row+ptr->rows_in_mem) { + if (! ptr->b_s_open) + ERREXIT(cinfo, JERR_VIRTUAL_BUG); + /* Flush old buffer contents if necessary */ + if (ptr->dirty) { + do_sarray_io(cinfo, ptr, TRUE); + ptr->dirty = FALSE; + } + /* Decide what part of virtual array to access. + * Algorithm: if target address > current window, assume forward scan, + * load starting at target address. If target address < current window, + * assume backward scan, load so that target area is top of window. + * Note that when switching from forward write to forward read, will have + * start_row = 0, so the limiting case applies and we load from 0 anyway. + */ + if (start_row > ptr->cur_start_row) { + ptr->cur_start_row = start_row; + } else { + /* use long arithmetic here to avoid overflow & unsigned problems */ + long ltemp; + + ltemp = (long) end_row - (long) ptr->rows_in_mem; + if (ltemp < 0) + ltemp = 0; /* don't fall off front end of file */ + ptr->cur_start_row = (JDIMENSION) ltemp; + } + /* Read in the selected part of the array. + * During the initial write pass, we will do no actual read + * because the selected part is all undefined. + */ + do_sarray_io(cinfo, ptr, FALSE); + } + /* Ensure the accessed part of the array is defined; prezero if needed. + * To improve locality of access, we only prezero the part of the array + * that the caller is about to access, not the entire in-memory array. + */ + if (ptr->first_undef_row < end_row) { + if (ptr->first_undef_row < start_row) { + if (writable) /* writer skipped over a section of array */ + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + undef_row = start_row; /* but reader is allowed to read ahead */ + } else { + undef_row = ptr->first_undef_row; + } + if (writable) + ptr->first_undef_row = end_row; + if (ptr->pre_zero) { + size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE); + undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ + end_row -= ptr->cur_start_row; + while (undef_row < end_row) { + jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); + undef_row++; + } + } else { + if (! writable) /* reader looking at undefined data */ + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + } + } + /* Flag the buffer dirty if caller will write in it */ + if (writable) + ptr->dirty = TRUE; + /* Return address of proper part of the buffer */ + return ptr->mem_buffer + (start_row - ptr->cur_start_row); +} + + +METHODDEF(JBLOCKARRAY) +access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, + JDIMENSION start_row, JDIMENSION num_rows, + boolean writable) +/* Access the part of a virtual block array starting at start_row */ +/* and extending for num_rows rows. writable is true if */ +/* caller intends to modify the accessed area. */ +{ + JDIMENSION end_row = start_row + num_rows; + JDIMENSION undef_row; + + /* debugging check */ + if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || + ptr->mem_buffer == NULL) + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + + /* Make the desired part of the virtual array accessible */ + if (start_row < ptr->cur_start_row || + end_row > ptr->cur_start_row+ptr->rows_in_mem) { + if (! ptr->b_s_open) + ERREXIT(cinfo, JERR_VIRTUAL_BUG); + /* Flush old buffer contents if necessary */ + if (ptr->dirty) { + do_barray_io(cinfo, ptr, TRUE); + ptr->dirty = FALSE; + } + /* Decide what part of virtual array to access. + * Algorithm: if target address > current window, assume forward scan, + * load starting at target address. If target address < current window, + * assume backward scan, load so that target area is top of window. + * Note that when switching from forward write to forward read, will have + * start_row = 0, so the limiting case applies and we load from 0 anyway. + */ + if (start_row > ptr->cur_start_row) { + ptr->cur_start_row = start_row; + } else { + /* use long arithmetic here to avoid overflow & unsigned problems */ + long ltemp; + + ltemp = (long) end_row - (long) ptr->rows_in_mem; + if (ltemp < 0) + ltemp = 0; /* don't fall off front end of file */ + ptr->cur_start_row = (JDIMENSION) ltemp; + } + /* Read in the selected part of the array. + * During the initial write pass, we will do no actual read + * because the selected part is all undefined. + */ + do_barray_io(cinfo, ptr, FALSE); + } + /* Ensure the accessed part of the array is defined; prezero if needed. + * To improve locality of access, we only prezero the part of the array + * that the caller is about to access, not the entire in-memory array. + */ + if (ptr->first_undef_row < end_row) { + if (ptr->first_undef_row < start_row) { + if (writable) /* writer skipped over a section of array */ + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + undef_row = start_row; /* but reader is allowed to read ahead */ + } else { + undef_row = ptr->first_undef_row; + } + if (writable) + ptr->first_undef_row = end_row; + if (ptr->pre_zero) { + size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK); + undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ + end_row -= ptr->cur_start_row; + while (undef_row < end_row) { + jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); + undef_row++; + } + } else { + if (! writable) /* reader looking at undefined data */ + ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); + } + } + /* Flag the buffer dirty if caller will write in it */ + if (writable) + ptr->dirty = TRUE; + /* Return address of proper part of the buffer */ + return ptr->mem_buffer + (start_row - ptr->cur_start_row); +} + + +/* + * Release all objects belonging to a specified pool. + */ + +METHODDEF(void) +free_pool (j_common_ptr cinfo, int pool_id) +{ + my_mem_ptr mem = (my_mem_ptr) cinfo->mem; + small_pool_ptr shdr_ptr; + large_pool_ptr lhdr_ptr; + size_t space_freed; + + if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) + ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ + +#ifdef MEM_STATS + if (cinfo->err->trace_level > 1) + print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */ +#endif + + /* If freeing IMAGE pool, close any virtual arrays first */ + if (pool_id == JPOOL_IMAGE) { + jvirt_sarray_ptr sptr; + jvirt_barray_ptr bptr; + + for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { + if (sptr->b_s_open) { /* there may be no backing store */ + sptr->b_s_open = FALSE; /* prevent recursive close if error */ + (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info); + } + } + mem->virt_sarray_list = NULL; + for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { + if (bptr->b_s_open) { /* there may be no backing store */ + bptr->b_s_open = FALSE; /* prevent recursive close if error */ + (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info); + } + } + mem->virt_barray_list = NULL; + } + + /* Release large objects */ + lhdr_ptr = mem->large_list[pool_id]; + mem->large_list[pool_id] = NULL; + + while (lhdr_ptr != NULL) { + large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next; + space_freed = lhdr_ptr->hdr.bytes_used + + lhdr_ptr->hdr.bytes_left + + SIZEOF(large_pool_hdr); + jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed); + mem->total_space_allocated -= space_freed; + lhdr_ptr = next_lhdr_ptr; + } + + /* Release small objects */ + shdr_ptr = mem->small_list[pool_id]; + mem->small_list[pool_id] = NULL; + + while (shdr_ptr != NULL) { + small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next; + space_freed = shdr_ptr->hdr.bytes_used + + shdr_ptr->hdr.bytes_left + + SIZEOF(small_pool_hdr); + jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed); + mem->total_space_allocated -= space_freed; + shdr_ptr = next_shdr_ptr; + } +} + + +/* + * Close up shop entirely. + * Note that this cannot be called unless cinfo->mem is non-NULL. + */ + +METHODDEF(void) +self_destruct (j_common_ptr cinfo) +{ + int pool; + + /* Close all backing store, release all memory. + * Releasing pools in reverse order might help avoid fragmentation + * with some (brain-damaged) malloc libraries. + */ + for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { + free_pool(cinfo, pool); + } + + /* Release the memory manager control block too. */ + jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr)); + cinfo->mem = NULL; /* ensures I will be called only once */ + + jpeg_mem_term(cinfo); /* system-dependent cleanup */ +} + + +/* + * Memory manager initialization. + * When this is called, only the error manager pointer is valid in cinfo! + */ + +GLOBAL(void) +jinit_memory_mgr (j_common_ptr cinfo) +{ + my_mem_ptr mem; + long max_to_use; + int pool; + size_t test_mac; + + cinfo->mem = NULL; /* for safety if init fails */ + + /* Check for configuration errors. + * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably + * doesn't reflect any real hardware alignment requirement. + * The test is a little tricky: for X>0, X and X-1 have no one-bits + * in common if and only if X is a power of 2, ie has only one one-bit. + * Some compilers may give an "unreachable code" warning here; ignore it. + */ + if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0) + ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE); + /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be + * a multiple of SIZEOF(ALIGN_TYPE). + * Again, an "unreachable code" warning may be ignored here. + * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK. + */ + test_mac = (size_t) MAX_ALLOC_CHUNK; + if ((long) test_mac != MAX_ALLOC_CHUNK || + (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0) + ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); + + max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */ + + /* Attempt to allocate memory manager's control block */ + mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr)); + + if (mem == NULL) { + jpeg_mem_term(cinfo); /* system-dependent cleanup */ + ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0); + } + + /* OK, fill in the method pointers */ + mem->pub.alloc_small = alloc_small; + mem->pub.alloc_large = alloc_large; + mem->pub.alloc_sarray = alloc_sarray; + mem->pub.alloc_barray = alloc_barray; + mem->pub.request_virt_sarray = request_virt_sarray; + mem->pub.request_virt_barray = request_virt_barray; + mem->pub.realize_virt_arrays = realize_virt_arrays; + mem->pub.access_virt_sarray = access_virt_sarray; + mem->pub.access_virt_barray = access_virt_barray; + mem->pub.free_pool = free_pool; + mem->pub.self_destruct = self_destruct; + + /* Make MAX_ALLOC_CHUNK accessible to other modules */ + mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK; + + /* Initialize working state */ + mem->pub.max_memory_to_use = max_to_use; + + for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { + mem->small_list[pool] = NULL; + mem->large_list[pool] = NULL; + } + mem->virt_sarray_list = NULL; + mem->virt_barray_list = NULL; + + mem->total_space_allocated = SIZEOF(my_memory_mgr); + + /* Declare ourselves open for business */ + cinfo->mem = & mem->pub; + + /* Check for an environment variable JPEGMEM; if found, override the + * default max_memory setting from jpeg_mem_init. Note that the + * surrounding application may again override this value. + * If your system doesn't support getenv(), define NO_GETENV to disable + * this feature. + */ +#ifndef NO_GETENV + { char * memenv; + + if ((memenv = getenv("JPEGMEM")) != NULL) { + char ch = 'x'; + + if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) { + if (ch == 'm' || ch == 'M') + max_to_use *= 1000L; + mem->pub.max_memory_to_use = max_to_use * 1000L; + } + } + } +#endif + +} diff --git a/TMessagesProj/jni/libjpeg/jmemnobs.c b/TMessagesProj/jni/libjpeg/jmemnobs.c new file mode 100755 index 000000000..eb8c33772 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jmemnobs.c @@ -0,0 +1,109 @@ +/* + * jmemnobs.c + * + * Copyright (C) 1992-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file provides a really simple implementation of the system- + * dependent portion of the JPEG memory manager. This implementation + * assumes that no backing-store files are needed: all required space + * can be obtained from malloc(). + * This is very portable in the sense that it'll compile on almost anything, + * but you'd better have lots of main memory (or virtual memory) if you want + * to process big images. + * Note that the max_memory_to_use option is ignored by this implementation. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jmemsys.h" /* import the system-dependent declarations */ + +#ifndef HAVE_STDLIB_H /* should declare malloc(),free() */ +extern void * malloc JPP((size_t size)); +extern void free JPP((void *ptr)); +#endif + + +/* + * Memory allocation and freeing are controlled by the regular library + * routines malloc() and free(). + */ + +GLOBAL(void *) +jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) +{ + return (void *) malloc(sizeofobject); +} + +GLOBAL(void) +jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) +{ + free(object); +} + + +/* + * "Large" objects are treated the same as "small" ones. + * NB: although we include FAR keywords in the routine declarations, + * this file won't actually work in 80x86 small/medium model; at least, + * you probably won't be able to process useful-size images in only 64KB. + */ + +GLOBAL(void FAR *) +jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) +{ + return (void FAR *) malloc(sizeofobject); +} + +GLOBAL(void) +jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) +{ + free(object); +} + + +/* + * This routine computes the total memory space available for allocation. + * Here we always say, "we got all you want bud!" + */ + +GLOBAL(long) +jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, + long max_bytes_needed, long already_allocated) +{ + return max_bytes_needed; +} + + +/* + * Backing store (temporary file) management. + * Since jpeg_mem_available always promised the moon, + * this should never be called and we can just error out. + */ + +GLOBAL(void) +jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, + long total_bytes_needed) +{ + ERREXIT(cinfo, JERR_NO_BACKING_STORE); +} + + +/* + * These routines take care of any system-dependent initialization and + * cleanup required. Here, there isn't any. + */ + +GLOBAL(long) +jpeg_mem_init (j_common_ptr cinfo) +{ + return 0; /* just set max_memory_to_use to 0 */ +} + +GLOBAL(void) +jpeg_mem_term (j_common_ptr cinfo) +{ + /* no work */ +} diff --git a/TMessagesProj/jni/libjpeg/jmemsys.h b/TMessagesProj/jni/libjpeg/jmemsys.h new file mode 100755 index 000000000..2ed1c63a1 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jmemsys.h @@ -0,0 +1,204 @@ +/* + * jmemsys.h + * + * Copyright (C) 1992-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This include file defines the interface between the system-independent + * and system-dependent portions of the JPEG memory manager. No other + * modules need include it. (The system-independent portion is jmemmgr.c; + * there are several different versions of the system-dependent portion.) + * + * This file works as-is for the system-dependent memory managers supplied + * in the IJG distribution. You may need to modify it if you write a + * custom memory manager. If system-dependent changes are needed in + * this file, the best method is to #ifdef them based on a configuration + * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR + * and USE_MAC_MEMMGR. + */ + + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_get_small jGetSmall +#define jpeg_free_small jFreeSmall +#define jpeg_get_large jGetLarge +#define jpeg_free_large jFreeLarge +#define jpeg_mem_available jMemAvail +#define jpeg_open_backing_store jOpenBackStore +#define jpeg_mem_init jMemInit +#define jpeg_mem_term jMemTerm +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* + * These two functions are used to allocate and release small chunks of + * memory. (Typically the total amount requested through jpeg_get_small is + * no more than 20K or so; this will be requested in chunks of a few K each.) + * Behavior should be the same as for the standard library functions malloc + * and free; in particular, jpeg_get_small must return NULL on failure. + * On most systems, these ARE malloc and free. jpeg_free_small is passed the + * size of the object being freed, just in case it's needed. + * On an 80x86 machine using small-data memory model, these manage near heap. + */ + +EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject)); +EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object, + size_t sizeofobject)); + +/* + * These two functions are used to allocate and release large chunks of + * memory (up to the total free space designated by jpeg_mem_available). + * The interface is the same as above, except that on an 80x86 machine, + * far pointers are used. On most other machines these are identical to + * the jpeg_get/free_small routines; but we keep them separate anyway, + * in case a different allocation strategy is desirable for large chunks. + */ + +EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo, + size_t sizeofobject)); +EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object, + size_t sizeofobject)); + +/* + * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may + * be requested in a single call to jpeg_get_large (and jpeg_get_small for that + * matter, but that case should never come into play). This macro is needed + * to model the 64Kb-segment-size limit of far addressing on 80x86 machines. + * On those machines, we expect that jconfig.h will provide a proper value. + * On machines with 32-bit flat address spaces, any large constant may be used. + * + * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type + * size_t and will be a multiple of sizeof(align_type). + */ + +#ifndef MAX_ALLOC_CHUNK /* may be overridden in jconfig.h */ +#define MAX_ALLOC_CHUNK 1000000000L +#endif + +/* + * This routine computes the total space still available for allocation by + * jpeg_get_large. If more space than this is needed, backing store will be + * used. NOTE: any memory already allocated must not be counted. + * + * There is a minimum space requirement, corresponding to the minimum + * feasible buffer sizes; jmemmgr.c will request that much space even if + * jpeg_mem_available returns zero. The maximum space needed, enough to hold + * all working storage in memory, is also passed in case it is useful. + * Finally, the total space already allocated is passed. If no better + * method is available, cinfo->mem->max_memory_to_use - already_allocated + * is often a suitable calculation. + * + * It is OK for jpeg_mem_available to underestimate the space available + * (that'll just lead to more backing-store access than is really necessary). + * However, an overestimate will lead to failure. Hence it's wise to subtract + * a slop factor from the true available space. 5% should be enough. + * + * On machines with lots of virtual memory, any large constant may be returned. + * Conversely, zero may be returned to always use the minimum amount of memory. + */ + +EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo, + long min_bytes_needed, + long max_bytes_needed, + long already_allocated)); + + +/* + * This structure holds whatever state is needed to access a single + * backing-store object. The read/write/close method pointers are called + * by jmemmgr.c to manipulate the backing-store object; all other fields + * are private to the system-dependent backing store routines. + */ + +#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */ + + +#ifdef USE_MSDOS_MEMMGR /* DOS-specific junk */ + +typedef unsigned short XMSH; /* type of extended-memory handles */ +typedef unsigned short EMSH; /* type of expanded-memory handles */ + +typedef union { + short file_handle; /* DOS file handle if it's a temp file */ + XMSH xms_handle; /* handle if it's a chunk of XMS */ + EMSH ems_handle; /* handle if it's a chunk of EMS */ +} handle_union; + +#endif /* USE_MSDOS_MEMMGR */ + +#ifdef USE_MAC_MEMMGR /* Mac-specific junk */ +#include +#endif /* USE_MAC_MEMMGR */ + + +typedef struct backing_store_struct * backing_store_ptr; + +typedef struct backing_store_struct { + /* Methods for reading/writing/closing this backing-store object */ + JMETHOD(void, read_backing_store, (j_common_ptr cinfo, + backing_store_ptr info, + void FAR * buffer_address, + long file_offset, long byte_count)); + JMETHOD(void, write_backing_store, (j_common_ptr cinfo, + backing_store_ptr info, + void FAR * buffer_address, + long file_offset, long byte_count)); + JMETHOD(void, close_backing_store, (j_common_ptr cinfo, + backing_store_ptr info)); + + /* Private fields for system-dependent backing-store management */ +#ifdef USE_MSDOS_MEMMGR + /* For the MS-DOS manager (jmemdos.c), we need: */ + handle_union handle; /* reference to backing-store storage object */ + char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ +#else +#ifdef USE_MAC_MEMMGR + /* For the Mac manager (jmemmac.c), we need: */ + short temp_file; /* file reference number to temp file */ + FSSpec tempSpec; /* the FSSpec for the temp file */ + char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ +#else +#ifdef USE_ANDROID_ASHMEM + short temp_file; /* file reference number to temp file */ + unsigned char* addr; /* the memory address mapped to ashmem */ + long size; /* the requested ashmem size */ +#else + /* For a typical implementation with temp files, we need: */ + FILE * temp_file; /* stdio reference to temp file */ + char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */ +#endif +#endif +#endif +} backing_store_info; + + +/* + * Initial opening of a backing-store object. This must fill in the + * read/write/close pointers in the object. The read/write routines + * may take an error exit if the specified maximum file size is exceeded. + * (If jpeg_mem_available always returns a large value, this routine can + * just take an error exit.) + */ + +EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo, + backing_store_ptr info, + long total_bytes_needed)); + + +/* + * These routines take care of any system-dependent initialization and + * cleanup required. jpeg_mem_init will be called before anything is + * allocated (and, therefore, nothing in cinfo is of use except the error + * manager pointer). It should return a suitable default value for + * max_memory_to_use; this may subsequently be overridden by the surrounding + * application. (Note that max_memory_to_use is only important if + * jpeg_mem_available chooses to consult it ... no one else will.) + * jpeg_mem_term may assume that all requested memory has been freed and that + * all opened backing-store objects have been closed. + */ + +EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo)); +EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo)); diff --git a/TMessagesProj/jni/libjpeg/jmorecfg.h b/TMessagesProj/jni/libjpeg/jmorecfg.h new file mode 100755 index 000000000..66116dbf7 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jmorecfg.h @@ -0,0 +1,395 @@ +/* + * jmorecfg.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains additional configuration options that customize the + * JPEG software for special applications or support machine-dependent + * optimizations. Most users will not need to touch this file. + */ + +/* + * Define ANDROID_RGB to enable specific optimizations for Android + * JCS_RGBA_8888 support + * JCS_RGB_565 support + * + */ + +#define ANDROID_RGB + +#ifdef ANDROID_RGB +#define PACK_SHORT_565(r,g,b) ((((r)<<8)&0xf800)|(((g)<<3)&0x7E0)|((b)>>3)) +#define PACK_TWO_PIXELS(l,r) ((r<<16) | l) +#define PACK_NEED_ALIGNMENT(ptr) (((uintptr_t)(ptr))&3) +#define WRITE_TWO_PIXELS(addr, pixels) do { \ + ((INT16*)(addr))[0] = (pixels); \ + ((INT16*)(addr))[1] = (pixels)>>16; \ + } while(0) +#define WRITE_TWO_ALIGNED_PIXELS(addr, pixels) ((*(INT32*)(addr)) = pixels) +#define DITHER_565_R(r, dither) ((r) + ((dither)&0xFF)) +#define DITHER_565_G(g, dither) ((g) + (((dither)&0xFF)>>1)) +#define DITHER_565_B(b, dither) ((b) + ((dither)&0xFF)) +#endif + +/* + * Define BITS_IN_JSAMPLE as either + * 8 for 8-bit sample values (the usual setting) + * 12 for 12-bit sample values + * Only 8 and 12 are legal data precisions for lossy JPEG according to the + * JPEG standard, and the IJG code does not support anything else! + * We do not support run-time selection of data precision, sorry. + */ + +#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ + + +/* + * Maximum number of components (color channels) allowed in JPEG image. + * To meet the letter of the JPEG spec, set this to 255. However, darn + * few applications need more than 4 channels (maybe 5 for CMYK + alpha + * mask). We recommend 10 as a reasonable compromise; use 4 if you are + * really short on memory. (Each allowed component costs a hundred or so + * bytes of storage, whether actually used in an image or not.) + */ + +#define MAX_COMPONENTS 10 /* maximum number of image components */ + + +/* + * Basic data types. + * You may need to change these if you have a machine with unusual data + * type sizes; for example, "char" not 8 bits, "short" not 16 bits, + * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, + * but it had better be at least 16. + */ + +/* Representation of a single sample (pixel element value). + * We frequently allocate large arrays of these, so it's important to keep + * them small. But if you have memory to burn and access to char or short + * arrays is very slow on your hardware, you might want to change these. + */ + +#if BITS_IN_JSAMPLE == 8 +/* JSAMPLE should be the smallest type that will hold the values 0..255. + * You can use a signed char by having GETJSAMPLE mask it with 0xFF. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JSAMPLE; +#ifdef CHAR_IS_UNSIGNED +#define GETJSAMPLE(value) ((int) (value)) +#else +#define GETJSAMPLE(value) ((int) (value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + +#define MAXJSAMPLE 255 +#define CENTERJSAMPLE 128 + +#endif /* BITS_IN_JSAMPLE == 8 */ + + +#if BITS_IN_JSAMPLE == 12 +/* JSAMPLE should be the smallest type that will hold the values 0..4095. + * On nearly all machines "short" will do nicely. + */ + +typedef short JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#define MAXJSAMPLE 4095 +#define CENTERJSAMPLE 2048 + +#endif /* BITS_IN_JSAMPLE == 12 */ + + +/* Representation of a DCT frequency coefficient. + * This should be a signed value of at least 16 bits; "short" is usually OK. + * Again, we allocate large arrays of these, but you can change to int + * if you have memory to burn and "short" is really slow. + */ + +typedef short JCOEF; + + +/* Compressed datastreams are represented as arrays of JOCTET. + * These must be EXACTLY 8 bits wide, at least once they are written to + * external storage. Note that when using the stdio data source/destination + * managers, this is also the data type passed to fread/fwrite. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JOCTET; +#define GETJOCTET(value) (value) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JOCTET; +#ifdef CHAR_IS_UNSIGNED +#define GETJOCTET(value) (value) +#else +#define GETJOCTET(value) ((value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + + +/* These typedefs are used for various table entries and so forth. + * They must be at least as wide as specified; but making them too big + * won't cost a huge amount of memory, so we don't provide special + * extraction code like we did for JSAMPLE. (In other words, these + * typedefs live at a different point on the speed/space tradeoff curve.) + */ + +/* UINT8 must hold at least the values 0..255. */ + +#ifdef HAVE_UNSIGNED_CHAR +typedef unsigned char UINT8; +#else /* not HAVE_UNSIGNED_CHAR */ +#ifdef CHAR_IS_UNSIGNED +typedef char UINT8; +#else /* not CHAR_IS_UNSIGNED */ +typedef short UINT8; +#endif /* CHAR_IS_UNSIGNED */ +#endif /* HAVE_UNSIGNED_CHAR */ + +/* UINT16 must hold at least the values 0..65535. */ + +#ifdef HAVE_UNSIGNED_SHORT +typedef unsigned short UINT16; +#else /* not HAVE_UNSIGNED_SHORT */ +typedef unsigned int UINT16; +#endif /* HAVE_UNSIGNED_SHORT */ + +/* INT16 must hold at least the values -32768..32767. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ +typedef short INT16; +#endif + +/* INT32 must hold at least signed 32-bit values. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */ +typedef long INT32; +#endif + +/* Datatype used for image dimensions. The JPEG standard only supports + * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore + * "unsigned int" is sufficient on all machines. However, if you need to + * handle larger images and you don't mind deviating from the spec, you + * can change this datatype. + */ + +typedef unsigned int JDIMENSION; + +#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ + + +/* These macros are used in all function definitions and extern declarations. + * You could modify them if you need to change function linkage conventions; + * in particular, you'll need to do that to make the library a Windows DLL. + * Another application is to make all functions global for use with debuggers + * or code profilers that require it. + */ + +/* a function called through method pointers: */ +#define METHODDEF(type) static type +/* a function used only in its module: */ +#define LOCAL(type) static type +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type +/* a reference to a GLOBAL function: */ +#define EXTERN(type) extern type + + +/* This macro is used to declare a "method", that is, a function pointer. + * We want to supply prototype parameters if the compiler can cope. + * Note that the arglist parameter must be parenthesized! + * Again, you can customize this if you need special linkage keywords. + */ + +#ifdef HAVE_PROTOTYPES +#define JMETHOD(type,methodname,arglist) type (*methodname) arglist +#else +#define JMETHOD(type,methodname,arglist) type (*methodname) () +#endif + + +/* Here is the pseudo-keyword for declaring pointers that must be "far" + * on 80x86 machines. Most of the specialized coding for 80x86 is handled + * by just saying "FAR *" where such a pointer is needed. In a few places + * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. + */ + +#ifdef NEED_FAR_POINTERS +#define FAR far +#else +#define FAR +#endif + + +/* + * On a few systems, type boolean and/or its values FALSE, TRUE may appear + * in standard header files. Or you may have conflicts with application- + * specific header files that you want to include together with these files. + * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. + */ + +#ifndef HAVE_BOOLEAN +typedef int boolean; +#endif +#ifndef FALSE /* in case these macros already exist */ +#define FALSE 0 /* values of boolean */ +#endif +#ifndef TRUE +#define TRUE 1 +#endif + + +/* + * The remaining options affect code selection within the JPEG library, + * but they don't need to be visible to most applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. + */ + +#ifdef JPEG_INTERNALS +#define JPEG_INTERNAL_OPTIONS +#endif + +#ifdef JPEG_INTERNAL_OPTIONS + + +/* + * These defines indicate whether to include various optional functions. + * Undefining some of these symbols will produce a smaller but less capable + * library. Note that you can leave certain source files out of the + * compilation/linking process if you've #undef'd the corresponding symbols. + * (You may HAVE to do that if your compiler doesn't like null source files.) + */ + +/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */ + +/* Capability options common to encoder and decoder: */ + +#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */ +#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */ +#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */ + +/* Encoder capability options: */ + +#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ +/* Note: if you selected 12-bit data precision, it is dangerous to turn off + * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit + * precision, so jchuff.c normally uses entropy optimization to compute + * usable tables for higher precision. If you don't want to do optimization, + * you'll have to supply different default Huffman tables. + * The exact same statements apply for progressive JPEG: the default tables + * don't work for progressive mode. (This may get fixed, however.) + */ +#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ + +/* Decoder capability options: */ + +#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ +#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ +#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ +#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ +#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ +#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ +#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ + +/* more capability options later, no doubt */ + + +/* + * Ordering of RGB data in scanlines passed to or from the application. + * If your application wants to deal with data in the order B,G,R, just + * change these macros. You can also deal with formats such as R,G,B,X + * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing + * the offsets will also change the order in which colormap data is organized. + * RESTRICTIONS: + * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats. + * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not + * useful if you are using JPEG color spaces other than YCbCr or grayscale. + * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE + * is not 3 (they don't understand about dummy color components!). So you + * can't use color quantization if you change that value. + */ + +#define RGB_RED 0 /* Offset of Red in an RGB scanline element */ +#define RGB_GREEN 1 /* Offset of Green */ +#define RGB_BLUE 2 /* Offset of Blue */ +#ifdef ANDROID_RGB +#define RGB_ALPHA 3 /* Offset of Alpha */ +#endif +#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ + +/* Definitions for speed-related optimizations. */ + + +/* If your compiler supports inline functions, define INLINE + * as the inline keyword; otherwise define it as empty. + */ + +#ifndef INLINE +#ifdef __GNUC__ /* for instance, GNU C knows about inline */ +#define INLINE __inline__ +#endif +#ifndef INLINE +#define INLINE /* default is to define it as empty */ +#endif +#endif + + +/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying + * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER + * as short on such a machine. MULTIPLIER must be at least 16 bits wide. + */ + +#ifndef MULTIPLIER +#ifdef ANDROID_INTELSSE2_IDCT + #define MULTIPLIER short +#elif ANDROID_MIPS_IDCT + #define MULTIPLIER short +#elif NV_ARM_NEON + #define MULTIPLIER short +#else + #define MULTIPLIER int /* type for fastest integer multiply */ +#endif +#endif + + +/* FAST_FLOAT should be either float or double, whichever is done faster + * by your compiler. (Note that this type is only used in the floating point + * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) + * Typically, float is faster in ANSI C compilers, while double is faster in + * pre-ANSI compilers (because they insist on converting to double anyway). + * The code below therefore chooses float if we have ANSI-style prototypes. + */ + +#ifndef FAST_FLOAT +#ifdef HAVE_PROTOTYPES +#define FAST_FLOAT float +#else +#define FAST_FLOAT double +#endif +#endif + +#endif /* JPEG_INTERNAL_OPTIONS */ diff --git a/TMessagesProj/jni/libjpeg/jpegint.h b/TMessagesProj/jni/libjpeg/jpegint.h new file mode 100755 index 000000000..3b5511e18 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jpegint.h @@ -0,0 +1,432 @@ +/* + * jpegint.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file provides common declarations for the various JPEG modules. + * These declarations are considered internal to the JPEG library; most + * applications using the library shouldn't need to include this file. + */ + + +/* Declarations for both compression & decompression */ + +typedef enum { /* Operating modes for buffer controllers */ + JBUF_PASS_THRU, /* Plain stripwise operation */ + /* Remaining modes require a full-image buffer to have been created */ + JBUF_SAVE_SOURCE, /* Run source subobject only, save output */ + JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */ + JBUF_SAVE_AND_PASS /* Run both subobjects, save output */ +} J_BUF_MODE; + +/* Values of global_state field (jdapi.c has some dependencies on ordering!) */ +#define CSTATE_START 100 /* after create_compress */ +#define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */ +#define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */ +#define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */ +#define DSTATE_START 200 /* after create_decompress */ +#define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */ +#define DSTATE_READY 202 /* found SOS, ready for start_decompress */ +#define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/ +#define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */ +#define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */ +#define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */ +#define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */ +#define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */ +#define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */ +#define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */ + + +/* Declarations for compression modules */ + +/* Master control module */ +struct jpeg_comp_master { + JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo)); + JMETHOD(void, pass_startup, (j_compress_ptr cinfo)); + JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); + + /* State variables made visible to other modules */ + boolean call_pass_startup; /* True if pass_startup must be called */ + boolean is_last_pass; /* True during last pass */ +}; + +/* Main buffer control (downsampled-data buffer) */ +struct jpeg_c_main_controller { + JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); + JMETHOD(void, process_data, (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail)); +}; + +/* Compression preprocessing (downsampling input buffer control) */ +struct jpeg_c_prep_controller { + JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); + JMETHOD(void, pre_process_data, (j_compress_ptr cinfo, + JSAMPARRAY input_buf, + JDIMENSION *in_row_ctr, + JDIMENSION in_rows_avail, + JSAMPIMAGE output_buf, + JDIMENSION *out_row_group_ctr, + JDIMENSION out_row_groups_avail)); +}; + +/* Coefficient buffer control */ +struct jpeg_c_coef_controller { + JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); + JMETHOD(boolean, compress_data, (j_compress_ptr cinfo, + JSAMPIMAGE input_buf)); +}; + +/* Colorspace conversion */ +struct jpeg_color_converter { + JMETHOD(void, start_pass, (j_compress_ptr cinfo)); + JMETHOD(void, color_convert, (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows)); +}; + +/* Downsampling */ +struct jpeg_downsampler { + JMETHOD(void, start_pass, (j_compress_ptr cinfo)); + JMETHOD(void, downsample, (j_compress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_index, + JSAMPIMAGE output_buf, + JDIMENSION out_row_group_index)); + + boolean need_context_rows; /* TRUE if need rows above & below */ +}; + +/* Forward DCT (also controls coefficient quantization) */ +struct jpeg_forward_dct { + JMETHOD(void, start_pass, (j_compress_ptr cinfo)); + /* perhaps this should be an array??? */ + JMETHOD(void, forward_DCT, (j_compress_ptr cinfo, + jpeg_component_info * compptr, + JSAMPARRAY sample_data, JBLOCKROW coef_blocks, + JDIMENSION start_row, JDIMENSION start_col, + JDIMENSION num_blocks)); +}; + +/* Entropy encoding */ +struct jpeg_entropy_encoder { + JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); + JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); + JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); +}; + +/* Marker writing */ +struct jpeg_marker_writer { + JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); + JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); + JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); + JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); + JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); + /* These routines are exported to allow insertion of extra markers */ + /* Probably only COM and APPn markers should be written this way */ + JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, + unsigned int datalen)); + JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); +}; + + +/* Declarations for decompression modules */ + +/* Master control module */ +struct jpeg_decomp_master { + JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); + JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); + + /* State variables made visible to other modules */ + boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ +}; + +/* Input control module */ +struct jpeg_input_controller { + JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); + JMETHOD(int, consume_input_build_huffman_index, (j_decompress_ptr cinfo, + huffman_index *index, int scan_count)); + JMETHOD(int, consume_markers, (j_decompress_ptr cinfo, + huffman_index *index, int scan_count)); + JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); + JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); + JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); + + /* State variables made visible to other modules */ + boolean has_multiple_scans; /* True if file has multiple scans */ + boolean eoi_reached; /* True when EOI has been consumed */ +}; + +/* Main buffer control (downsampled-data buffer) */ +struct jpeg_d_main_controller { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); + JMETHOD(void, process_data, (j_decompress_ptr cinfo, + JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); +}; + +/* Coefficient buffer control */ +struct jpeg_d_coef_controller { + JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); + JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); + JMETHOD(int, consume_data_build_huffman_index, (j_decompress_ptr cinfo, + huffman_index* index, int scan_count)); + JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); + JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, + JSAMPIMAGE output_buf)); + /* Pointer to array of coefficient virtual arrays, or NULL if none */ + jvirt_barray_ptr *coef_arrays; + + /* column number of the first and last tile, respectively */ + int column_left_boundary; + int column_right_boundary; + + /* column number of the first and last MCU, respectively */ + int MCU_column_left_boundary; + int MCU_column_right_boundary; + + /* the number of MCU columns to skip from the indexed MCU, iM, + * to the requested MCU boundary, rM, where iM is the MCU that we sample + * into our index and is the nearest one to the left of rM. + */ + int MCU_columns_to_skip; +}; + +/* Decompression postprocessing (color quantization buffer control) */ +struct jpeg_d_post_controller { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); + JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, + JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, + JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); +}; + +/* Marker reading & parsing */ +struct jpeg_marker_reader { + JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); + /* Read markers until SOS or EOI. + * Returns same codes as are defined for jpeg_consume_input: + * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. + */ + JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); + JMETHOD(void, get_sos_marker_position, (j_decompress_ptr cinfo, + huffman_index *index)); + /* Read a restart marker --- exported for use by entropy decoder only */ + jpeg_marker_parser_method read_restart_marker; + + /* State of marker reader --- nominally internal, but applications + * supplying COM or APPn handlers might like to know the state. + */ + boolean saw_SOI; /* found SOI? */ + boolean saw_SOF; /* found SOF? */ + int next_restart_num; /* next restart number expected (0-7) */ + int current_sos_marker_position; + unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ +}; + +/* Entropy decoding */ +struct jpeg_entropy_decoder { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); + JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, + JBLOCKROW *MCU_data)); + JMETHOD(boolean, decode_mcu_discard_coef, (j_decompress_ptr cinfo)); + JMETHOD(void, configure_huffman_decoder, (j_decompress_ptr cinfo, + huffman_offset_data offset)); + JMETHOD(void, get_huffman_decoder_configuration, (j_decompress_ptr cinfo, + huffman_offset_data *offset)); + + /* This is here to share code between baseline and progressive decoders; */ + /* other modules probably should not use it */ + boolean insufficient_data; /* set TRUE after emitting warning */ + + huffman_index *index; +}; + +/* Inverse DCT (also performs dequantization) */ +typedef JMETHOD(void, inverse_DCT_method_ptr, + (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, JDIMENSION output_col)); + +struct jpeg_inverse_dct { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); + /* It is useful to allow each component to have a separate IDCT method. */ + inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; +}; + +/* Upsampling (note that upsampler must also call color converter) */ +struct jpeg_upsampler { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); + JMETHOD(void, upsample, (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, + JDIMENSION *in_row_group_ctr, + JDIMENSION in_row_groups_avail, + JSAMPARRAY output_buf, + JDIMENSION *out_row_ctr, + JDIMENSION out_rows_avail)); + + boolean need_context_rows; /* TRUE if need rows above & below */ +}; + +/* Colorspace conversion */ +struct jpeg_color_deconverter { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); + JMETHOD(void, color_convert, (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows)); +}; + +/* Color quantization or color precision reduction */ +struct jpeg_color_quantizer { + JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); + JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPARRAY output_buf, + int num_rows)); + JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); + JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); +}; + + +/* Miscellaneous useful macros */ + +#undef MAX +#define MAX(a,b) ((a) > (b) ? (a) : (b)) +#undef MIN +#define MIN(a,b) ((a) < (b) ? (a) : (b)) + + +/* We assume that right shift corresponds to signed division by 2 with + * rounding towards minus infinity. This is correct for typical "arithmetic + * shift" instructions that shift in copies of the sign bit. But some + * C compilers implement >> with an unsigned shift. For these machines you + * must define RIGHT_SHIFT_IS_UNSIGNED. + * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. + * It is only applied with constant shift counts. SHIFT_TEMPS must be + * included in the variables of any routine using RIGHT_SHIFT. + */ + +#ifdef RIGHT_SHIFT_IS_UNSIGNED +#define SHIFT_TEMPS INT32 shift_temp; +#define RIGHT_SHIFT(x,shft) \ + ((shift_temp = (x)) < 0 ? \ + (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ + (shift_temp >> (shft))) +#else +#define SHIFT_TEMPS +#define RIGHT_SHIFT(x,shft) ((x) >> (shft)) +#endif + + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jinit_compress_master jICompress +#define jinit_c_master_control jICMaster +#define jinit_c_main_controller jICMainC +#define jinit_c_prep_controller jICPrepC +#define jinit_c_coef_controller jICCoefC +#define jinit_color_converter jICColor +#define jinit_downsampler jIDownsampler +#define jinit_forward_dct jIFDCT +#define jinit_huff_encoder jIHEncoder +#define jinit_phuff_encoder jIPHEncoder +#define jinit_marker_writer jIMWriter +#define jinit_master_decompress jIDMaster +#define jinit_d_main_controller jIDMainC +#define jinit_d_coef_controller jIDCoefC +#define jinit_d_post_controller jIDPostC +#define jinit_input_controller jIInCtlr +#define jinit_marker_reader jIMReader +#define jinit_huff_decoder jIHDecoder +#define jinit_phuff_decoder jIPHDecoder +#define jinit_inverse_dct jIIDCT +#define jinit_upsampler jIUpsampler +#define jinit_color_deconverter jIDColor +#define jinit_1pass_quantizer jI1Quant +#define jinit_2pass_quantizer jI2Quant +#define jinit_merged_upsampler jIMUpsampler +#define jinit_memory_mgr jIMemMgr +#define jdiv_round_up jDivRound +#define jround_up jRound +#define jcopy_sample_rows jCopySamples +#define jcopy_block_row jCopyBlocks +#define jzero_far jZeroFar +#define jpeg_zigzag_order jZIGTable +#define jpeg_natural_order jZAGTable +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Compression module initialization routines */ +EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, + boolean transcode_only)); +EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo)); +EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); +/* Decompression module initialization routines */ +EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, + boolean need_full_buffer)); +EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_huff_decoder_no_data JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); +EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_decompress_per_scan_setup (j_decompress_ptr cinfo); +/* Memory manager initialization */ +EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); + +/* Utility routines in jutils.c */ +EXTERN(long) jdiv_round_up JPP((long a, long b)); +EXTERN(long) jround_up JPP((long a, long b)); +EXTERN(long) jmin JPP((long a, long b)); +EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, + JSAMPARRAY output_array, int dest_row, + int num_rows, JDIMENSION num_cols)); +EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, + JDIMENSION num_blocks)); +EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); + +EXTERN(void) jset_input_stream_position JPP((j_decompress_ptr cinfo, + int offset)); +EXTERN(void) jset_input_stream_position_bit JPP((j_decompress_ptr cinfo, + int byte_offset, int bit_left, INT32 buf)); + +EXTERN(int) jget_input_stream_position JPP((j_decompress_ptr cinfo)); +/* Constant tables in jutils.c */ +#if 0 /* This table is not actually needed in v6a */ +extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ +#endif +extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ + +/* Suppress undefined-structure complaints if necessary. */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ +struct jvirt_sarray_control { long dummy; }; +struct jvirt_barray_control { long dummy; }; +#endif +#endif /* INCOMPLETE_TYPES_BROKEN */ diff --git a/TMessagesProj/jni/libjpeg/jpeglib.h b/TMessagesProj/jni/libjpeg/jpeglib.h new file mode 100755 index 000000000..07e687294 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jpeglib.h @@ -0,0 +1,1184 @@ +/* + * jpeglib.h + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the application interface for the JPEG library. + * Most applications using the library need only include this file, + * and perhaps jerror.h if they want to know the exact error codes. + */ + +#ifndef JPEGLIB_H +#define JPEGLIB_H + +/* + * First we include the configuration files that record how this + * installation of the JPEG library is set up. jconfig.h can be + * generated automatically for many systems. jmorecfg.h contains + * manual configuration options that most people need not worry about. + */ + +#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ +#include "jconfig.h" /* widely used configuration options */ +#endif +#include "jmorecfg.h" /* seldom changed options */ + + +/* Version ID for the JPEG library. + * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60". + */ + +#define JPEG_LIB_VERSION 62 /* Version 6b */ + + +/* Various constants determining the sizes of things. + * All of these are specified by the JPEG standard, so don't change them + * if you want to be compatible. + */ + +#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ +#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ +#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ +#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ +#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ +#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ +#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU + * to handle it. We even let you do this from the jconfig.h file. However, + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe + * sometimes emits noncompliant files doesn't mean you should too. + */ +#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ +#ifndef D_MAX_BLOCKS_IN_MCU +#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ +#endif + + +/* Data structures for images (arrays of samples and of DCT coefficients). + * On 80x86 machines, the image arrays are too big for near pointers, + * but the pointer arrays can fit in near memory. + */ + +typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ +typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ +typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ + +typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ +typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ +typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ +typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ + +typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ + + +/* Types for JPEG compression parameters and working tables. */ + + +/* DCT coefficient quantization tables. */ + +typedef struct { + /* This array gives the coefficient quantizers in natural array order + * (not the zigzag order in which they are stored in a JPEG DQT marker). + * CAUTION: IJG versions prior to v6a kept this array in zigzag order. + */ + UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JQUANT_TBL; + + +/* Huffman coding tables. */ + +typedef struct { + /* These two fields directly represent the contents of a JPEG DHT marker */ + UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ + /* length k bits; bits[0] is unused */ + UINT8 huffval[256]; /* The symbols, in order of incr code length */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JHUFF_TBL; + + +/* Basic info about one component (color channel). */ + +typedef struct { + /* These values are fixed over the whole image. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOF marker. */ + int component_id; /* identifier for this component (0..255) */ + int component_index; /* its index in SOF or cinfo->comp_info[] */ + int h_samp_factor; /* horizontal sampling factor (1..4) */ + int v_samp_factor; /* vertical sampling factor (1..4) */ + int quant_tbl_no; /* quantization table selector (0..3) */ + /* These values may vary between scans. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOS marker. */ + /* The decompressor output side may not use these variables. */ + int dc_tbl_no; /* DC entropy table selector (0..3) */ + int ac_tbl_no; /* AC entropy table selector (0..3) */ + + /* Remaining fields should be treated as private by applications. */ + + /* These values are computed during compression or decompression startup: */ + /* Component's size in DCT blocks. + * Any dummy blocks added to complete an MCU are not counted; therefore + * these values do not depend on whether a scan is interleaved or not. + */ + JDIMENSION width_in_blocks; + JDIMENSION height_in_blocks; + /* Size of a DCT block in samples. Always DCTSIZE for compression. + * For decompression this is the size of the output from one DCT block, + * reflecting any scaling we choose to apply during the IDCT step. + * Values of 1,2,4,8 are likely to be supported. Note that different + * components may receive different IDCT scalings. + */ + int DCT_scaled_size; + /* The downsampled dimensions are the component's actual, unpadded number + * of samples at the main buffer (preprocessing/compression interface), thus + * downsampled_width = ceil(image_width * Hi/Hmax) + * and similarly for height. For decompression, IDCT scaling is included, so + * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) + */ + JDIMENSION downsampled_width; /* actual width in samples */ + JDIMENSION downsampled_height; /* actual height in samples */ + /* This flag is used only for decompression. In cases where some of the + * components will be ignored (eg grayscale output from YCbCr image), + * we can skip most computations for the unused components. + */ + boolean component_needed; /* do we need the value of this component? */ + + /* These values are computed before starting a scan of the component. */ + /* The decompressor output side may not use these variables. */ + int MCU_width; /* number of blocks per MCU, horizontally */ + int MCU_height; /* number of blocks per MCU, vertically */ + int MCU_blocks; /* MCU_width * MCU_height */ + int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */ + int last_col_width; /* # of non-dummy blocks across in last MCU */ + int last_row_height; /* # of non-dummy blocks down in last MCU */ + + /* Saved quantization table for component; NULL if none yet saved. + * See jdinput.c comments about the need for this information. + * This field is currently used only for decompression. + */ + JQUANT_TBL * quant_table; + + /* Private per-component storage for DCT or IDCT subsystem. */ + void * dct_table; +} jpeg_component_info; + + +/* The script for encoding a multiple-scan file is an array of these: */ + +typedef struct { + int comps_in_scan; /* number of components encoded in this scan */ + int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ + int Ss, Se; /* progressive JPEG spectral selection parms */ + int Ah, Al; /* progressive JPEG successive approx. parms */ +} jpeg_scan_info; + +/* The decompressor can save APPn and COM markers in a list of these: */ + +typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr; + +struct jpeg_marker_struct { + jpeg_saved_marker_ptr next; /* next in list, or NULL */ + UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ + unsigned int original_length; /* # bytes of data in the file */ + unsigned int data_length; /* # bytes of data saved at data[] */ + JOCTET FAR * data; /* the data contained in the marker */ + /* the marker length word is not counted in data_length or original_length */ +}; + +/* Known color spaces. */ + +typedef enum { + JCS_UNKNOWN, /* error/unspecified */ + JCS_GRAYSCALE, /* monochrome */ + JCS_RGB, /* red/green/blue */ + JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ + JCS_CMYK, /* C/M/Y/K */ + JCS_YCCK, /* Y/Cb/Cr/K */ +#ifdef ANDROID_RGB + JCS_RGBA_8888, /* red/green/blue/alpha */ + JCS_RGB_565 /* red/green/blue in 565 format */ +#endif +} J_COLOR_SPACE; + +/* DCT/IDCT algorithm options. */ + +typedef enum { + JDCT_ISLOW, /* slow but accurate integer algorithm */ + JDCT_IFAST, /* faster, less accurate integer method */ + JDCT_FLOAT /* floating-point: accurate, fast on fast HW */ +} J_DCT_METHOD; + +#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ +#define JDCT_DEFAULT JDCT_ISLOW +#endif +#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ +#define JDCT_FASTEST JDCT_IFAST +#endif + +/* Dithering options for decompression. */ + +typedef enum { + JDITHER_NONE, /* no dithering */ + JDITHER_ORDERED, /* simple ordered dither */ + JDITHER_FS /* Floyd-Steinberg error diffusion dither */ +} J_DITHER_MODE; + + +/* Common fields between JPEG compression and decompression master structs. */ + +#define jpeg_common_fields \ + struct jpeg_error_mgr * err; /* Error handler module */\ + struct jpeg_memory_mgr * mem; /* Memory manager module */\ + struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\ + void * client_data; /* Available for use by application */\ + boolean is_decompressor; /* So common code can tell which is which */\ + int global_state /* For checking call sequence validity */ + +/* Routines that are to be used by both halves of the library are declared + * to receive a pointer to this structure. There are no actual instances of + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. + */ +struct jpeg_common_struct { + jpeg_common_fields; /* Fields common to both master struct types */ + /* Additional fields follow in an actual jpeg_compress_struct or + * jpeg_decompress_struct. All three structs must agree on these + * initial fields! (This would be a lot cleaner in C++.) + */ +}; + +typedef struct jpeg_common_struct * j_common_ptr; +typedef struct jpeg_compress_struct * j_compress_ptr; +typedef struct jpeg_decompress_struct * j_decompress_ptr; + + +/* Master record for a compression instance */ + +struct jpeg_compress_struct { + jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ + + /* Destination for compressed data */ + struct jpeg_destination_mgr * dest; + + /* Description of source image --- these fields must be filled in by + * outer application before starting compression. in_color_space must + * be correct before you can even call jpeg_set_defaults(). + */ + + JDIMENSION image_width; /* input image width */ + JDIMENSION image_height; /* input image height */ + int input_components; /* # of color components in input image */ + J_COLOR_SPACE in_color_space; /* colorspace of input image */ + + double input_gamma; /* image gamma of input image */ + + /* Compression parameters --- these fields must be set before calling + * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to + * initialize everything to reasonable defaults, then changing anything + * the application specifically wants to change. That way you won't get + * burnt when new parameters are added. Also note that there are several + * helper routines to simplify changing parameters. + */ + + int data_precision; /* bits of precision in image data */ + + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + int num_scans; /* # of entries in scan_info array */ + const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */ + /* The default value of scan_info is NULL, which causes a single-scan + * sequential JPEG file to be emitted. To create a multi-scan file, + * set num_scans and scan_info to point to an array of scan definitions. + */ + + boolean raw_data_in; /* TRUE=caller supplies downsampled data */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + int smoothing_factor; /* 1..100, or 0 for no input smoothing */ + J_DCT_METHOD dct_method; /* DCT algorithm selector */ + + /* The restart interval can be specified in absolute MCUs by setting + * restart_interval, or in MCU rows by setting restart_in_rows + * (in which case the correct restart_interval will be figured + * for each scan). + */ + unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ + int restart_in_rows; /* if > 0, MCU rows per restart interval */ + + /* Parameters controlling emission of special markers. */ + + boolean write_JFIF_header; /* should a JFIF marker be written? */ + UINT8 JFIF_major_version; /* What to write for the JFIF version number */ + UINT8 JFIF_minor_version; + /* These three values are not used by the JPEG code, merely copied */ + /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ + /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ + /* ratio is defined by X_density/Y_density even when density_unit=0. */ + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean write_Adobe_marker; /* should an Adobe marker be written? */ + + /* State variable: index of next scanline to be written to + * jpeg_write_scanlines(). Application may use this to control its + * processing loop, e.g., "while (next_scanline < image_height)". + */ + + JDIMENSION next_scanline; /* 0 .. image_height-1 */ + + /* Remaining fields are known throughout compressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during compression startup + */ + boolean progressive_mode; /* TRUE if scan script uses progressive mode */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ + /* The coefficient controller receives data in units of MCU rows as defined + * for fully interleaved scans (whether the JPEG file is interleaved or not). + * There are v_samp_factor * DCTSIZE sample rows of each component in an + * "iMCU" (interleaved MCU) row. + */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[C_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* + * Links to compression subobjects (methods and private variables of modules) + */ + struct jpeg_comp_master * master; + struct jpeg_c_main_controller * main; + struct jpeg_c_prep_controller * prep; + struct jpeg_c_coef_controller * coef; + struct jpeg_marker_writer * marker; + struct jpeg_color_converter * cconvert; + struct jpeg_downsampler * downsample; + struct jpeg_forward_dct * fdct; + struct jpeg_entropy_encoder * entropy; + jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */ + int script_space_size; +}; + + +/* Master record for a decompression instance */ + +struct jpeg_decompress_struct { + jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ + + /* Source of compressed data */ + struct jpeg_source_mgr * src; + + /* Basic description of image --- filled in by jpeg_read_header(). */ + /* Application may inspect these values to decide how to process image. */ + + JDIMENSION original_image_width; /* nominal image width (from SOF marker) */ + + JDIMENSION image_width; /* nominal image width (from SOF marker) + may be changed by tile decode */ + JDIMENSION image_height; /* nominal image height */ + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + /* Decompression processing parameters --- these fields must be set before + * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes + * them to default values. + */ + + J_COLOR_SPACE out_color_space; /* colorspace for output */ + + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + double output_gamma; /* image gamma wanted in output */ + + boolean buffered_image; /* TRUE=multiple output passes */ + boolean raw_data_out; /* TRUE=downsampled data wanted */ + + J_DCT_METHOD dct_method; /* IDCT algorithm selector */ + boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ + boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ + + boolean quantize_colors; /* TRUE=colormapped output wanted */ + /* the following are ignored if not quantize_colors: */ + J_DITHER_MODE dither_mode; /* type of color dithering to use */ + boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ + int desired_number_of_colors; /* max # colors to use in created colormap */ + /* these are significant only in buffered-image mode: */ + boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ + boolean enable_external_quant;/* enable future use of external colormap */ + boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ + + /* Description of actual output image that will be returned to application. + * These fields are computed by jpeg_start_decompress(). + * You can also use jpeg_calc_output_dimensions() to determine these values + * in advance of calling jpeg_start_decompress(). + */ + + JDIMENSION output_width; /* scaled image width */ + JDIMENSION output_height; /* scaled image height */ + int out_color_components; /* # of color components in out_color_space */ + int output_components; /* # of color components returned */ + /* output_components is 1 (a colormap index) when quantizing colors; + * otherwise it equals out_color_components. + */ + int rec_outbuf_height; /* min recommended height of scanline buffer */ + /* If the buffer passed to jpeg_read_scanlines() is less than this many rows + * high, space and time will be wasted due to unnecessary data copying. + * Usually rec_outbuf_height will be 1 or 2, at most 4. + */ + + /* When quantizing colors, the output colormap is described by these fields. + * The application can supply a colormap by setting colormap non-NULL before + * calling jpeg_start_decompress; otherwise a colormap is created during + * jpeg_start_decompress or jpeg_start_output. + * The map has out_color_components rows and actual_number_of_colors columns. + */ + int actual_number_of_colors; /* number of entries in use */ + JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ + + /* State variables: these variables indicate the progress of decompression. + * The application may examine these but must not modify them. + */ + + /* Row index of next scanline to be read from jpeg_read_scanlines(). + * Application may use this to control its processing loop, e.g., + * "while (output_scanline < output_height)". + */ + JDIMENSION output_scanline; /* 0 .. output_height-1 */ + + /* Current input scan number and number of iMCU rows completed in scan. + * These indicate the progress of the decompressor input side. + */ + int input_scan_number; /* Number of SOS markers seen so far */ + JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ + + /* The "output scan number" is the notional scan being displayed by the + * output side. The decompressor will not allow output scan/row number + * to get ahead of input scan/row, but it can fall arbitrarily far behind. + */ + int output_scan_number; /* Nominal scan number being displayed */ + JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ + + /* Current progression status. coef_bits[c][i] indicates the precision + * with which component c's DCT coefficient i (in zigzag order) is known. + * It is -1 when no data has yet been received, otherwise it is the point + * transform (shift) value for the most recent scan of the coefficient + * (thus, 0 at completion of the progression). + * This pointer is NULL when reading a non-progressive file. + */ + int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ + + /* Internal JPEG parameters --- the application usually need not look at + * these fields. Note that the decompressor output side may not use + * any parameters that can change between scans. + */ + + /* Quantization and Huffman tables are carried forward across input + * datastreams when processing abbreviated JPEG datastreams. + */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + /* These parameters are never carried across datastreams, since they + * are given in SOF/SOS markers or defined to be reset by SOI. + */ + + int data_precision; /* bits of precision in image data */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + boolean tile_decode; /* TRUE if using tile based decoding */ + boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ + + /* These fields record data obtained from optional markers recognized by + * the JPEG library. + */ + boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ + /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ + UINT8 JFIF_major_version; /* JFIF version number */ + UINT8 JFIF_minor_version; + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ + UINT8 Adobe_transform; /* Color transform code from Adobe marker */ + + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + + /* Aside from the specific data retained from APPn markers known to the + * library, the uninterpreted contents of any or all APPn and COM markers + * can be saved in a list for examination by the application. + */ + jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ + + /* Remaining fields are known throughout decompressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during decompression startup + */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ + /* The coefficient controller's input and output progress is measured in + * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows + * in fully interleaved JPEG scans, but are used whether the scan is + * interleaved or not. We define an iMCU row as v_samp_factor DCT block + * rows of each component. Therefore, the IDCT output contains + * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row. + */ + + JSAMPLE * sample_range_limit; /* table for fast range-limiting */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + * Note that the decompressor output side must not use these fields. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[D_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* This field is shared between entropy decoder and marker parser. + * It is either zero or the code of a JPEG marker that has been + * read from the data source, but has not yet been processed. + */ + int unread_marker; + + /* + * Links to decompression subobjects (methods, private variables of modules) + */ + struct jpeg_decomp_master * master; + struct jpeg_d_main_controller * main; + struct jpeg_d_coef_controller * coef; + struct jpeg_d_post_controller * post; + struct jpeg_input_controller * inputctl; + struct jpeg_marker_reader * marker; + struct jpeg_entropy_decoder * entropy; + struct jpeg_inverse_dct * idct; + struct jpeg_upsampler * upsample; + struct jpeg_color_deconverter * cconvert; + struct jpeg_color_quantizer * cquantize; +}; + +typedef struct { + + // |--- byte_offset ---|- bit_left -| + // \------ 27 -------/ \---- 5 ----/ + unsigned int bitstream_offset; + short prev_dc[3]; + + // remaining EOBs in EOBRUN + unsigned short EOBRUN; + + // save the decoder current bit buffer, entropy->bitstate.get_buffer. + INT32 get_buffer; + + // save the restart info. + unsigned short restarts_to_go; + unsigned char next_restart_num; +} huffman_offset_data; + +typedef struct { + + // The header starting position of this scan + unsigned int bitstream_offset; + + // Number of components in this scan + int comps_in_scan; + + // Number of MCUs in each row + int MCUs_per_row; + int MCU_rows_per_iMCU_row; + + // The last MCU position and its dc value in this scan + huffman_offset_data prev_MCU_offset; + + huffman_offset_data **offset; +} huffman_scan_header; + +#define DEFAULT_MCU_SAMPLE_SIZE 16 + +typedef struct { + + // The number of MCUs that we sample each time as an index point + int MCU_sample_size; + + // Number of scan in this image + int scan_count; + + // Number of iMCUs rows in this image + int total_iMCU_rows; + + // Memory used by scan struct + size_t mem_used; + huffman_scan_header *scan; +} huffman_index; + +/* "Object" declarations for JPEG modules that may be supplied or called + * directly by the surrounding application. + * As with all objects in the JPEG library, these structs only define the + * publicly visible methods and state variables of a module. Additional + * private fields may exist after the public ones. + */ + + +/* Error handler object */ + +struct jpeg_error_mgr { + /* Error exit handler: does not return to caller */ + JMETHOD(void, error_exit, (j_common_ptr cinfo)); + /* Conditionally emit a trace or warning message */ + JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); + /* Routine that actually outputs a trace or error message */ + JMETHOD(void, output_message, (j_common_ptr cinfo)); + /* Format a message string for the most recent JPEG error or message */ + JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); +#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ + /* Reset error state variables at start of a new image */ + JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); + + /* The message ID code and any parameters are saved here. + * A message can have one string parameter or up to 8 int parameters. + */ + int msg_code; +#define JMSG_STR_PARM_MAX 80 + union { + int i[8]; + char s[JMSG_STR_PARM_MAX]; + } msg_parm; + + /* Standard state variables for error facility */ + + int trace_level; /* max msg_level that will be displayed */ + + /* For recoverable corrupt-data errors, we emit a warning message, + * but keep going unless emit_message chooses to abort. emit_message + * should count warnings in num_warnings. The surrounding application + * can check for bad data by seeing if num_warnings is nonzero at the + * end of processing. + */ + long num_warnings; /* number of corrupt-data warnings */ + + /* These fields point to the table(s) of error message strings. + * An application can change the table pointer to switch to a different + * message list (typically, to change the language in which errors are + * reported). Some applications may wish to add additional error codes + * that will be handled by the JPEG library error mechanism; the second + * table pointer is used for this purpose. + * + * First table includes all errors generated by JPEG library itself. + * Error code 0 is reserved for a "no such error string" message. + */ + const char * const * jpeg_message_table; /* Library errors */ + int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ + /* Second table can be added by application (see cjpeg/djpeg for example). + * It contains strings numbered first_addon_message..last_addon_message. + */ + const char * const * addon_message_table; /* Non-library errors */ + int first_addon_message; /* code for first string in addon table */ + int last_addon_message; /* code for last string in addon table */ +}; + + +/* Progress monitor object */ + +struct jpeg_progress_mgr { + JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); + + long pass_counter; /* work units completed in this pass */ + long pass_limit; /* total number of work units in this pass */ + int completed_passes; /* passes completed so far */ + int total_passes; /* total number of passes expected */ +}; + + +/* Data destination object for compression */ + +struct jpeg_destination_mgr { + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + + JMETHOD(void, init_destination, (j_compress_ptr cinfo)); + JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); + JMETHOD(void, term_destination, (j_compress_ptr cinfo)); +}; + + +/* Data source object for decompression */ + +struct jpeg_source_mgr { + const JOCTET * next_input_byte; /* => next byte to read from buffer */ + const JOCTET * start_input_byte; /* => first byte to read from input */ + size_t bytes_in_buffer; /* # of bytes remaining in buffer */ + size_t current_offset; /* current readed input offset */ + + JMETHOD(void, init_source, (j_decompress_ptr cinfo)); + JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); + JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); + JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); + JMETHOD(void, term_source, (j_decompress_ptr cinfo)); + JMETHOD(boolean, seek_input_data, (j_decompress_ptr cinfo, long byte_offset)); +}; + + +/* Memory manager object. + * Allocates "small" objects (a few K total), "large" objects (tens of K), + * and "really big" objects (virtual arrays with backing store if needed). + * The memory manager does not allow individual objects to be freed; rather, + * each created object is assigned to a pool, and whole pools can be freed + * at once. This is faster and more convenient than remembering exactly what + * to free, especially where malloc()/free() are not too speedy. + * NB: alloc routines never return NULL. They exit to error_exit if not + * successful. + */ + +#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ +#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ +#define JPOOL_NUMPOOLS 2 + +typedef struct jvirt_sarray_control * jvirt_sarray_ptr; +typedef struct jvirt_barray_control * jvirt_barray_ptr; + + +struct jpeg_memory_mgr { + /* Method pointers */ + JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, + JDIMENSION numrows)); + JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, + JDIMENSION numrows)); + JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION samplesperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION blocksperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); + JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, + jvirt_sarray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo, + jvirt_barray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id)); + JMETHOD(void, self_destruct, (j_common_ptr cinfo)); + + /* Limit on memory allocation for this JPEG object. (Note that this is + * merely advisory, not a guaranteed maximum; it only affects the space + * used for virtual-array buffers.) May be changed by outer application + * after creating the JPEG object. + */ + long max_memory_to_use; + + /* Maximum allocation request accepted by alloc_large. */ + long max_alloc_chunk; +}; + + +/* Routine signature for application-supplied marker processing methods. + * Need not pass marker code since it is stored in cinfo->unread_marker. + */ +typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); + + +/* Declarations for routines called by application. + * The JPP macro hides prototype parameters from compilers that can't cope. + * Note JPP requires double parentheses. + */ + +#ifdef HAVE_PROTOTYPES +#define JPP(arglist) arglist +#else +#define JPP(arglist) () +#endif + + +/* Short forms of external names for systems with brain-damaged linkers. + * We shorten external names to be unique in the first six letters, which + * is good enough for all known systems. + * (If your compiler itself needs names to be unique in less than 15 + * characters, you are out of luck. Get a better compiler.) + */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_std_error jStdError +#define jpeg_CreateCompress jCreaCompress +#define jpeg_CreateDecompress jCreaDecompress +#define jpeg_destroy_compress jDestCompress +#define jpeg_destroy_decompress jDestDecompress +#define jpeg_stdio_dest jStdDest +#define jpeg_stdio_src jStdSrc +#define jpeg_set_defaults jSetDefaults +#define jpeg_set_colorspace jSetColorspace +#define jpeg_default_colorspace jDefColorspace +#define jpeg_set_quality jSetQuality +#define jpeg_set_linear_quality jSetLQuality +#define jpeg_add_quant_table jAddQuantTable +#define jpeg_quality_scaling jQualityScaling +#define jpeg_simple_progression jSimProgress +#define jpeg_suppress_tables jSuppressTables +#define jpeg_alloc_quant_table jAlcQTable +#define jpeg_alloc_huff_table jAlcHTable +#define jpeg_start_compress jStrtCompress +#define jpeg_write_scanlines jWrtScanlines +#define jpeg_finish_compress jFinCompress +#define jpeg_write_raw_data jWrtRawData +#define jpeg_write_marker jWrtMarker +#define jpeg_write_m_header jWrtMHeader +#define jpeg_write_m_byte jWrtMByte +#define jpeg_write_tables jWrtTables +#define jpeg_read_header jReadHeader +#define jpeg_start_decompress jStrtDecompress +#define jpeg_read_scanlines jReadScanlines +#define jpeg_finish_decompress jFinDecompress +#define jpeg_read_raw_data jReadRawData +#define jpeg_has_multiple_scans jHasMultScn +#define jpeg_start_output jStrtOutput +#define jpeg_finish_output jFinOutput +#define jpeg_input_complete jInComplete +#define jpeg_new_colormap jNewCMap +#define jpeg_consume_input jConsumeInput +#define jpeg_calc_output_dimensions jCalcDimensions +#define jpeg_save_markers jSaveMarkers +#define jpeg_set_marker_processor jSetMarker +#define jpeg_read_coefficients jReadCoefs +#define jpeg_write_coefficients jWrtCoefs +#define jpeg_copy_critical_parameters jCopyCrit +#define jpeg_abort_compress jAbrtCompress +#define jpeg_abort_decompress jAbrtDecompress +#define jpeg_abort jAbort +#define jpeg_destroy jDestroy +#define jpeg_resync_to_restart jResyncRestart +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Default error-management setup */ +EXTERN(struct jpeg_error_mgr *) jpeg_std_error + JPP((struct jpeg_error_mgr * err)); + +/* Initialization of JPEG compression objects. + * jpeg_create_compress() and jpeg_create_decompress() are the exported + * names that applications should call. These expand to calls on + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information + * passed for version mismatch checking. + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. + */ +#define jpeg_create_compress(cinfo) \ + jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_compress_struct)) +#define jpeg_create_decompress(cinfo) \ + jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_decompress_struct)) +EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, + int version, size_t structsize)); +EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, + int version, size_t structsize)); +/* Destruction of JPEG compression objects */ +EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); + +/* Standard data source and destination managers: stdio streams. */ +/* Caller is responsible for opening the file before and closing after. */ +EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile)); +EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile)); + +/* Default parameter setup for compression */ +EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); +/* Compression parameter setup aids */ +EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, + J_COLOR_SPACE colorspace)); +EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, + boolean force_baseline)); +EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, + int scale_factor, + boolean force_baseline)); +EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, + boolean force_baseline)); +EXTERN(int) jpeg_quality_scaling JPP((int quality)); +EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, + boolean suppress)); +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo)); +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo)); + +/* Main entry points for compression */ +EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, + boolean write_all_tables)); +EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION num_lines)); +EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); + +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION num_lines)); + +/* Write a special marker. See libjpeg.doc concerning safe usage. */ +EXTERN(void) jpeg_write_marker + JPP((j_compress_ptr cinfo, int marker, + const JOCTET * dataptr, unsigned int datalen)); +/* Same, but piecemeal. */ +EXTERN(void) jpeg_write_m_header + JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); +EXTERN(void) jpeg_write_m_byte + JPP((j_compress_ptr cinfo, int val)); + +/* Alternate compression function: just write an abbreviated table file */ +EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); + +/* Decompression startup: read start of JPEG datastream to see what's there */ +EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, + boolean require_image)); +/* Return value is one of: */ +#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ +#define JPEG_HEADER_OK 1 /* Found valid image datastream */ +#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ +/* If you pass require_image = TRUE (normal case), you need not check for + * a TABLES_ONLY return code; an abbreviated file will cause an error exit. + * JPEG_SUSPENDED is only possible if you use a data source module that can + * give a suspension return (the stdio source module doesn't). + */ + +/* Main entry points for decompression */ +EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_start_tile_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION max_lines)); +EXTERN(JDIMENSION) jpeg_read_scanlines_from JPP((j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + int line_offset, + JDIMENSION max_lines)); +EXTERN(JDIMENSION) jpeg_read_tile_scanline JPP((j_decompress_ptr cinfo, + huffman_index *index, + JSAMPARRAY scanlines)); +EXTERN(void) jpeg_init_read_tile_scanline JPP((j_decompress_ptr cinfo, + huffman_index *index, + int *start_x, int *start_y, + int *width, int *height)); +EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); + +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION max_lines)); + +/* Additional entry points for buffered-image mode. */ +EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, + int scan_number)); +EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); +EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo)); +/* Return value is one of: */ +/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ +#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ +#define JPEG_REACHED_EOI 2 /* Reached end of image */ +#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ +#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ + +/* Precalculate output dimensions for current decompression parameters. */ +EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); + +/* Control saving of COM and APPn markers into marker_list. */ +EXTERN(void) jpeg_save_markers + JPP((j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit)); + +/* Install a special processing method for COM or APPn markers. */ +EXTERN(void) jpeg_set_marker_processor + JPP((j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine)); + +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_build_huffman_index + JPP((j_decompress_ptr cinfo, huffman_index *index)); +EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays)); +EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, + j_compress_ptr dstinfo)); + +/* If you choose to abort compression or decompression before completing + * jpeg_finish_(de)compress, then you need to clean up to release memory, + * temporary files, etc. You can just call jpeg_destroy_(de)compress + * if you're done with the JPEG object, but if you want to clean it up and + * reuse it, call this: + */ +EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); + +/* Generic versions of jpeg_abort and jpeg_destroy that work on either + * flavor of JPEG object. These may be more convenient in some places. + */ +EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); +EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); + +/* Default restart-marker-resync procedure for use by data source modules */ +EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, + int desired)); + +EXTERN(void) jpeg_configure_huffman_decoder(j_decompress_ptr cinfo, + huffman_offset_data offset); +EXTERN(void) jpeg_get_huffman_decoder_configuration(j_decompress_ptr cinfo, + huffman_offset_data *offset); +EXTERN(void) jpeg_create_huffman_index(j_decompress_ptr cinfo, + huffman_index *index); +EXTERN(void) jpeg_configure_huffman_index_scan(j_decompress_ptr cinfo, + huffman_index *index, int scan_no, int offset); +EXTERN(void) jpeg_destroy_huffman_index(huffman_index *index); + + +/* These marker codes are exported since applications and data source modules + * are likely to want to use them. + */ + +#define JPEG_RST0 0xD0 /* RST0 marker code */ +#define JPEG_EOI 0xD9 /* EOI marker code */ +#define JPEG_APP0 0xE0 /* APP0 marker code */ +#define JPEG_COM 0xFE /* COM marker code */ + + +/* If we have a brain-damaged compiler that emits warnings (or worse, errors) + * for structure definitions that are never filled in, keep it quiet by + * supplying dummy definitions for the various substructures. + */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ +struct jvirt_sarray_control { long dummy; }; +struct jvirt_barray_control { long dummy; }; +struct jpeg_comp_master { long dummy; }; +struct jpeg_c_main_controller { long dummy; }; +struct jpeg_c_prep_controller { long dummy; }; +struct jpeg_c_coef_controller { long dummy; }; +struct jpeg_marker_writer { long dummy; }; +struct jpeg_color_converter { long dummy; }; +struct jpeg_downsampler { long dummy; }; +struct jpeg_forward_dct { long dummy; }; +struct jpeg_entropy_encoder { long dummy; }; +struct jpeg_decomp_master { long dummy; }; +struct jpeg_d_main_controller { long dummy; }; +struct jpeg_d_coef_controller { long dummy; }; +struct jpeg_d_post_controller { long dummy; }; +struct jpeg_input_controller { long dummy; }; +struct jpeg_marker_reader { long dummy; }; +struct jpeg_entropy_decoder { long dummy; }; +struct jpeg_inverse_dct { long dummy; }; +struct jpeg_upsampler { long dummy; }; +struct jpeg_color_deconverter { long dummy; }; +struct jpeg_color_quantizer { long dummy; }; +#endif /* JPEG_INTERNALS */ +#endif /* INCOMPLETE_TYPES_BROKEN */ + + +/* + * The JPEG library modules define JPEG_INTERNALS before including this file. + * The internal structure declarations are read only when that is true. + * Applications using the library should not include jpegint.h, but may wish + * to include jerror.h. + */ + +#ifdef JPEG_INTERNALS +#include "jpegint.h" /* fetch private declarations */ +#include "jerror.h" /* fetch error codes too */ +#endif + +#endif /* JPEGLIB_H */ diff --git a/TMessagesProj/jni/libjpeg/jquant1.c b/TMessagesProj/jni/libjpeg/jquant1.c new file mode 100755 index 000000000..b2f96aa15 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jquant1.c @@ -0,0 +1,856 @@ +/* + * jquant1.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains 1-pass color quantization (color mapping) routines. + * These routines provide mapping to a fixed color map using equally spaced + * color values. Optional Floyd-Steinberg or ordered dithering is available. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + +#ifdef QUANT_1PASS_SUPPORTED + + +/* + * The main purpose of 1-pass quantization is to provide a fast, if not very + * high quality, colormapped output capability. A 2-pass quantizer usually + * gives better visual quality; however, for quantized grayscale output this + * quantizer is perfectly adequate. Dithering is highly recommended with this + * quantizer, though you can turn it off if you really want to. + * + * In 1-pass quantization the colormap must be chosen in advance of seeing the + * image. We use a map consisting of all combinations of Ncolors[i] color + * values for the i'th component. The Ncolors[] values are chosen so that + * their product, the total number of colors, is no more than that requested. + * (In most cases, the product will be somewhat less.) + * + * Since the colormap is orthogonal, the representative value for each color + * component can be determined without considering the other components; + * then these indexes can be combined into a colormap index by a standard + * N-dimensional-array-subscript calculation. Most of the arithmetic involved + * can be precalculated and stored in the lookup table colorindex[]. + * colorindex[i][j] maps pixel value j in component i to the nearest + * representative value (grid plane) for that component; this index is + * multiplied by the array stride for component i, so that the + * index of the colormap entry closest to a given pixel value is just + * sum( colorindex[component-number][pixel-component-value] ) + * Aside from being fast, this scheme allows for variable spacing between + * representative values with no additional lookup cost. + * + * If gamma correction has been applied in color conversion, it might be wise + * to adjust the color grid spacing so that the representative colors are + * equidistant in linear space. At this writing, gamma correction is not + * implemented by jdcolor, so nothing is done here. + */ + + +/* Declarations for ordered dithering. + * + * We use a standard 16x16 ordered dither array. The basic concept of ordered + * dithering is described in many references, for instance Dale Schumacher's + * chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991). + * In place of Schumacher's comparisons against a "threshold" value, we add a + * "dither" value to the input pixel and then round the result to the nearest + * output value. The dither value is equivalent to (0.5 - threshold) times + * the distance between output values. For ordered dithering, we assume that + * the output colors are equally spaced; if not, results will probably be + * worse, since the dither may be too much or too little at a given point. + * + * The normal calculation would be to form pixel value + dither, range-limit + * this to 0..MAXJSAMPLE, and then index into the colorindex table as usual. + * We can skip the separate range-limiting step by extending the colorindex + * table in both directions. + */ + +#define ODITHER_SIZE 16 /* dimension of dither matrix */ +/* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */ +#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE) /* # cells in matrix */ +#define ODITHER_MASK (ODITHER_SIZE-1) /* mask for wrapping around counters */ + +typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE]; +typedef int (*ODITHER_MATRIX_PTR)[ODITHER_SIZE]; + +static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = { + /* Bayer's order-4 dither array. Generated by the code given in + * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I. + * The values in this array must range from 0 to ODITHER_CELLS-1. + */ + { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 }, + { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 }, + { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 }, + { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 }, + { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 }, + { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 }, + { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 }, + { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 }, + { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 }, + { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 }, + { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 }, + { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 }, + { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 }, + { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 }, + { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 }, + { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 } +}; + + +/* Declarations for Floyd-Steinberg dithering. + * + * Errors are accumulated into the array fserrors[], at a resolution of + * 1/16th of a pixel count. The error at a given pixel is propagated + * to its not-yet-processed neighbors using the standard F-S fractions, + * ... (here) 7/16 + * 3/16 5/16 1/16 + * We work left-to-right on even rows, right-to-left on odd rows. + * + * We can get away with a single array (holding one row's worth of errors) + * by using it to store the current row's errors at pixel columns not yet + * processed, but the next row's errors at columns already processed. We + * need only a few extra variables to hold the errors immediately around the + * current column. (If we are lucky, those variables are in registers, but + * even if not, they're probably cheaper to access than array elements are.) + * + * The fserrors[] array is indexed [component#][position]. + * We provide (#columns + 2) entries per component; the extra entry at each + * end saves us from special-casing the first and last pixels. + * + * Note: on a wide image, we might not have enough room in a PC's near data + * segment to hold the error array; so it is allocated with alloc_large. + */ + +#if BITS_IN_JSAMPLE == 8 +typedef INT16 FSERROR; /* 16 bits should be enough */ +typedef int LOCFSERROR; /* use 'int' for calculation temps */ +#else +typedef INT32 FSERROR; /* may need more than 16 bits */ +typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */ +#endif + +typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */ + + +/* Private subobject */ + +#define MAX_Q_COMPS 4 /* max components I can handle */ + +typedef struct { + struct jpeg_color_quantizer pub; /* public fields */ + + /* Initially allocated colormap is saved here */ + JSAMPARRAY sv_colormap; /* The color map as a 2-D pixel array */ + int sv_actual; /* number of entries in use */ + + JSAMPARRAY colorindex; /* Precomputed mapping for speed */ + /* colorindex[i][j] = index of color closest to pixel value j in component i, + * premultiplied as described above. Since colormap indexes must fit into + * JSAMPLEs, the entries of this array will too. + */ + boolean is_padded; /* is the colorindex padded for odither? */ + + int Ncolors[MAX_Q_COMPS]; /* # of values alloced to each component */ + + /* Variables for ordered dithering */ + int row_index; /* cur row's vertical index in dither matrix */ + ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */ + + /* Variables for Floyd-Steinberg dithering */ + FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */ + boolean on_odd_row; /* flag to remember which row we are on */ +} my_cquantizer; + +typedef my_cquantizer * my_cquantize_ptr; + + +/* + * Policy-making subroutines for create_colormap and create_colorindex. + * These routines determine the colormap to be used. The rest of the module + * only assumes that the colormap is orthogonal. + * + * * select_ncolors decides how to divvy up the available colors + * among the components. + * * output_value defines the set of representative values for a component. + * * largest_input_value defines the mapping from input values to + * representative values for a component. + * Note that the latter two routines may impose different policies for + * different components, though this is not currently done. + */ + + +LOCAL(int) +select_ncolors (j_decompress_ptr cinfo, int Ncolors[]) +/* Determine allocation of desired colors to components, */ +/* and fill in Ncolors[] array to indicate choice. */ +/* Return value is total number of colors (product of Ncolors[] values). */ +{ + int nc = cinfo->out_color_components; /* number of color components */ + int max_colors = cinfo->desired_number_of_colors; + int total_colors, iroot, i, j; + boolean changed; + long temp; + static const int RGB_order[3] = { RGB_GREEN, RGB_RED, RGB_BLUE }; + + /* We can allocate at least the nc'th root of max_colors per component. */ + /* Compute floor(nc'th root of max_colors). */ + iroot = 1; + do { + iroot++; + temp = iroot; /* set temp = iroot ** nc */ + for (i = 1; i < nc; i++) + temp *= iroot; + } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */ + iroot--; /* now iroot = floor(root) */ + + /* Must have at least 2 color values per component */ + if (iroot < 2) + ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, (int) temp); + + /* Initialize to iroot color values for each component */ + total_colors = 1; + for (i = 0; i < nc; i++) { + Ncolors[i] = iroot; + total_colors *= iroot; + } + /* We may be able to increment the count for one or more components without + * exceeding max_colors, though we know not all can be incremented. + * Sometimes, the first component can be incremented more than once! + * (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.) + * In RGB colorspace, try to increment G first, then R, then B. + */ + do { + changed = FALSE; + for (i = 0; i < nc; i++) { + j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i); + /* calculate new total_colors if Ncolors[j] is incremented */ + temp = total_colors / Ncolors[j]; + temp *= Ncolors[j]+1; /* done in long arith to avoid oflo */ + if (temp > (long) max_colors) + break; /* won't fit, done with this pass */ + Ncolors[j]++; /* OK, apply the increment */ + total_colors = (int) temp; + changed = TRUE; + } + } while (changed); + + return total_colors; +} + + +LOCAL(int) +output_value (j_decompress_ptr cinfo, int ci, int j, int maxj) +/* Return j'th output value, where j will range from 0 to maxj */ +/* The output values must fall in 0..MAXJSAMPLE in increasing order */ +{ + /* We always provide values 0 and MAXJSAMPLE for each component; + * any additional values are equally spaced between these limits. + * (Forcing the upper and lower values to the limits ensures that + * dithering can't produce a color outside the selected gamut.) + */ + return (int) (((INT32) j * MAXJSAMPLE + maxj/2) / maxj); +} + + +LOCAL(int) +largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj) +/* Return largest input value that should map to j'th output value */ +/* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */ +{ + /* Breakpoints are halfway between values returned by output_value */ + return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj)); +} + + +/* + * Create the colormap. + */ + +LOCAL(void) +create_colormap (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + JSAMPARRAY colormap; /* Created colormap */ + int total_colors; /* Number of distinct output colors */ + int i,j,k, nci, blksize, blkdist, ptr, val; + + /* Select number of colors for each component */ + total_colors = select_ncolors(cinfo, cquantize->Ncolors); + + /* Report selected color counts */ + if (cinfo->out_color_components == 3) + TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS, + total_colors, cquantize->Ncolors[0], + cquantize->Ncolors[1], cquantize->Ncolors[2]); + else + TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors); + + /* Allocate and fill in the colormap. */ + /* The colors are ordered in the map in standard row-major order, */ + /* i.e. rightmost (highest-indexed) color changes most rapidly. */ + + colormap = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components); + + /* blksize is number of adjacent repeated entries for a component */ + /* blkdist is distance between groups of identical entries for a component */ + blkdist = total_colors; + + for (i = 0; i < cinfo->out_color_components; i++) { + /* fill in colormap entries for i'th color component */ + nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ + blksize = blkdist / nci; + for (j = 0; j < nci; j++) { + /* Compute j'th output value (out of nci) for component */ + val = output_value(cinfo, i, j, nci-1); + /* Fill in all colormap entries that have this value of this component */ + for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) { + /* fill in blksize entries beginning at ptr */ + for (k = 0; k < blksize; k++) + colormap[i][ptr+k] = (JSAMPLE) val; + } + } + blkdist = blksize; /* blksize of this color is blkdist of next */ + } + + /* Save the colormap in private storage, + * where it will survive color quantization mode changes. + */ + cquantize->sv_colormap = colormap; + cquantize->sv_actual = total_colors; +} + + +/* + * Create the color index table. + */ + +LOCAL(void) +create_colorindex (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + JSAMPROW indexptr; + int i,j,k, nci, blksize, val, pad; + + /* For ordered dither, we pad the color index tables by MAXJSAMPLE in + * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE). + * This is not necessary in the other dithering modes. However, we + * flag whether it was done in case user changes dithering mode. + */ + if (cinfo->dither_mode == JDITHER_ORDERED) { + pad = MAXJSAMPLE*2; + cquantize->is_padded = TRUE; + } else { + pad = 0; + cquantize->is_padded = FALSE; + } + + cquantize->colorindex = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (JDIMENSION) (MAXJSAMPLE+1 + pad), + (JDIMENSION) cinfo->out_color_components); + + /* blksize is number of adjacent repeated entries for a component */ + blksize = cquantize->sv_actual; + + for (i = 0; i < cinfo->out_color_components; i++) { + /* fill in colorindex entries for i'th color component */ + nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ + blksize = blksize / nci; + + /* adjust colorindex pointers to provide padding at negative indexes. */ + if (pad) + cquantize->colorindex[i] += MAXJSAMPLE; + + /* in loop, val = index of current output value, */ + /* and k = largest j that maps to current val */ + indexptr = cquantize->colorindex[i]; + val = 0; + k = largest_input_value(cinfo, i, 0, nci-1); + for (j = 0; j <= MAXJSAMPLE; j++) { + while (j > k) /* advance val if past boundary */ + k = largest_input_value(cinfo, i, ++val, nci-1); + /* premultiply so that no multiplication needed in main processing */ + indexptr[j] = (JSAMPLE) (val * blksize); + } + /* Pad at both ends if necessary */ + if (pad) + for (j = 1; j <= MAXJSAMPLE; j++) { + indexptr[-j] = indexptr[0]; + indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE]; + } + } +} + + +/* + * Create an ordered-dither array for a component having ncolors + * distinct output values. + */ + +LOCAL(ODITHER_MATRIX_PTR) +make_odither_array (j_decompress_ptr cinfo, int ncolors) +{ + ODITHER_MATRIX_PTR odither; + int j,k; + INT32 num,den; + + odither = (ODITHER_MATRIX_PTR) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(ODITHER_MATRIX)); + /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1). + * Hence the dither value for the matrix cell with fill order f + * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1). + * On 16-bit-int machine, be careful to avoid overflow. + */ + den = 2 * ODITHER_CELLS * ((INT32) (ncolors - 1)); + for (j = 0; j < ODITHER_SIZE; j++) { + for (k = 0; k < ODITHER_SIZE; k++) { + num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k]))) + * MAXJSAMPLE; + /* Ensure round towards zero despite C's lack of consistency + * about rounding negative values in integer division... + */ + odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den); + } + } + return odither; +} + + +/* + * Create the ordered-dither tables. + * Components having the same number of representative colors may + * share a dither table. + */ + +LOCAL(void) +create_odither_tables (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + ODITHER_MATRIX_PTR odither; + int i, j, nci; + + for (i = 0; i < cinfo->out_color_components; i++) { + nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ + odither = NULL; /* search for matching prior component */ + for (j = 0; j < i; j++) { + if (nci == cquantize->Ncolors[j]) { + odither = cquantize->odither[j]; + break; + } + } + if (odither == NULL) /* need a new table? */ + odither = make_odither_array(cinfo, nci); + cquantize->odither[i] = odither; + } +} + + +/* + * Map some rows of pixels to the output colormapped representation. + */ + +METHODDEF(void) +color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) +/* General case, no dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + JSAMPARRAY colorindex = cquantize->colorindex; + register int pixcode, ci; + register JSAMPROW ptrin, ptrout; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + register int nc = cinfo->out_color_components; + + for (row = 0; row < num_rows; row++) { + ptrin = input_buf[row]; + ptrout = output_buf[row]; + for (col = width; col > 0; col--) { + pixcode = 0; + for (ci = 0; ci < nc; ci++) { + pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]); + } + *ptrout++ = (JSAMPLE) pixcode; + } + } +} + + +METHODDEF(void) +color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) +/* Fast path for out_color_components==3, no dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + register int pixcode; + register JSAMPROW ptrin, ptrout; + JSAMPROW colorindex0 = cquantize->colorindex[0]; + JSAMPROW colorindex1 = cquantize->colorindex[1]; + JSAMPROW colorindex2 = cquantize->colorindex[2]; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + + for (row = 0; row < num_rows; row++) { + ptrin = input_buf[row]; + ptrout = output_buf[row]; + for (col = width; col > 0; col--) { + pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*ptrin++)]); + pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*ptrin++)]); + pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*ptrin++)]); + *ptrout++ = (JSAMPLE) pixcode; + } + } +} + + +METHODDEF(void) +quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) +/* General case, with ordered dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + register JSAMPROW input_ptr; + register JSAMPROW output_ptr; + JSAMPROW colorindex_ci; + int * dither; /* points to active row of dither matrix */ + int row_index, col_index; /* current indexes into dither matrix */ + int nc = cinfo->out_color_components; + int ci; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + + for (row = 0; row < num_rows; row++) { + /* Initialize output values to 0 so can process components separately */ + jzero_far((void FAR *) output_buf[row], + (size_t) (width * SIZEOF(JSAMPLE))); + row_index = cquantize->row_index; + for (ci = 0; ci < nc; ci++) { + input_ptr = input_buf[row] + ci; + output_ptr = output_buf[row]; + colorindex_ci = cquantize->colorindex[ci]; + dither = cquantize->odither[ci][row_index]; + col_index = 0; + + for (col = width; col > 0; col--) { + /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE, + * select output value, accumulate into output code for this pixel. + * Range-limiting need not be done explicitly, as we have extended + * the colorindex table to produce the right answers for out-of-range + * inputs. The maximum dither is +- MAXJSAMPLE; this sets the + * required amount of padding. + */ + *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]]; + input_ptr += nc; + output_ptr++; + col_index = (col_index + 1) & ODITHER_MASK; + } + } + /* Advance row index for next row */ + row_index = (row_index + 1) & ODITHER_MASK; + cquantize->row_index = row_index; + } +} + + +METHODDEF(void) +quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) +/* Fast path for out_color_components==3, with ordered dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + register int pixcode; + register JSAMPROW input_ptr; + register JSAMPROW output_ptr; + JSAMPROW colorindex0 = cquantize->colorindex[0]; + JSAMPROW colorindex1 = cquantize->colorindex[1]; + JSAMPROW colorindex2 = cquantize->colorindex[2]; + int * dither0; /* points to active row of dither matrix */ + int * dither1; + int * dither2; + int row_index, col_index; /* current indexes into dither matrix */ + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + + for (row = 0; row < num_rows; row++) { + row_index = cquantize->row_index; + input_ptr = input_buf[row]; + output_ptr = output_buf[row]; + dither0 = cquantize->odither[0][row_index]; + dither1 = cquantize->odither[1][row_index]; + dither2 = cquantize->odither[2][row_index]; + col_index = 0; + + for (col = width; col > 0; col--) { + pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) + + dither0[col_index]]); + pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) + + dither1[col_index]]); + pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) + + dither2[col_index]]); + *output_ptr++ = (JSAMPLE) pixcode; + col_index = (col_index + 1) & ODITHER_MASK; + } + row_index = (row_index + 1) & ODITHER_MASK; + cquantize->row_index = row_index; + } +} + + +METHODDEF(void) +quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, + JSAMPARRAY output_buf, int num_rows) +/* General case, with Floyd-Steinberg dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + register LOCFSERROR cur; /* current error or pixel value */ + LOCFSERROR belowerr; /* error for pixel below cur */ + LOCFSERROR bpreverr; /* error for below/prev col */ + LOCFSERROR bnexterr; /* error for below/next col */ + LOCFSERROR delta; + register FSERRPTR errorptr; /* => fserrors[] at column before current */ + register JSAMPROW input_ptr; + register JSAMPROW output_ptr; + JSAMPROW colorindex_ci; + JSAMPROW colormap_ci; + int pixcode; + int nc = cinfo->out_color_components; + int dir; /* 1 for left-to-right, -1 for right-to-left */ + int dirnc; /* dir * nc */ + int ci; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + JSAMPLE *range_limit = cinfo->sample_range_limit; + SHIFT_TEMPS + + for (row = 0; row < num_rows; row++) { + /* Initialize output values to 0 so can process components separately */ + jzero_far((void FAR *) output_buf[row], + (size_t) (width * SIZEOF(JSAMPLE))); + for (ci = 0; ci < nc; ci++) { + input_ptr = input_buf[row] + ci; + output_ptr = output_buf[row]; + if (cquantize->on_odd_row) { + /* work right to left in this row */ + input_ptr += (width-1) * nc; /* so point to rightmost pixel */ + output_ptr += width-1; + dir = -1; + dirnc = -nc; + errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */ + } else { + /* work left to right in this row */ + dir = 1; + dirnc = nc; + errorptr = cquantize->fserrors[ci]; /* => entry before first column */ + } + colorindex_ci = cquantize->colorindex[ci]; + colormap_ci = cquantize->sv_colormap[ci]; + /* Preset error values: no error propagated to first pixel from left */ + cur = 0; + /* and no error propagated to row below yet */ + belowerr = bpreverr = 0; + + for (col = width; col > 0; col--) { + /* cur holds the error propagated from the previous pixel on the + * current line. Add the error propagated from the previous line + * to form the complete error correction term for this pixel, and + * round the error term (which is expressed * 16) to an integer. + * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct + * for either sign of the error value. + * Note: errorptr points to *previous* column's array entry. + */ + cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4); + /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. + * The maximum error is +- MAXJSAMPLE; this sets the required size + * of the range_limit array. + */ + cur += GETJSAMPLE(*input_ptr); + cur = GETJSAMPLE(range_limit[cur]); + /* Select output value, accumulate into output code for this pixel */ + pixcode = GETJSAMPLE(colorindex_ci[cur]); + *output_ptr += (JSAMPLE) pixcode; + /* Compute actual representation error at this pixel */ + /* Note: we can do this even though we don't have the final */ + /* pixel code, because the colormap is orthogonal. */ + cur -= GETJSAMPLE(colormap_ci[pixcode]); + /* Compute error fractions to be propagated to adjacent pixels. + * Add these into the running sums, and simultaneously shift the + * next-line error sums left by 1 column. + */ + bnexterr = cur; + delta = cur * 2; + cur += delta; /* form error * 3 */ + errorptr[0] = (FSERROR) (bpreverr + cur); + cur += delta; /* form error * 5 */ + bpreverr = belowerr + cur; + belowerr = bnexterr; + cur += delta; /* form error * 7 */ + /* At this point cur contains the 7/16 error value to be propagated + * to the next pixel on the current line, and all the errors for the + * next line have been shifted over. We are therefore ready to move on. + */ + input_ptr += dirnc; /* advance input ptr to next column */ + output_ptr += dir; /* advance output ptr to next column */ + errorptr += dir; /* advance errorptr to current column */ + } + /* Post-loop cleanup: we must unload the final error value into the + * final fserrors[] entry. Note we need not unload belowerr because + * it is for the dummy column before or after the actual array. + */ + errorptr[0] = (FSERROR) bpreverr; /* unload prev err into array */ + } + cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE); + } +} + + +/* + * Allocate workspace for Floyd-Steinberg errors. + */ + +LOCAL(void) +alloc_fs_workspace (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + size_t arraysize; + int i; + + arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR)); + for (i = 0; i < cinfo->out_color_components; i++) { + cquantize->fserrors[i] = (FSERRPTR) + (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize); + } +} + + +/* + * Initialize for one-pass color quantization. + */ + +METHODDEF(void) +start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + size_t arraysize; + int i; + + /* Install my colormap. */ + cinfo->colormap = cquantize->sv_colormap; + cinfo->actual_number_of_colors = cquantize->sv_actual; + + /* Initialize for desired dithering mode. */ + switch (cinfo->dither_mode) { + case JDITHER_NONE: + if (cinfo->out_color_components == 3) + cquantize->pub.color_quantize = color_quantize3; + else + cquantize->pub.color_quantize = color_quantize; + break; + case JDITHER_ORDERED: + if (cinfo->out_color_components == 3) + cquantize->pub.color_quantize = quantize3_ord_dither; + else + cquantize->pub.color_quantize = quantize_ord_dither; + cquantize->row_index = 0; /* initialize state for ordered dither */ + /* If user changed to ordered dither from another mode, + * we must recreate the color index table with padding. + * This will cost extra space, but probably isn't very likely. + */ + if (! cquantize->is_padded) + create_colorindex(cinfo); + /* Create ordered-dither tables if we didn't already. */ + if (cquantize->odither[0] == NULL) + create_odither_tables(cinfo); + break; + case JDITHER_FS: + cquantize->pub.color_quantize = quantize_fs_dither; + cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */ + /* Allocate Floyd-Steinberg workspace if didn't already. */ + if (cquantize->fserrors[0] == NULL) + alloc_fs_workspace(cinfo); + /* Initialize the propagated errors to zero. */ + arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR)); + for (i = 0; i < cinfo->out_color_components; i++) + jzero_far((void FAR *) cquantize->fserrors[i], arraysize); + break; + default: + ERREXIT(cinfo, JERR_NOT_COMPILED); + break; + } +} + + +/* + * Finish up at the end of the pass. + */ + +METHODDEF(void) +finish_pass_1_quant (j_decompress_ptr cinfo) +{ + /* no work in 1-pass case */ +} + + +/* + * Switch to a new external colormap between output passes. + * Shouldn't get to this module! + */ + +METHODDEF(void) +new_color_map_1_quant (j_decompress_ptr cinfo) +{ + ERREXIT(cinfo, JERR_MODE_CHANGE); +} + + +/* + * Module initialization routine for 1-pass color quantization. + */ + +GLOBAL(void) +jinit_1pass_quantizer (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize; + + cquantize = (my_cquantize_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_cquantizer)); + cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize; + cquantize->pub.start_pass = start_pass_1_quant; + cquantize->pub.finish_pass = finish_pass_1_quant; + cquantize->pub.new_color_map = new_color_map_1_quant; + cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */ + cquantize->odither[0] = NULL; /* Also flag odither arrays not allocated */ + + /* Make sure my internal arrays won't overflow */ + if (cinfo->out_color_components > MAX_Q_COMPS) + ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS); + /* Make sure colormap indexes can be represented by JSAMPLEs */ + if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1)) + ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1); + + /* Create the colormap and color index table. */ + create_colormap(cinfo); + create_colorindex(cinfo); + + /* Allocate Floyd-Steinberg workspace now if requested. + * We do this now since it is FAR storage and may affect the memory + * manager's space calculations. If the user changes to FS dither + * mode in a later pass, we will allocate the space then, and will + * possibly overrun the max_memory_to_use setting. + */ + if (cinfo->dither_mode == JDITHER_FS) + alloc_fs_workspace(cinfo); +} + +#endif /* QUANT_1PASS_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jquant2.c b/TMessagesProj/jni/libjpeg/jquant2.c new file mode 100755 index 000000000..af601e334 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jquant2.c @@ -0,0 +1,1310 @@ +/* + * jquant2.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains 2-pass color quantization (color mapping) routines. + * These routines provide selection of a custom color map for an image, + * followed by mapping of the image to that color map, with optional + * Floyd-Steinberg dithering. + * It is also possible to use just the second pass to map to an arbitrary + * externally-given color map. + * + * Note: ordered dithering is not supported, since there isn't any fast + * way to compute intercolor distances; it's unclear that ordered dither's + * fundamental assumptions even hold with an irregularly spaced color map. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + +#ifdef QUANT_2PASS_SUPPORTED + + +/* + * This module implements the well-known Heckbert paradigm for color + * quantization. Most of the ideas used here can be traced back to + * Heckbert's seminal paper + * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display", + * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304. + * + * In the first pass over the image, we accumulate a histogram showing the + * usage count of each possible color. To keep the histogram to a reasonable + * size, we reduce the precision of the input; typical practice is to retain + * 5 or 6 bits per color, so that 8 or 4 different input values are counted + * in the same histogram cell. + * + * Next, the color-selection step begins with a box representing the whole + * color space, and repeatedly splits the "largest" remaining box until we + * have as many boxes as desired colors. Then the mean color in each + * remaining box becomes one of the possible output colors. + * + * The second pass over the image maps each input pixel to the closest output + * color (optionally after applying a Floyd-Steinberg dithering correction). + * This mapping is logically trivial, but making it go fast enough requires + * considerable care. + * + * Heckbert-style quantizers vary a good deal in their policies for choosing + * the "largest" box and deciding where to cut it. The particular policies + * used here have proved out well in experimental comparisons, but better ones + * may yet be found. + * + * In earlier versions of the IJG code, this module quantized in YCbCr color + * space, processing the raw upsampled data without a color conversion step. + * This allowed the color conversion math to be done only once per colormap + * entry, not once per pixel. However, that optimization precluded other + * useful optimizations (such as merging color conversion with upsampling) + * and it also interfered with desired capabilities such as quantizing to an + * externally-supplied colormap. We have therefore abandoned that approach. + * The present code works in the post-conversion color space, typically RGB. + * + * To improve the visual quality of the results, we actually work in scaled + * RGB space, giving G distances more weight than R, and R in turn more than + * B. To do everything in integer math, we must use integer scale factors. + * The 2/3/1 scale factors used here correspond loosely to the relative + * weights of the colors in the NTSC grayscale equation. + * If you want to use this code to quantize a non-RGB color space, you'll + * probably need to change these scale factors. + */ + +#define R_SCALE 2 /* scale R distances by this much */ +#define G_SCALE 3 /* scale G distances by this much */ +#define B_SCALE 1 /* and B by this much */ + +/* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined + * in jmorecfg.h. As the code stands, it will do the right thing for R,G,B + * and B,G,R orders. If you define some other weird order in jmorecfg.h, + * you'll get compile errors until you extend this logic. In that case + * you'll probably want to tweak the histogram sizes too. + */ + +#if RGB_RED == 0 +#define C0_SCALE R_SCALE +#endif +#if RGB_BLUE == 0 +#define C0_SCALE B_SCALE +#endif +#if RGB_GREEN == 1 +#define C1_SCALE G_SCALE +#endif +#if RGB_RED == 2 +#define C2_SCALE R_SCALE +#endif +#if RGB_BLUE == 2 +#define C2_SCALE B_SCALE +#endif + + +/* + * First we have the histogram data structure and routines for creating it. + * + * The number of bits of precision can be adjusted by changing these symbols. + * We recommend keeping 6 bits for G and 5 each for R and B. + * If you have plenty of memory and cycles, 6 bits all around gives marginally + * better results; if you are short of memory, 5 bits all around will save + * some space but degrade the results. + * To maintain a fully accurate histogram, we'd need to allocate a "long" + * (preferably unsigned long) for each cell. In practice this is overkill; + * we can get by with 16 bits per cell. Few of the cell counts will overflow, + * and clamping those that do overflow to the maximum value will give close- + * enough results. This reduces the recommended histogram size from 256Kb + * to 128Kb, which is a useful savings on PC-class machines. + * (In the second pass the histogram space is re-used for pixel mapping data; + * in that capacity, each cell must be able to store zero to the number of + * desired colors. 16 bits/cell is plenty for that too.) + * Since the JPEG code is intended to run in small memory model on 80x86 + * machines, we can't just allocate the histogram in one chunk. Instead + * of a true 3-D array, we use a row of pointers to 2-D arrays. Each + * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and + * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that + * on 80x86 machines, the pointer row is in near memory but the actual + * arrays are in far memory (same arrangement as we use for image arrays). + */ + +#define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */ + +/* These will do the right thing for either R,G,B or B,G,R color order, + * but you may not like the results for other color orders. + */ +#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */ +#define HIST_C1_BITS 6 /* bits of precision in G histogram */ +#define HIST_C2_BITS 5 /* bits of precision in B/R histogram */ + +/* Number of elements along histogram axes. */ +#define HIST_C0_ELEMS (1<cquantize; + register JSAMPROW ptr; + register histptr histp; + register hist3d histogram = cquantize->histogram; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + + for (row = 0; row < num_rows; row++) { + ptr = input_buf[row]; + for (col = width; col > 0; col--) { + /* get pixel value and index into the histogram */ + histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT] + [GETJSAMPLE(ptr[1]) >> C1_SHIFT] + [GETJSAMPLE(ptr[2]) >> C2_SHIFT]; + /* increment, check for overflow and undo increment if so. */ + if (++(*histp) <= 0) + (*histp)--; + ptr += 3; + } + } +} + + +/* + * Next we have the really interesting routines: selection of a colormap + * given the completed histogram. + * These routines work with a list of "boxes", each representing a rectangular + * subset of the input color space (to histogram precision). + */ + +typedef struct { + /* The bounds of the box (inclusive); expressed as histogram indexes */ + int c0min, c0max; + int c1min, c1max; + int c2min, c2max; + /* The volume (actually 2-norm) of the box */ + INT32 volume; + /* The number of nonzero histogram cells within this box */ + long colorcount; +} box; + +typedef box * boxptr; + + +LOCAL(boxptr) +find_biggest_color_pop (boxptr boxlist, int numboxes) +/* Find the splittable box with the largest color population */ +/* Returns NULL if no splittable boxes remain */ +{ + register boxptr boxp; + register int i; + register long maxc = 0; + boxptr which = NULL; + + for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { + if (boxp->colorcount > maxc && boxp->volume > 0) { + which = boxp; + maxc = boxp->colorcount; + } + } + return which; +} + + +LOCAL(boxptr) +find_biggest_volume (boxptr boxlist, int numboxes) +/* Find the splittable box with the largest (scaled) volume */ +/* Returns NULL if no splittable boxes remain */ +{ + register boxptr boxp; + register int i; + register INT32 maxv = 0; + boxptr which = NULL; + + for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { + if (boxp->volume > maxv) { + which = boxp; + maxv = boxp->volume; + } + } + return which; +} + + +LOCAL(void) +update_box (j_decompress_ptr cinfo, boxptr boxp) +/* Shrink the min/max bounds of a box to enclose only nonzero elements, */ +/* and recompute its volume and population */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + histptr histp; + int c0,c1,c2; + int c0min,c0max,c1min,c1max,c2min,c2max; + INT32 dist0,dist1,dist2; + long ccount; + + c0min = boxp->c0min; c0max = boxp->c0max; + c1min = boxp->c1min; c1max = boxp->c1max; + c2min = boxp->c2min; c2max = boxp->c2max; + + if (c0max > c0min) + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c0min = c0min = c0; + goto have_c0min; + } + } + have_c0min: + if (c0max > c0min) + for (c0 = c0max; c0 >= c0min; c0--) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c0max = c0max = c0; + goto have_c0max; + } + } + have_c0max: + if (c1max > c1min) + for (c1 = c1min; c1 <= c1max; c1++) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c1min = c1min = c1; + goto have_c1min; + } + } + have_c1min: + if (c1max > c1min) + for (c1 = c1max; c1 >= c1min; c1--) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c1max = c1max = c1; + goto have_c1max; + } + } + have_c1max: + if (c2max > c2min) + for (c2 = c2min; c2 <= c2max; c2++) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = & histogram[c0][c1min][c2]; + for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) + if (*histp != 0) { + boxp->c2min = c2min = c2; + goto have_c2min; + } + } + have_c2min: + if (c2max > c2min) + for (c2 = c2max; c2 >= c2min; c2--) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = & histogram[c0][c1min][c2]; + for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) + if (*histp != 0) { + boxp->c2max = c2max = c2; + goto have_c2max; + } + } + have_c2max: + + /* Update box volume. + * We use 2-norm rather than real volume here; this biases the method + * against making long narrow boxes, and it has the side benefit that + * a box is splittable iff norm > 0. + * Since the differences are expressed in histogram-cell units, + * we have to shift back to JSAMPLE units to get consistent distances; + * after which, we scale according to the selected distance scale factors. + */ + dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE; + dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE; + dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE; + boxp->volume = dist0*dist0 + dist1*dist1 + dist2*dist2; + + /* Now scan remaining volume of box and compute population */ + ccount = 0; + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++, histp++) + if (*histp != 0) { + ccount++; + } + } + boxp->colorcount = ccount; +} + + +LOCAL(int) +median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, + int desired_colors) +/* Repeatedly select and split the largest box until we have enough boxes */ +{ + int n,lb; + int c0,c1,c2,cmax; + register boxptr b1,b2; + + while (numboxes < desired_colors) { + /* Select box to split. + * Current algorithm: by population for first half, then by volume. + */ + if (numboxes*2 <= desired_colors) { + b1 = find_biggest_color_pop(boxlist, numboxes); + } else { + b1 = find_biggest_volume(boxlist, numboxes); + } + if (b1 == NULL) /* no splittable boxes left! */ + break; + b2 = &boxlist[numboxes]; /* where new box will go */ + /* Copy the color bounds to the new box. */ + b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max; + b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min; + /* Choose which axis to split the box on. + * Current algorithm: longest scaled axis. + * See notes in update_box about scaling distances. + */ + c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE; + c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE; + c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE; + /* We want to break any ties in favor of green, then red, blue last. + * This code does the right thing for R,G,B or B,G,R color orders only. + */ +#if RGB_RED == 0 + cmax = c1; n = 1; + if (c0 > cmax) { cmax = c0; n = 0; } + if (c2 > cmax) { n = 2; } +#else + cmax = c1; n = 1; + if (c2 > cmax) { cmax = c2; n = 2; } + if (c0 > cmax) { n = 0; } +#endif + /* Choose split point along selected axis, and update box bounds. + * Current algorithm: split at halfway point. + * (Since the box has been shrunk to minimum volume, + * any split will produce two nonempty subboxes.) + * Note that lb value is max for lower box, so must be < old max. + */ + switch (n) { + case 0: + lb = (b1->c0max + b1->c0min) / 2; + b1->c0max = lb; + b2->c0min = lb+1; + break; + case 1: + lb = (b1->c1max + b1->c1min) / 2; + b1->c1max = lb; + b2->c1min = lb+1; + break; + case 2: + lb = (b1->c2max + b1->c2min) / 2; + b1->c2max = lb; + b2->c2min = lb+1; + break; + } + /* Update stats for boxes */ + update_box(cinfo, b1); + update_box(cinfo, b2); + numboxes++; + } + return numboxes; +} + + +LOCAL(void) +compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor) +/* Compute representative color for a box, put it in colormap[icolor] */ +{ + /* Current algorithm: mean weighted by pixels (not colors) */ + /* Note it is important to get the rounding correct! */ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + histptr histp; + int c0,c1,c2; + int c0min,c0max,c1min,c1max,c2min,c2max; + long count; + long total = 0; + long c0total = 0; + long c1total = 0; + long c2total = 0; + + c0min = boxp->c0min; c0max = boxp->c0max; + c1min = boxp->c1min; c1max = boxp->c1max; + c2min = boxp->c2min; c2max = boxp->c2max; + + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = & histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) { + if ((count = *histp++) != 0) { + total += count; + c0total += ((c0 << C0_SHIFT) + ((1<>1)) * count; + c1total += ((c1 << C1_SHIFT) + ((1<>1)) * count; + c2total += ((c2 << C2_SHIFT) + ((1<>1)) * count; + } + } + } + + cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total); + cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total); + cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total); +} + + +LOCAL(void) +select_colors (j_decompress_ptr cinfo, int desired_colors) +/* Master routine for color selection */ +{ + boxptr boxlist; + int numboxes; + int i; + + /* Allocate workspace for box list */ + boxlist = (boxptr) (*cinfo->mem->alloc_small) + ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * SIZEOF(box)); + /* Initialize one box containing whole space */ + numboxes = 1; + boxlist[0].c0min = 0; + boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT; + boxlist[0].c1min = 0; + boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT; + boxlist[0].c2min = 0; + boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT; + /* Shrink it to actually-used volume and set its statistics */ + update_box(cinfo, & boxlist[0]); + /* Perform median-cut to produce final box list */ + numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors); + /* Compute the representative color for each box, fill colormap */ + for (i = 0; i < numboxes; i++) + compute_color(cinfo, & boxlist[i], i); + cinfo->actual_number_of_colors = numboxes; + TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes); +} + + +/* + * These routines are concerned with the time-critical task of mapping input + * colors to the nearest color in the selected colormap. + * + * We re-use the histogram space as an "inverse color map", essentially a + * cache for the results of nearest-color searches. All colors within a + * histogram cell will be mapped to the same colormap entry, namely the one + * closest to the cell's center. This may not be quite the closest entry to + * the actual input color, but it's almost as good. A zero in the cache + * indicates we haven't found the nearest color for that cell yet; the array + * is cleared to zeroes before starting the mapping pass. When we find the + * nearest color for a cell, its colormap index plus one is recorded in the + * cache for future use. The pass2 scanning routines call fill_inverse_cmap + * when they need to use an unfilled entry in the cache. + * + * Our method of efficiently finding nearest colors is based on the "locally + * sorted search" idea described by Heckbert and on the incremental distance + * calculation described by Spencer W. Thomas in chapter III.1 of Graphics + * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that + * the distances from a given colormap entry to each cell of the histogram can + * be computed quickly using an incremental method: the differences between + * distances to adjacent cells themselves differ by a constant. This allows a + * fairly fast implementation of the "brute force" approach of computing the + * distance from every colormap entry to every histogram cell. Unfortunately, + * it needs a work array to hold the best-distance-so-far for each histogram + * cell (because the inner loop has to be over cells, not colormap entries). + * The work array elements have to be INT32s, so the work array would need + * 256Kb at our recommended precision. This is not feasible in DOS machines. + * + * To get around these problems, we apply Thomas' method to compute the + * nearest colors for only the cells within a small subbox of the histogram. + * The work array need be only as big as the subbox, so the memory usage + * problem is solved. Furthermore, we need not fill subboxes that are never + * referenced in pass2; many images use only part of the color gamut, so a + * fair amount of work is saved. An additional advantage of this + * approach is that we can apply Heckbert's locality criterion to quickly + * eliminate colormap entries that are far away from the subbox; typically + * three-fourths of the colormap entries are rejected by Heckbert's criterion, + * and we need not compute their distances to individual cells in the subbox. + * The speed of this approach is heavily influenced by the subbox size: too + * small means too much overhead, too big loses because Heckbert's criterion + * can't eliminate as many colormap entries. Empirically the best subbox + * size seems to be about 1/512th of the histogram (1/8th in each direction). + * + * Thomas' article also describes a refined method which is asymptotically + * faster than the brute-force method, but it is also far more complex and + * cannot efficiently be applied to small subboxes. It is therefore not + * useful for programs intended to be portable to DOS machines. On machines + * with plenty of memory, filling the whole histogram in one shot with Thomas' + * refined method might be faster than the present code --- but then again, + * it might not be any faster, and it's certainly more complicated. + */ + + +/* log2(histogram cells in update box) for each axis; this can be adjusted */ +#define BOX_C0_LOG (HIST_C0_BITS-3) +#define BOX_C1_LOG (HIST_C1_BITS-3) +#define BOX_C2_LOG (HIST_C2_BITS-3) + +#define BOX_C0_ELEMS (1<actual_number_of_colors; + int maxc0, maxc1, maxc2; + int centerc0, centerc1, centerc2; + int i, x, ncolors; + INT32 minmaxdist, min_dist, max_dist, tdist; + INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */ + + /* Compute true coordinates of update box's upper corner and center. + * Actually we compute the coordinates of the center of the upper-corner + * histogram cell, which are the upper bounds of the volume we care about. + * Note that since ">>" rounds down, the "center" values may be closer to + * min than to max; hence comparisons to them must be "<=", not "<". + */ + maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT)); + centerc0 = (minc0 + maxc0) >> 1; + maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT)); + centerc1 = (minc1 + maxc1) >> 1; + maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT)); + centerc2 = (minc2 + maxc2) >> 1; + + /* For each color in colormap, find: + * 1. its minimum squared-distance to any point in the update box + * (zero if color is within update box); + * 2. its maximum squared-distance to any point in the update box. + * Both of these can be found by considering only the corners of the box. + * We save the minimum distance for each color in mindist[]; + * only the smallest maximum distance is of interest. + */ + minmaxdist = 0x7FFFFFFFL; + + for (i = 0; i < numcolors; i++) { + /* We compute the squared-c0-distance term, then add in the other two. */ + x = GETJSAMPLE(cinfo->colormap[0][i]); + if (x < minc0) { + tdist = (x - minc0) * C0_SCALE; + min_dist = tdist*tdist; + tdist = (x - maxc0) * C0_SCALE; + max_dist = tdist*tdist; + } else if (x > maxc0) { + tdist = (x - maxc0) * C0_SCALE; + min_dist = tdist*tdist; + tdist = (x - minc0) * C0_SCALE; + max_dist = tdist*tdist; + } else { + /* within cell range so no contribution to min_dist */ + min_dist = 0; + if (x <= centerc0) { + tdist = (x - maxc0) * C0_SCALE; + max_dist = tdist*tdist; + } else { + tdist = (x - minc0) * C0_SCALE; + max_dist = tdist*tdist; + } + } + + x = GETJSAMPLE(cinfo->colormap[1][i]); + if (x < minc1) { + tdist = (x - minc1) * C1_SCALE; + min_dist += tdist*tdist; + tdist = (x - maxc1) * C1_SCALE; + max_dist += tdist*tdist; + } else if (x > maxc1) { + tdist = (x - maxc1) * C1_SCALE; + min_dist += tdist*tdist; + tdist = (x - minc1) * C1_SCALE; + max_dist += tdist*tdist; + } else { + /* within cell range so no contribution to min_dist */ + if (x <= centerc1) { + tdist = (x - maxc1) * C1_SCALE; + max_dist += tdist*tdist; + } else { + tdist = (x - minc1) * C1_SCALE; + max_dist += tdist*tdist; + } + } + + x = GETJSAMPLE(cinfo->colormap[2][i]); + if (x < minc2) { + tdist = (x - minc2) * C2_SCALE; + min_dist += tdist*tdist; + tdist = (x - maxc2) * C2_SCALE; + max_dist += tdist*tdist; + } else if (x > maxc2) { + tdist = (x - maxc2) * C2_SCALE; + min_dist += tdist*tdist; + tdist = (x - minc2) * C2_SCALE; + max_dist += tdist*tdist; + } else { + /* within cell range so no contribution to min_dist */ + if (x <= centerc2) { + tdist = (x - maxc2) * C2_SCALE; + max_dist += tdist*tdist; + } else { + tdist = (x - minc2) * C2_SCALE; + max_dist += tdist*tdist; + } + } + + mindist[i] = min_dist; /* save away the results */ + if (max_dist < minmaxdist) + minmaxdist = max_dist; + } + + /* Now we know that no cell in the update box is more than minmaxdist + * away from some colormap entry. Therefore, only colors that are + * within minmaxdist of some part of the box need be considered. + */ + ncolors = 0; + for (i = 0; i < numcolors; i++) { + if (mindist[i] <= minmaxdist) + colorlist[ncolors++] = (JSAMPLE) i; + } + return ncolors; +} + + +LOCAL(void) +find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, + int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[]) +/* Find the closest colormap entry for each cell in the update box, + * given the list of candidate colors prepared by find_nearby_colors. + * Return the indexes of the closest entries in the bestcolor[] array. + * This routine uses Thomas' incremental distance calculation method to + * find the distance from a colormap entry to successive cells in the box. + */ +{ + int ic0, ic1, ic2; + int i, icolor; + register INT32 * bptr; /* pointer into bestdist[] array */ + JSAMPLE * cptr; /* pointer into bestcolor[] array */ + INT32 dist0, dist1; /* initial distance values */ + register INT32 dist2; /* current distance in inner loop */ + INT32 xx0, xx1; /* distance increments */ + register INT32 xx2; + INT32 inc0, inc1, inc2; /* initial values for increments */ + /* This array holds the distance to the nearest-so-far color for each cell */ + INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; + + /* Initialize best-distance for each cell of the update box */ + bptr = bestdist; + for (i = BOX_C0_ELEMS*BOX_C1_ELEMS*BOX_C2_ELEMS-1; i >= 0; i--) + *bptr++ = 0x7FFFFFFFL; + + /* For each color selected by find_nearby_colors, + * compute its distance to the center of each cell in the box. + * If that's less than best-so-far, update best distance and color number. + */ + + /* Nominal steps between cell centers ("x" in Thomas article) */ +#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE) +#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE) +#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE) + + for (i = 0; i < numcolors; i++) { + icolor = GETJSAMPLE(colorlist[i]); + /* Compute (square of) distance from minc0/c1/c2 to this color */ + inc0 = (minc0 - GETJSAMPLE(cinfo->colormap[0][icolor])) * C0_SCALE; + dist0 = inc0*inc0; + inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE; + dist0 += inc1*inc1; + inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE; + dist0 += inc2*inc2; + /* Form the initial difference increments */ + inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0; + inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1; + inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2; + /* Now loop over all cells in box, updating distance per Thomas method */ + bptr = bestdist; + cptr = bestcolor; + xx0 = inc0; + for (ic0 = BOX_C0_ELEMS-1; ic0 >= 0; ic0--) { + dist1 = dist0; + xx1 = inc1; + for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) { + dist2 = dist1; + xx2 = inc2; + for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) { + if (dist2 < *bptr) { + *bptr = dist2; + *cptr = (JSAMPLE) icolor; + } + dist2 += xx2; + xx2 += 2 * STEP_C2 * STEP_C2; + bptr++; + cptr++; + } + dist1 += xx1; + xx1 += 2 * STEP_C1 * STEP_C1; + } + dist0 += xx0; + xx0 += 2 * STEP_C0 * STEP_C0; + } + } +} + + +LOCAL(void) +fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2) +/* Fill the inverse-colormap entries in the update box that contains */ +/* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */ +/* we can fill as many others as we wish.) */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + int minc0, minc1, minc2; /* lower left corner of update box */ + int ic0, ic1, ic2; + register JSAMPLE * cptr; /* pointer into bestcolor[] array */ + register histptr cachep; /* pointer into main cache array */ + /* This array lists the candidate colormap indexes. */ + JSAMPLE colorlist[MAXNUMCOLORS]; + int numcolors; /* number of candidate colors */ + /* This array holds the actually closest colormap index for each cell. */ + JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; + + /* Convert cell coordinates to update box ID */ + c0 >>= BOX_C0_LOG; + c1 >>= BOX_C1_LOG; + c2 >>= BOX_C2_LOG; + + /* Compute true coordinates of update box's origin corner. + * Actually we compute the coordinates of the center of the corner + * histogram cell, which are the lower bounds of the volume we care about. + */ + minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1); + minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1); + minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1); + + /* Determine which colormap entries are close enough to be candidates + * for the nearest entry to some cell in the update box. + */ + numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist); + + /* Determine the actually nearest colors. */ + find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist, + bestcolor); + + /* Save the best color numbers (plus 1) in the main cache array */ + c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */ + c1 <<= BOX_C1_LOG; + c2 <<= BOX_C2_LOG; + cptr = bestcolor; + for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) { + for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) { + cachep = & histogram[c0+ic0][c1+ic1][c2]; + for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) { + *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1); + } + } + } +} + + +/* + * Map some rows of pixels to the output colormapped representation. + */ + +METHODDEF(void) +pass2_no_dither (j_decompress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) +/* This version performs no dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + register JSAMPROW inptr, outptr; + register histptr cachep; + register int c0, c1, c2; + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + + for (row = 0; row < num_rows; row++) { + inptr = input_buf[row]; + outptr = output_buf[row]; + for (col = width; col > 0; col--) { + /* get pixel value and index into the cache */ + c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT; + c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT; + c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT; + cachep = & histogram[c0][c1][c2]; + /* If we have not seen this color before, find nearest colormap entry */ + /* and update the cache */ + if (*cachep == 0) + fill_inverse_cmap(cinfo, c0,c1,c2); + /* Now emit the colormap index for this cell */ + *outptr++ = (JSAMPLE) (*cachep - 1); + } + } +} + + +METHODDEF(void) +pass2_fs_dither (j_decompress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) +/* This version performs Floyd-Steinberg dithering */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */ + LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */ + LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */ + register FSERRPTR errorptr; /* => fserrors[] at column before current */ + JSAMPROW inptr; /* => current input pixel */ + JSAMPROW outptr; /* => current output pixel */ + histptr cachep; + int dir; /* +1 or -1 depending on direction */ + int dir3; /* 3*dir, for advancing inptr & errorptr */ + int row; + JDIMENSION col; + JDIMENSION width = cinfo->output_width; + JSAMPLE *range_limit = cinfo->sample_range_limit; + int *error_limit = cquantize->error_limiter; + JSAMPROW colormap0 = cinfo->colormap[0]; + JSAMPROW colormap1 = cinfo->colormap[1]; + JSAMPROW colormap2 = cinfo->colormap[2]; + SHIFT_TEMPS + + for (row = 0; row < num_rows; row++) { + inptr = input_buf[row]; + outptr = output_buf[row]; + if (cquantize->on_odd_row) { + /* work right to left in this row */ + inptr += (width-1) * 3; /* so point to rightmost pixel */ + outptr += width-1; + dir = -1; + dir3 = -3; + errorptr = cquantize->fserrors + (width+1)*3; /* => entry after last column */ + cquantize->on_odd_row = FALSE; /* flip for next time */ + } else { + /* work left to right in this row */ + dir = 1; + dir3 = 3; + errorptr = cquantize->fserrors; /* => entry before first real column */ + cquantize->on_odd_row = TRUE; /* flip for next time */ + } + /* Preset error values: no error propagated to first pixel from left */ + cur0 = cur1 = cur2 = 0; + /* and no error propagated to row below yet */ + belowerr0 = belowerr1 = belowerr2 = 0; + bpreverr0 = bpreverr1 = bpreverr2 = 0; + + for (col = width; col > 0; col--) { + /* curN holds the error propagated from the previous pixel on the + * current line. Add the error propagated from the previous line + * to form the complete error correction term for this pixel, and + * round the error term (which is expressed * 16) to an integer. + * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct + * for either sign of the error value. + * Note: errorptr points to *previous* column's array entry. + */ + cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3+0] + 8, 4); + cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3+1] + 8, 4); + cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3+2] + 8, 4); + /* Limit the error using transfer function set by init_error_limit. + * See comments with init_error_limit for rationale. + */ + cur0 = error_limit[cur0]; + cur1 = error_limit[cur1]; + cur2 = error_limit[cur2]; + /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. + * The maximum error is +- MAXJSAMPLE (or less with error limiting); + * this sets the required size of the range_limit array. + */ + cur0 += GETJSAMPLE(inptr[0]); + cur1 += GETJSAMPLE(inptr[1]); + cur2 += GETJSAMPLE(inptr[2]); + cur0 = GETJSAMPLE(range_limit[cur0]); + cur1 = GETJSAMPLE(range_limit[cur1]); + cur2 = GETJSAMPLE(range_limit[cur2]); + /* Index into the cache with adjusted pixel value */ + cachep = & histogram[cur0>>C0_SHIFT][cur1>>C1_SHIFT][cur2>>C2_SHIFT]; + /* If we have not seen this color before, find nearest colormap */ + /* entry and update the cache */ + if (*cachep == 0) + fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT); + /* Now emit the colormap index for this cell */ + { register int pixcode = *cachep - 1; + *outptr = (JSAMPLE) pixcode; + /* Compute representation error for this pixel */ + cur0 -= GETJSAMPLE(colormap0[pixcode]); + cur1 -= GETJSAMPLE(colormap1[pixcode]); + cur2 -= GETJSAMPLE(colormap2[pixcode]); + } + /* Compute error fractions to be propagated to adjacent pixels. + * Add these into the running sums, and simultaneously shift the + * next-line error sums left by 1 column. + */ + { register LOCFSERROR bnexterr, delta; + + bnexterr = cur0; /* Process component 0 */ + delta = cur0 * 2; + cur0 += delta; /* form error * 3 */ + errorptr[0] = (FSERROR) (bpreverr0 + cur0); + cur0 += delta; /* form error * 5 */ + bpreverr0 = belowerr0 + cur0; + belowerr0 = bnexterr; + cur0 += delta; /* form error * 7 */ + bnexterr = cur1; /* Process component 1 */ + delta = cur1 * 2; + cur1 += delta; /* form error * 3 */ + errorptr[1] = (FSERROR) (bpreverr1 + cur1); + cur1 += delta; /* form error * 5 */ + bpreverr1 = belowerr1 + cur1; + belowerr1 = bnexterr; + cur1 += delta; /* form error * 7 */ + bnexterr = cur2; /* Process component 2 */ + delta = cur2 * 2; + cur2 += delta; /* form error * 3 */ + errorptr[2] = (FSERROR) (bpreverr2 + cur2); + cur2 += delta; /* form error * 5 */ + bpreverr2 = belowerr2 + cur2; + belowerr2 = bnexterr; + cur2 += delta; /* form error * 7 */ + } + /* At this point curN contains the 7/16 error value to be propagated + * to the next pixel on the current line, and all the errors for the + * next line have been shifted over. We are therefore ready to move on. + */ + inptr += dir3; /* Advance pixel pointers to next column */ + outptr += dir; + errorptr += dir3; /* advance errorptr to current column */ + } + /* Post-loop cleanup: we must unload the final error values into the + * final fserrors[] entry. Note we need not unload belowerrN because + * it is for the dummy column before or after the actual array. + */ + errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */ + errorptr[1] = (FSERROR) bpreverr1; + errorptr[2] = (FSERROR) bpreverr2; + } +} + + +/* + * Initialize the error-limiting transfer function (lookup table). + * The raw F-S error computation can potentially compute error values of up to + * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be + * much less, otherwise obviously wrong pixels will be created. (Typical + * effects include weird fringes at color-area boundaries, isolated bright + * pixels in a dark area, etc.) The standard advice for avoiding this problem + * is to ensure that the "corners" of the color cube are allocated as output + * colors; then repeated errors in the same direction cannot cause cascading + * error buildup. However, that only prevents the error from getting + * completely out of hand; Aaron Giles reports that error limiting improves + * the results even with corner colors allocated. + * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty + * well, but the smoother transfer function used below is even better. Thanks + * to Aaron Giles for this idea. + */ + +LOCAL(void) +init_error_limit (j_decompress_ptr cinfo) +/* Allocate and fill in the error_limiter table */ +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + int * table; + int in, out; + + table = (int *) (*cinfo->mem->alloc_small) + ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int)); + table += MAXJSAMPLE; /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */ + cquantize->error_limiter = table; + +#define STEPSIZE ((MAXJSAMPLE+1)/16) + /* Map errors 1:1 up to +- MAXJSAMPLE/16 */ + out = 0; + for (in = 0; in < STEPSIZE; in++, out++) { + table[in] = out; table[-in] = -out; + } + /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */ + for (; in < STEPSIZE*3; in++, out += (in&1) ? 0 : 1) { + table[in] = out; table[-in] = -out; + } + /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */ + for (; in <= MAXJSAMPLE; in++) { + table[in] = out; table[-in] = -out; + } +#undef STEPSIZE +} + + +/* + * Finish up at the end of each pass. + */ + +METHODDEF(void) +finish_pass1 (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + + /* Select the representative colors and fill in cinfo->colormap */ + cinfo->colormap = cquantize->sv_colormap; + select_colors(cinfo, cquantize->desired); + /* Force next pass to zero the color index table */ + cquantize->needs_zeroed = TRUE; +} + + +METHODDEF(void) +finish_pass2 (j_decompress_ptr cinfo) +{ + /* no work */ +} + + +/* + * Initialize for each processing pass. + */ + +METHODDEF(void) +start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + hist3d histogram = cquantize->histogram; + int i; + + /* Only F-S dithering or no dithering is supported. */ + /* If user asks for ordered dither, give him F-S. */ + if (cinfo->dither_mode != JDITHER_NONE) + cinfo->dither_mode = JDITHER_FS; + + if (is_pre_scan) { + /* Set up method pointers */ + cquantize->pub.color_quantize = prescan_quantize; + cquantize->pub.finish_pass = finish_pass1; + cquantize->needs_zeroed = TRUE; /* Always zero histogram */ + } else { + /* Set up method pointers */ + if (cinfo->dither_mode == JDITHER_FS) + cquantize->pub.color_quantize = pass2_fs_dither; + else + cquantize->pub.color_quantize = pass2_no_dither; + cquantize->pub.finish_pass = finish_pass2; + + /* Make sure color count is acceptable */ + i = cinfo->actual_number_of_colors; + if (i < 1) + ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1); + if (i > MAXNUMCOLORS) + ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS); + + if (cinfo->dither_mode == JDITHER_FS) { + size_t arraysize = (size_t) ((cinfo->output_width + 2) * + (3 * SIZEOF(FSERROR))); + /* Allocate Floyd-Steinberg workspace if we didn't already. */ + if (cquantize->fserrors == NULL) + cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large) + ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize); + /* Initialize the propagated errors to zero. */ + jzero_far((void FAR *) cquantize->fserrors, arraysize); + /* Make the error-limit table if we didn't already. */ + if (cquantize->error_limiter == NULL) + init_error_limit(cinfo); + cquantize->on_odd_row = FALSE; + } + + } + /* Zero the histogram or inverse color map, if necessary */ + if (cquantize->needs_zeroed) { + for (i = 0; i < HIST_C0_ELEMS; i++) { + jzero_far((void FAR *) histogram[i], + HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell)); + } + cquantize->needs_zeroed = FALSE; + } +} + + +/* + * Switch to a new external colormap between output passes. + */ + +METHODDEF(void) +new_color_map_2_quant (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; + + /* Reset the inverse color map */ + cquantize->needs_zeroed = TRUE; +} + + +/* + * Module initialization routine for 2-pass color quantization. + */ + +GLOBAL(void) +jinit_2pass_quantizer (j_decompress_ptr cinfo) +{ + my_cquantize_ptr cquantize; + int i; + + cquantize = (my_cquantize_ptr) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + SIZEOF(my_cquantizer)); + cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize; + cquantize->pub.start_pass = start_pass_2_quant; + cquantize->pub.new_color_map = new_color_map_2_quant; + cquantize->fserrors = NULL; /* flag optional arrays not allocated */ + cquantize->error_limiter = NULL; + + /* Make sure jdmaster didn't give me a case I can't handle */ + if (cinfo->out_color_components != 3) + ERREXIT(cinfo, JERR_NOTIMPL); + + /* Allocate the histogram/inverse colormap storage */ + cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small) + ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d)); + for (i = 0; i < HIST_C0_ELEMS; i++) { + cquantize->histogram[i] = (hist2d) (*cinfo->mem->alloc_large) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell)); + } + cquantize->needs_zeroed = TRUE; /* histogram is garbage now */ + + /* Allocate storage for the completed colormap, if required. + * We do this now since it is FAR storage and may affect + * the memory manager's space calculations. + */ + if (cinfo->enable_2pass_quant) { + /* Make sure color count is acceptable */ + int desired = cinfo->desired_number_of_colors; + /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */ + if (desired < 8) + ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8); + /* Make sure colormap indexes can be represented by JSAMPLEs */ + if (desired > MAXNUMCOLORS) + ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS); + cquantize->sv_colormap = (*cinfo->mem->alloc_sarray) + ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3); + cquantize->desired = desired; + } else + cquantize->sv_colormap = NULL; + + /* Only F-S dithering or no dithering is supported. */ + /* If user asks for ordered dither, give him F-S. */ + if (cinfo->dither_mode != JDITHER_NONE) + cinfo->dither_mode = JDITHER_FS; + + /* Allocate Floyd-Steinberg workspace if necessary. + * This isn't really needed until pass 2, but again it is FAR storage. + * Although we will cope with a later change in dither_mode, + * we do not promise to honor max_memory_to_use if dither_mode changes. + */ + if (cinfo->dither_mode == JDITHER_FS) { + cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large) + ((j_common_ptr) cinfo, JPOOL_IMAGE, + (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR)))); + /* Might as well create the error-limiting table too. */ + init_error_limit(cinfo); + } +} + +#endif /* QUANT_2PASS_SUPPORTED */ diff --git a/TMessagesProj/jni/libjpeg/jutils.c b/TMessagesProj/jni/libjpeg/jutils.c new file mode 100755 index 000000000..616ad0511 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jutils.c @@ -0,0 +1,185 @@ +/* + * jutils.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains tables and miscellaneous utility routines needed + * for both compression and decompression. + * Note we prefix all global names with "j" to minimize conflicts with + * a surrounding application. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" + + +/* + * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element + * of a DCT block read in natural order (left to right, top to bottom). + */ + +#if 0 /* This table is not actually needed in v6a */ + +const int jpeg_zigzag_order[DCTSIZE2] = { + 0, 1, 5, 6, 14, 15, 27, 28, + 2, 4, 7, 13, 16, 26, 29, 42, + 3, 8, 12, 17, 25, 30, 41, 43, + 9, 11, 18, 24, 31, 40, 44, 53, + 10, 19, 23, 32, 39, 45, 52, 54, + 20, 22, 33, 38, 46, 51, 55, 60, + 21, 34, 37, 47, 50, 56, 59, 61, + 35, 36, 48, 49, 57, 58, 62, 63 +}; + +#endif + +/* + * jpeg_natural_order[i] is the natural-order position of the i'th element + * of zigzag order. + * + * When reading corrupted data, the Huffman decoders could attempt + * to reference an entry beyond the end of this array (if the decoded + * zero run length reaches past the end of the block). To prevent + * wild stores without adding an inner-loop test, we put some extra + * "63"s after the real entries. This will cause the extra coefficient + * to be stored in location 63 of the block, not somewhere random. + * The worst case would be a run-length of 15, which means we need 16 + * fake entries. + */ + +const int jpeg_natural_order[DCTSIZE2+16] = { + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */ + 63, 63, 63, 63, 63, 63, 63, 63 +}; + + +/* + * Arithmetic utilities + */ + +GLOBAL(long) +jdiv_round_up (long a, long b) +/* Compute a/b rounded up to next integer, ie, ceil(a/b) */ +/* Assumes a >= 0, b > 0 */ +{ + return (a + b - 1L) / b; +} + + +GLOBAL(long) +jround_up (long a, long b) +/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */ +/* Assumes a >= 0, b > 0 */ +{ + a += b - 1L; + return a - (a % b); +} + +GLOBAL(long) +jmin (long a, long b) +{ + return a < b ? a : b; +} + + +/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays + * and coefficient-block arrays. This won't work on 80x86 because the arrays + * are FAR and we're assuming a small-pointer memory model. However, some + * DOS compilers provide far-pointer versions of memcpy() and memset() even + * in the small-model libraries. These will be used if USE_FMEM is defined. + * Otherwise, the routines below do it the hard way. (The performance cost + * is not all that great, because these routines aren't very heavily used.) + */ + +#ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */ +#define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size) +#define FMEMZERO(target,size) MEMZERO(target,size) +#else /* 80x86 case, define if we can */ +#ifdef USE_FMEM +#define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size)) +#define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size)) +#endif +#endif + + +GLOBAL(void) +jcopy_sample_rows (JSAMPARRAY input_array, int source_row, + JSAMPARRAY output_array, int dest_row, + int num_rows, JDIMENSION num_cols) +/* Copy some rows of samples from one place to another. + * num_rows rows are copied from input_array[source_row++] + * to output_array[dest_row++]; these areas may overlap for duplication. + * The source and destination arrays must be at least as wide as num_cols. + */ +{ + register JSAMPROW inptr, outptr; +#ifdef FMEMCOPY + register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE)); +#else + register JDIMENSION count; +#endif + register int row; + + input_array += source_row; + output_array += dest_row; + + for (row = num_rows; row > 0; row--) { + inptr = *input_array++; + outptr = *output_array++; +#ifdef FMEMCOPY + FMEMCOPY(outptr, inptr, count); +#else + for (count = num_cols; count > 0; count--) + *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */ +#endif + } +} + + +GLOBAL(void) +jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, + JDIMENSION num_blocks) +/* Copy a row of coefficient blocks from one place to another. */ +{ +#ifdef FMEMCOPY + FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF))); +#else + register JCOEFPTR inptr, outptr; + register long count; + + inptr = (JCOEFPTR) input_row; + outptr = (JCOEFPTR) output_row; + for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) { + *outptr++ = *inptr++; + } +#endif +} + + +GLOBAL(void) +jzero_far (void FAR * target, size_t bytestozero) +/* Zero out a chunk of FAR memory. */ +/* This might be sample-array data, block-array data, or alloc_large data. */ +{ +#ifdef FMEMZERO + FMEMZERO(target, bytestozero); +#else + register char FAR * ptr = (char FAR *) target; + register size_t count; + + for (count = bytestozero; count > 0; count--) { + *ptr++ = 0; + } +#endif +} diff --git a/TMessagesProj/jni/libjpeg/jversion.h b/TMessagesProj/jni/libjpeg/jversion.h new file mode 100755 index 000000000..6472c58d3 --- /dev/null +++ b/TMessagesProj/jni/libjpeg/jversion.h @@ -0,0 +1,14 @@ +/* + * jversion.h + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains software version identification. + */ + + +#define JVERSION "6b 27-Mar-1998" + +#define JCOPYRIGHT "Copyright (C) 1998, Thomas G. Lane" diff --git a/TMessagesProj/jni/utils.c b/TMessagesProj/jni/utils.c new file mode 100644 index 000000000..1321a8213 --- /dev/null +++ b/TMessagesProj/jni/utils.c @@ -0,0 +1,14 @@ +#include "utils.h" + +void throwException(JNIEnv *env, char *format, ...) { + jclass exClass = (*env)->FindClass(env, "java/lang/UnsupportedOperationException"); + if (!exClass) { + return; + } + char dest[256]; + va_list argptr; + va_start(argptr, format); + vsprintf(dest, format, argptr); + va_end(argptr); + (*env)->ThrowNew(env, exClass, dest); +} diff --git a/TMessagesProj/jni/utils.h b/TMessagesProj/jni/utils.h index 49885b99f..d18734f87 100644 --- a/TMessagesProj/jni/utils.h +++ b/TMessagesProj/jni/utils.h @@ -2,6 +2,7 @@ #define log_h #include +#include #define LOG_TAG "tmessages_native" #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) @@ -16,4 +17,6 @@ #define min(x, y) ((x) < (y)) ? (x) : (y) #endif +void throwException(JNIEnv *env, char *format, ...); + #endif diff --git a/TMessagesProj/libs/armeabi-v7a/libtmessages.so b/TMessagesProj/libs/armeabi-v7a/libtmessages.so index 1f8815194eb9c8ae8a11d78732bffa1ce20809ca..d3d44495ad892a91ee3b417a35261369ead5cb59 100755 GIT binary patch delta 544287 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

NO-Il_YAG`d_ecA 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 -B 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ÇVkTXhM(AOSpS-W2P|`mg^G7v%9i|z% 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�kd_bWCahSkIsC=1ly95_jXsYCZo= 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%0D>)l2Hf$<-dMM;6nx;TWOQ3j<$i24{R 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