mirror of https://github.com/adamdruppe/arsd.git
3471 lines
115 KiB
D
3471 lines
115 KiB
D
// jpgd.h - C++ class for JPEG decompression.
|
|
// Rich Geldreich <richgel99@gmail.com>
|
|
// Alex Evans: Linear memory allocator (taken from jpge.h).
|
|
// v1.04, May. 19, 2012: Code tweaks to fix VS2008 static code analysis warnings (all looked harmless)
|
|
// D translation by Ketmar // Invisible Vector
|
|
//
|
|
// This is free and unencumbered software released into the public domain.
|
|
//
|
|
// Anyone is free to copy, modify, publish, use, compile, sell, or
|
|
// distribute this software, either in source code form or as a compiled
|
|
// binary, for any purpose, commercial or non-commercial, and by any
|
|
// means.
|
|
//
|
|
// In jurisdictions that recognize copyright laws, the author or authors
|
|
// of this software dedicate any and all copyright interest in the
|
|
// software to the public domain. We make this dedication for the benefit
|
|
// of the public at large and to the detriment of our heirs and
|
|
// successors. We intend this dedication to be an overt act of
|
|
// relinquishment in perpetuity of all present and future rights to this
|
|
// software under copyright law.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
// OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
// For more information, please refer to <http://unlicense.org/>
|
|
//
|
|
// Supports progressive and baseline sequential JPEG image files, and the most common chroma subsampling factors: Y, H1V1, H2V1, H1V2, and H2V2.
|
|
//
|
|
// Chroma upsampling quality: H2V2 is upsampled in the frequency domain, H2V1 and H1V2 are upsampled using point sampling.
|
|
// Chroma upsampling reference: "Fast Scheme for Image Size Change in the Compressed Domain"
|
|
// http://vision.ai.uiuc.edu/~dugad/research/dct/index.html
|
|
/**
|
|
* Loads a JPEG image from a memory buffer or a file.
|
|
*
|
|
* req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
|
|
* On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
|
|
* Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
|
|
*/
|
|
module arsd.jpeg;
|
|
|
|
// Set to 1 to enable freq. domain chroma upsampling on images using H2V2 subsampling (0=faster nearest neighbor sampling).
|
|
// This is slower, but results in higher quality on images with highly saturated colors.
|
|
version = JPGD_SUPPORT_FREQ_DOMAIN_UPSAMPLING;
|
|
|
|
/// Input stream interface.
|
|
/// This delegate is called when the internal input buffer is empty.
|
|
/// Parameters:
|
|
/// pBuf - input buffer
|
|
/// max_bytes_to_read - maximum bytes that can be written to pBuf
|
|
/// pEOF_flag - set this to true if at end of stream (no more bytes remaining)
|
|
/// Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
|
|
/// Notes: This delegate will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
|
|
alias JpegStreamReadFunc = int delegate (void* pBuf, int max_bytes_to_read, bool* pEOF_flag);
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
private:
|
|
void *jpgd_malloc (size_t nSize) { import core.stdc.stdlib : malloc; return malloc(nSize); }
|
|
void jpgd_free (void *p) { import core.stdc.stdlib : free; if (p !is null) free(p); }
|
|
|
|
// Success/failure error codes.
|
|
alias jpgd_status = int;
|
|
enum /*jpgd_status*/ {
|
|
JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
|
|
JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE,
|
|
JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS,
|
|
JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
|
|
JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
|
|
JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
|
|
JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
|
|
JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
|
|
JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM,
|
|
}
|
|
|
|
enum {
|
|
JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4,
|
|
JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384,
|
|
}
|
|
|
|
// DCT coefficients are stored in this sequence.
|
|
static immutable int[64] g_ZAG = [ 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 ];
|
|
|
|
alias JPEG_MARKER = int;
|
|
enum /*JPEG_MARKER*/ {
|
|
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_APP15 = 0xEF, M_JPG0 = 0xF0, M_JPG13 = 0xFD, M_COM = 0xFE, M_TEM = 0x01, M_ERROR = 0x100, RST0 = 0xD0,
|
|
}
|
|
|
|
alias JPEG_SUBSAMPLING = int;
|
|
enum /*JPEG_SUBSAMPLING*/ { JPGD_GRAYSCALE = 0, JPGD_YH1V1, JPGD_YH2V1, JPGD_YH1V2, JPGD_YH2V2 };
|
|
|
|
enum CONST_BITS = 13;
|
|
enum PASS1_BITS = 2;
|
|
enum SCALEDONE = cast(int)1;
|
|
|
|
enum FIX_0_298631336 = cast(int)2446; /* FIX(0.298631336) */
|
|
enum FIX_0_390180644 = cast(int)3196; /* FIX(0.390180644) */
|
|
enum FIX_0_541196100 = cast(int)4433; /* FIX(0.541196100) */
|
|
enum FIX_0_765366865 = cast(int)6270; /* FIX(0.765366865) */
|
|
enum FIX_0_899976223 = cast(int)7373; /* FIX(0.899976223) */
|
|
enum FIX_1_175875602 = cast(int)9633; /* FIX(1.175875602) */
|
|
enum FIX_1_501321110 = cast(int)12299; /* FIX(1.501321110) */
|
|
enum FIX_1_847759065 = cast(int)15137; /* FIX(1.847759065) */
|
|
enum FIX_1_961570560 = cast(int)16069; /* FIX(1.961570560) */
|
|
enum FIX_2_053119869 = cast(int)16819; /* FIX(2.053119869) */
|
|
enum FIX_2_562915447 = cast(int)20995; /* FIX(2.562915447) */
|
|
enum FIX_3_072711026 = cast(int)25172; /* FIX(3.072711026) */
|
|
|
|
int DESCALE() (int x, int n) { pragma(inline, true); return (((x) + (SCALEDONE << ((n)-1))) >> (n)); }
|
|
int DESCALE_ZEROSHIFT() (int x, int n) { pragma(inline, true); return (((x) + (128 << (n)) + (SCALEDONE << ((n)-1))) >> (n)); }
|
|
ubyte CLAMP() (int i) { pragma(inline, true); return cast(ubyte)(cast(uint)i > 255 ? (((~i) >> 31) & 0xFF) : i); }
|
|
|
|
|
|
// Compiler creates a fast path 1D IDCT for X non-zero columns
|
|
struct Row(int NONZERO_COLS) {
|
|
pure nothrow @trusted @nogc:
|
|
static void idct(int* pTemp, const(jpeg_decoder.jpgd_block_t)* pSrc) {
|
|
static if (NONZERO_COLS == 0) {
|
|
// nothing
|
|
} else static if (NONZERO_COLS == 1) {
|
|
immutable int dcval = (pSrc[0] << PASS1_BITS);
|
|
pTemp[0] = dcval;
|
|
pTemp[1] = dcval;
|
|
pTemp[2] = dcval;
|
|
pTemp[3] = dcval;
|
|
pTemp[4] = dcval;
|
|
pTemp[5] = dcval;
|
|
pTemp[6] = dcval;
|
|
pTemp[7] = dcval;
|
|
} else {
|
|
// ACCESS_COL() will be optimized at compile time to either an array access, or 0.
|
|
//#define ACCESS_COL(x) (((x) < NONZERO_COLS) ? (int)pSrc[x] : 0)
|
|
template ACCESS_COL(int x) {
|
|
static if (x < NONZERO_COLS) enum ACCESS_COL = "cast(int)pSrc["~x.stringof~"]"; else enum ACCESS_COL = "0";
|
|
}
|
|
|
|
immutable int z2 = mixin(ACCESS_COL!2), z3 = mixin(ACCESS_COL!6);
|
|
|
|
immutable int z1 = (z2 + z3)*FIX_0_541196100;
|
|
immutable int tmp2 = z1 + z3*(-FIX_1_847759065);
|
|
immutable int tmp3 = z1 + z2*FIX_0_765366865;
|
|
|
|
immutable int tmp0 = (mixin(ACCESS_COL!0) + mixin(ACCESS_COL!4)) << CONST_BITS;
|
|
immutable int tmp1 = (mixin(ACCESS_COL!0) - mixin(ACCESS_COL!4)) << CONST_BITS;
|
|
|
|
immutable int tmp10 = tmp0 + tmp3, tmp13 = tmp0 - tmp3, tmp11 = tmp1 + tmp2, tmp12 = tmp1 - tmp2;
|
|
|
|
immutable int atmp0 = mixin(ACCESS_COL!7), atmp1 = mixin(ACCESS_COL!5), atmp2 = mixin(ACCESS_COL!3), atmp3 = mixin(ACCESS_COL!1);
|
|
|
|
immutable int bz1 = atmp0 + atmp3, bz2 = atmp1 + atmp2, bz3 = atmp0 + atmp2, bz4 = atmp1 + atmp3;
|
|
immutable int bz5 = (bz3 + bz4)*FIX_1_175875602;
|
|
|
|
immutable int az1 = bz1*(-FIX_0_899976223);
|
|
immutable int az2 = bz2*(-FIX_2_562915447);
|
|
immutable int az3 = bz3*(-FIX_1_961570560) + bz5;
|
|
immutable int az4 = bz4*(-FIX_0_390180644) + bz5;
|
|
|
|
immutable int btmp0 = atmp0*FIX_0_298631336 + az1 + az3;
|
|
immutable int btmp1 = atmp1*FIX_2_053119869 + az2 + az4;
|
|
immutable int btmp2 = atmp2*FIX_3_072711026 + az2 + az3;
|
|
immutable int btmp3 = atmp3*FIX_1_501321110 + az1 + az4;
|
|
|
|
pTemp[0] = DESCALE(tmp10 + btmp3, CONST_BITS-PASS1_BITS);
|
|
pTemp[7] = DESCALE(tmp10 - btmp3, CONST_BITS-PASS1_BITS);
|
|
pTemp[1] = DESCALE(tmp11 + btmp2, CONST_BITS-PASS1_BITS);
|
|
pTemp[6] = DESCALE(tmp11 - btmp2, CONST_BITS-PASS1_BITS);
|
|
pTemp[2] = DESCALE(tmp12 + btmp1, CONST_BITS-PASS1_BITS);
|
|
pTemp[5] = DESCALE(tmp12 - btmp1, CONST_BITS-PASS1_BITS);
|
|
pTemp[3] = DESCALE(tmp13 + btmp0, CONST_BITS-PASS1_BITS);
|
|
pTemp[4] = DESCALE(tmp13 - btmp0, CONST_BITS-PASS1_BITS);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Compiler creates a fast path 1D IDCT for X non-zero rows
|
|
struct Col (int NONZERO_ROWS) {
|
|
pure nothrow @trusted @nogc:
|
|
static void idct(ubyte* pDst_ptr, const(int)* pTemp) {
|
|
static assert(NONZERO_ROWS > 0);
|
|
static if (NONZERO_ROWS == 1) {
|
|
int dcval = DESCALE_ZEROSHIFT(pTemp[0], PASS1_BITS+3);
|
|
immutable ubyte dcval_clamped = cast(ubyte)CLAMP(dcval);
|
|
pDst_ptr[0*8] = dcval_clamped;
|
|
pDst_ptr[1*8] = dcval_clamped;
|
|
pDst_ptr[2*8] = dcval_clamped;
|
|
pDst_ptr[3*8] = dcval_clamped;
|
|
pDst_ptr[4*8] = dcval_clamped;
|
|
pDst_ptr[5*8] = dcval_clamped;
|
|
pDst_ptr[6*8] = dcval_clamped;
|
|
pDst_ptr[7*8] = dcval_clamped;
|
|
} else {
|
|
// ACCESS_ROW() will be optimized at compile time to either an array access, or 0.
|
|
//#define ACCESS_ROW(x) (((x) < NONZERO_ROWS) ? pTemp[x * 8] : 0)
|
|
template ACCESS_ROW(int x) {
|
|
static if (x < NONZERO_ROWS) enum ACCESS_ROW = "pTemp["~(x*8).stringof~"]"; else enum ACCESS_ROW = "0";
|
|
}
|
|
|
|
immutable int z2 = mixin(ACCESS_ROW!2);
|
|
immutable int z3 = mixin(ACCESS_ROW!6);
|
|
|
|
immutable int z1 = (z2 + z3)*FIX_0_541196100;
|
|
immutable int tmp2 = z1 + z3*(-FIX_1_847759065);
|
|
immutable int tmp3 = z1 + z2*FIX_0_765366865;
|
|
|
|
immutable int tmp0 = (mixin(ACCESS_ROW!0) + mixin(ACCESS_ROW!4)) << CONST_BITS;
|
|
immutable int tmp1 = (mixin(ACCESS_ROW!0) - mixin(ACCESS_ROW!4)) << CONST_BITS;
|
|
|
|
immutable int tmp10 = tmp0 + tmp3, tmp13 = tmp0 - tmp3, tmp11 = tmp1 + tmp2, tmp12 = tmp1 - tmp2;
|
|
|
|
immutable int atmp0 = mixin(ACCESS_ROW!7), atmp1 = mixin(ACCESS_ROW!5), atmp2 = mixin(ACCESS_ROW!3), atmp3 = mixin(ACCESS_ROW!1);
|
|
|
|
immutable int bz1 = atmp0 + atmp3, bz2 = atmp1 + atmp2, bz3 = atmp0 + atmp2, bz4 = atmp1 + atmp3;
|
|
immutable int bz5 = (bz3 + bz4)*FIX_1_175875602;
|
|
|
|
immutable int az1 = bz1*(-FIX_0_899976223);
|
|
immutable int az2 = bz2*(-FIX_2_562915447);
|
|
immutable int az3 = bz3*(-FIX_1_961570560) + bz5;
|
|
immutable int az4 = bz4*(-FIX_0_390180644) + bz5;
|
|
|
|
immutable int btmp0 = atmp0*FIX_0_298631336 + az1 + az3;
|
|
immutable int btmp1 = atmp1*FIX_2_053119869 + az2 + az4;
|
|
immutable int btmp2 = atmp2*FIX_3_072711026 + az2 + az3;
|
|
immutable int btmp3 = atmp3*FIX_1_501321110 + az1 + az4;
|
|
|
|
int i = DESCALE_ZEROSHIFT(tmp10 + btmp3, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*0] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp10 - btmp3, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*7] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp11 + btmp2, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*1] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp11 - btmp2, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*6] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp12 + btmp1, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*2] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp12 - btmp1, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*5] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp13 + btmp0, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*3] = cast(ubyte)CLAMP(i);
|
|
|
|
i = DESCALE_ZEROSHIFT(tmp13 - btmp0, CONST_BITS+PASS1_BITS+3);
|
|
pDst_ptr[8*4] = cast(ubyte)CLAMP(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static immutable ubyte[512] s_idct_row_table = [
|
|
1,0,0,0,0,0,0,0, 2,0,0,0,0,0,0,0, 2,1,0,0,0,0,0,0, 2,1,1,0,0,0,0,0, 2,2,1,0,0,0,0,0, 3,2,1,0,0,0,0,0, 4,2,1,0,0,0,0,0, 4,3,1,0,0,0,0,0,
|
|
4,3,2,0,0,0,0,0, 4,3,2,1,0,0,0,0, 4,3,2,1,1,0,0,0, 4,3,2,2,1,0,0,0, 4,3,3,2,1,0,0,0, 4,4,3,2,1,0,0,0, 5,4,3,2,1,0,0,0, 6,4,3,2,1,0,0,0,
|
|
6,5,3,2,1,0,0,0, 6,5,4,2,1,0,0,0, 6,5,4,3,1,0,0,0, 6,5,4,3,2,0,0,0, 6,5,4,3,2,1,0,0, 6,5,4,3,2,1,1,0, 6,5,4,3,2,2,1,0, 6,5,4,3,3,2,1,0,
|
|
6,5,4,4,3,2,1,0, 6,5,5,4,3,2,1,0, 6,6,5,4,3,2,1,0, 7,6,5,4,3,2,1,0, 8,6,5,4,3,2,1,0, 8,7,5,4,3,2,1,0, 8,7,6,4,3,2,1,0, 8,7,6,5,3,2,1,0,
|
|
8,7,6,5,4,2,1,0, 8,7,6,5,4,3,1,0, 8,7,6,5,4,3,2,0, 8,7,6,5,4,3,2,1, 8,7,6,5,4,3,2,2, 8,7,6,5,4,3,3,2, 8,7,6,5,4,4,3,2, 8,7,6,5,5,4,3,2,
|
|
8,7,6,6,5,4,3,2, 8,7,7,6,5,4,3,2, 8,8,7,6,5,4,3,2, 8,8,8,6,5,4,3,2, 8,8,8,7,5,4,3,2, 8,8,8,7,6,4,3,2, 8,8,8,7,6,5,3,2, 8,8,8,7,6,5,4,2,
|
|
8,8,8,7,6,5,4,3, 8,8,8,7,6,5,4,4, 8,8,8,7,6,5,5,4, 8,8,8,7,6,6,5,4, 8,8,8,7,7,6,5,4, 8,8,8,8,7,6,5,4, 8,8,8,8,8,6,5,4, 8,8,8,8,8,7,5,4,
|
|
8,8,8,8,8,7,6,4, 8,8,8,8,8,7,6,5, 8,8,8,8,8,7,6,6, 8,8,8,8,8,7,7,6, 8,8,8,8,8,8,7,6, 8,8,8,8,8,8,8,6, 8,8,8,8,8,8,8,7, 8,8,8,8,8,8,8,8,
|
|
];
|
|
|
|
static immutable ubyte[64] s_idct_col_table = [ 1, 1, 2, 3, 3, 3, 3, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 ];
|
|
|
|
void idct() (const(jpeg_decoder.jpgd_block_t)* pSrc_ptr, ubyte* pDst_ptr, int block_max_zag) {
|
|
assert(block_max_zag >= 1);
|
|
assert(block_max_zag <= 64);
|
|
|
|
if (block_max_zag <= 1)
|
|
{
|
|
int k = ((pSrc_ptr[0] + 4) >> 3) + 128;
|
|
k = CLAMP(k);
|
|
k = k | (k<<8);
|
|
k = k | (k<<16);
|
|
|
|
for (int i = 8; i > 0; i--)
|
|
{
|
|
*cast(int*)&pDst_ptr[0] = k;
|
|
*cast(int*)&pDst_ptr[4] = k;
|
|
pDst_ptr += 8;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int[64] temp;
|
|
|
|
const(jpeg_decoder.jpgd_block_t)* pSrc = pSrc_ptr;
|
|
int* pTemp = temp.ptr;
|
|
|
|
const(ubyte)* pRow_tab = &s_idct_row_table.ptr[(block_max_zag - 1) * 8];
|
|
int i;
|
|
for (i = 8; i > 0; i--, pRow_tab++)
|
|
{
|
|
switch (*pRow_tab)
|
|
{
|
|
case 0: Row!(0).idct(pTemp, pSrc); break;
|
|
case 1: Row!(1).idct(pTemp, pSrc); break;
|
|
case 2: Row!(2).idct(pTemp, pSrc); break;
|
|
case 3: Row!(3).idct(pTemp, pSrc); break;
|
|
case 4: Row!(4).idct(pTemp, pSrc); break;
|
|
case 5: Row!(5).idct(pTemp, pSrc); break;
|
|
case 6: Row!(6).idct(pTemp, pSrc); break;
|
|
case 7: Row!(7).idct(pTemp, pSrc); break;
|
|
case 8: Row!(8).idct(pTemp, pSrc); break;
|
|
default: assert(0);
|
|
}
|
|
|
|
pSrc += 8;
|
|
pTemp += 8;
|
|
}
|
|
|
|
pTemp = temp.ptr;
|
|
|
|
immutable int nonzero_rows = s_idct_col_table.ptr[block_max_zag - 1];
|
|
for (i = 8; i > 0; i--)
|
|
{
|
|
switch (nonzero_rows)
|
|
{
|
|
case 1: Col!(1).idct(pDst_ptr, pTemp); break;
|
|
case 2: Col!(2).idct(pDst_ptr, pTemp); break;
|
|
case 3: Col!(3).idct(pDst_ptr, pTemp); break;
|
|
case 4: Col!(4).idct(pDst_ptr, pTemp); break;
|
|
case 5: Col!(5).idct(pDst_ptr, pTemp); break;
|
|
case 6: Col!(6).idct(pDst_ptr, pTemp); break;
|
|
case 7: Col!(7).idct(pDst_ptr, pTemp); break;
|
|
case 8: Col!(8).idct(pDst_ptr, pTemp); break;
|
|
default: assert(0);
|
|
}
|
|
|
|
pTemp++;
|
|
pDst_ptr++;
|
|
}
|
|
}
|
|
|
|
void idct_4x4() (const(jpeg_decoder.jpgd_block_t)* pSrc_ptr, ubyte* pDst_ptr) {
|
|
int[64] temp;
|
|
int* pTemp = temp.ptr;
|
|
const(jpeg_decoder.jpgd_block_t)* pSrc = pSrc_ptr;
|
|
|
|
for (int i = 4; i > 0; i--)
|
|
{
|
|
Row!(4).idct(pTemp, pSrc);
|
|
pSrc += 8;
|
|
pTemp += 8;
|
|
}
|
|
|
|
pTemp = temp.ptr;
|
|
for (int i = 8; i > 0; i--)
|
|
{
|
|
Col!(4).idct(pDst_ptr, pTemp);
|
|
pTemp++;
|
|
pDst_ptr++;
|
|
}
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
struct jpeg_decoder {
|
|
private import core.stdc.string : memcpy, memset;
|
|
private:
|
|
static auto JPGD_MIN(T) (T a, T b) pure nothrow @safe @nogc { pragma(inline, true); return (a < b ? a : b); }
|
|
static auto JPGD_MAX(T) (T a, T b) pure nothrow @safe @nogc { pragma(inline, true); return (a > b ? a : b); }
|
|
|
|
alias jpgd_quant_t = short;
|
|
alias jpgd_block_t = short;
|
|
alias pDecode_block_func = void function (ref jpeg_decoder, int, int, int);
|
|
|
|
static struct huff_tables {
|
|
bool ac_table;
|
|
uint[256] look_up;
|
|
uint[256] look_up2;
|
|
ubyte[256] code_size;
|
|
uint[512] tree;
|
|
}
|
|
|
|
static struct coeff_buf {
|
|
ubyte* pData;
|
|
int block_num_x, block_num_y;
|
|
int block_len_x, block_len_y;
|
|
int block_size;
|
|
}
|
|
|
|
static struct mem_block {
|
|
mem_block* m_pNext;
|
|
size_t m_used_count;
|
|
size_t m_size;
|
|
char[1] m_data;
|
|
}
|
|
|
|
mem_block* m_pMem_blocks;
|
|
int m_image_x_size;
|
|
int m_image_y_size;
|
|
JpegStreamReadFunc readfn;
|
|
int m_progressive_flag;
|
|
ubyte[JPGD_MAX_HUFF_TABLES] m_huff_ac;
|
|
ubyte*[JPGD_MAX_HUFF_TABLES] m_huff_num; // pointer to number of Huffman codes per bit size
|
|
ubyte*[JPGD_MAX_HUFF_TABLES] m_huff_val; // pointer to Huffman codes per bit size
|
|
jpgd_quant_t*[JPGD_MAX_QUANT_TABLES] m_quant; // pointer to quantization tables
|
|
int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
|
|
int m_comps_in_frame; // # of components in frame
|
|
int[JPGD_MAX_COMPONENTS] m_comp_h_samp; // component's horizontal sampling factor
|
|
int[JPGD_MAX_COMPONENTS] m_comp_v_samp; // component's vertical sampling factor
|
|
int[JPGD_MAX_COMPONENTS] m_comp_quant; // component's quantization table selector
|
|
int[JPGD_MAX_COMPONENTS] m_comp_ident; // component's ID
|
|
int[JPGD_MAX_COMPONENTS] m_comp_h_blocks;
|
|
int[JPGD_MAX_COMPONENTS] m_comp_v_blocks;
|
|
int m_comps_in_scan; // # of components in scan
|
|
int[JPGD_MAX_COMPS_IN_SCAN] m_comp_list; // components in this scan
|
|
int[JPGD_MAX_COMPONENTS] m_comp_dc_tab; // component's DC Huffman coding table selector
|
|
int[JPGD_MAX_COMPONENTS] m_comp_ac_tab; // component's AC Huffman coding table selector
|
|
int m_spectral_start; // spectral selection start
|
|
int m_spectral_end; // spectral selection end
|
|
int m_successive_low; // successive approximation low
|
|
int m_successive_high; // successive approximation high
|
|
int m_max_mcu_x_size; // MCU's max. X size in pixels
|
|
int m_max_mcu_y_size; // MCU's max. Y size in pixels
|
|
int m_blocks_per_mcu;
|
|
int m_max_blocks_per_row;
|
|
int m_mcus_per_row, m_mcus_per_col;
|
|
int[JPGD_MAX_BLOCKS_PER_MCU] m_mcu_org;
|
|
int m_total_lines_left; // total # lines left in image
|
|
int m_mcu_lines_left; // total # lines left in this MCU
|
|
int m_real_dest_bytes_per_scan_line;
|
|
int m_dest_bytes_per_scan_line; // rounded up
|
|
int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y)
|
|
huff_tables*[JPGD_MAX_HUFF_TABLES] m_pHuff_tabs;
|
|
coeff_buf*[JPGD_MAX_COMPONENTS] m_dc_coeffs;
|
|
coeff_buf*[JPGD_MAX_COMPONENTS] m_ac_coeffs;
|
|
int m_eob_run;
|
|
int[JPGD_MAX_COMPONENTS] m_block_y_mcu;
|
|
ubyte* m_pIn_buf_ofs;
|
|
int m_in_buf_left;
|
|
int m_tem_flag;
|
|
bool m_eof_flag;
|
|
ubyte[128] m_in_buf_pad_start;
|
|
ubyte[JPGD_IN_BUF_SIZE+128] m_in_buf;
|
|
ubyte[128] m_in_buf_pad_end;
|
|
int m_bits_left;
|
|
uint m_bit_buf;
|
|
int m_restart_interval;
|
|
int m_restarts_left;
|
|
int m_next_restart_num;
|
|
int m_max_mcus_per_row;
|
|
int m_max_blocks_per_mcu;
|
|
int m_expanded_blocks_per_mcu;
|
|
int m_expanded_blocks_per_row;
|
|
int m_expanded_blocks_per_component;
|
|
bool m_freq_domain_chroma_upsample;
|
|
int m_max_mcus_per_col;
|
|
uint[JPGD_MAX_COMPONENTS] m_last_dc_val;
|
|
jpgd_block_t* m_pMCU_coefficients;
|
|
int[JPGD_MAX_BLOCKS_PER_MCU] m_mcu_block_max_zag;
|
|
ubyte* m_pSample_buf;
|
|
int[256] m_crr;
|
|
int[256] m_cbb;
|
|
int[256] m_crg;
|
|
int[256] m_cbg;
|
|
ubyte* m_pScan_line_0;
|
|
ubyte* m_pScan_line_1;
|
|
jpgd_status m_error_code;
|
|
bool m_ready_flag;
|
|
int m_total_bytes_read;
|
|
|
|
public:
|
|
// Inspect `error_code` after constructing to determine if the stream is valid or not. You may look at the `width`, `height`, etc.
|
|
// methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
|
|
this (JpegStreamReadFunc rfn) { decode_init(rfn); }
|
|
|
|
~this () { free_all_blocks(); }
|
|
|
|
@disable this (this); // no copies
|
|
|
|
// Call this method after constructing the object to begin decompression.
|
|
// If JPGD_SUCCESS is returned you may then call decode() on each scanline.
|
|
int begin_decoding () {
|
|
if (m_ready_flag) return JPGD_SUCCESS;
|
|
if (m_error_code) return JPGD_FAILED;
|
|
try {
|
|
decode_start();
|
|
m_ready_flag = true;
|
|
return JPGD_SUCCESS;
|
|
} catch (Exception e) {
|
|
//version(jpegd_test) {{ import core.stdc.stdio; stderr.fprintf("ERROR: %.*s...\n", cast(int)e.msg.length, e.msg.ptr); }}
|
|
version(jpegd_test) {{ import std.stdio; stderr.writeln(e.toString); }}
|
|
}
|
|
return JPGD_FAILED;
|
|
}
|
|
|
|
// Returns the next scan line.
|
|
// For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (`bytes_per_pixel` will return 1).
|
|
// Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and `bytes_per_pixel` will return 4).
|
|
// Returns JPGD_SUCCESS if a scan line has been returned.
|
|
// Returns JPGD_DONE if all scan lines have been returned.
|
|
// Returns JPGD_FAILED if an error occurred. Inspect `error_code` for a more info.
|
|
int decode (/*const void** */void** pScan_line, uint* pScan_line_len) {
|
|
if (m_error_code || !m_ready_flag) return JPGD_FAILED;
|
|
if (m_total_lines_left == 0) return JPGD_DONE;
|
|
try {
|
|
if (m_mcu_lines_left == 0) {
|
|
if (m_progressive_flag) load_next_row(); else decode_next_row();
|
|
// Find the EOI marker if that was the last row.
|
|
if (m_total_lines_left <= m_max_mcu_y_size) find_eoi();
|
|
m_mcu_lines_left = m_max_mcu_y_size;
|
|
}
|
|
if (m_freq_domain_chroma_upsample) {
|
|
expanded_convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
} else {
|
|
switch (m_scan_type) {
|
|
case JPGD_YH2V2:
|
|
if ((m_mcu_lines_left & 1) == 0) {
|
|
H2V2Convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
} else {
|
|
*pScan_line = m_pScan_line_1;
|
|
}
|
|
break;
|
|
case JPGD_YH2V1:
|
|
H2V1Convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
break;
|
|
case JPGD_YH1V2:
|
|
if ((m_mcu_lines_left & 1) == 0) {
|
|
H1V2Convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
} else {
|
|
*pScan_line = m_pScan_line_1;
|
|
}
|
|
break;
|
|
case JPGD_YH1V1:
|
|
H1V1Convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
break;
|
|
case JPGD_GRAYSCALE:
|
|
gray_convert();
|
|
*pScan_line = m_pScan_line_0;
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
*pScan_line_len = m_real_dest_bytes_per_scan_line;
|
|
--m_mcu_lines_left;
|
|
--m_total_lines_left;
|
|
return JPGD_SUCCESS;
|
|
} catch (Exception) {}
|
|
return JPGD_FAILED;
|
|
}
|
|
|
|
@property const pure nothrow @safe @nogc {
|
|
jpgd_status error_code () { pragma(inline, true); return m_error_code; }
|
|
|
|
int width () { pragma(inline, true); return m_image_x_size; }
|
|
int height () { pragma(inline, true); return m_image_y_size; }
|
|
|
|
int num_components () { pragma(inline, true); return m_comps_in_frame; }
|
|
|
|
int bytes_per_pixel () { pragma(inline, true); return m_dest_bytes_per_pixel; }
|
|
int bytes_per_scan_line () { pragma(inline, true); return m_image_x_size * bytes_per_pixel(); }
|
|
|
|
// Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
|
|
int total_bytes_read () { pragma(inline, true); return m_total_bytes_read; }
|
|
}
|
|
|
|
private:
|
|
// Retrieve one character from the input stream.
|
|
uint get_char () {
|
|
// Any bytes remaining in buffer?
|
|
if (!m_in_buf_left) {
|
|
// Try to get more bytes.
|
|
prep_in_buffer();
|
|
// Still nothing to get?
|
|
if (!m_in_buf_left) {
|
|
// Pad the end of the stream with 0xFF 0xD9 (EOI marker)
|
|
int t = m_tem_flag;
|
|
m_tem_flag ^= 1;
|
|
return (t ? 0xD9 : 0xFF);
|
|
}
|
|
}
|
|
uint c = *m_pIn_buf_ofs++;
|
|
--m_in_buf_left;
|
|
return c;
|
|
}
|
|
|
|
// Same as previous method, except can indicate if the character is a pad character or not.
|
|
uint get_char (bool* pPadding_flag) {
|
|
if (!m_in_buf_left) {
|
|
prep_in_buffer();
|
|
if (!m_in_buf_left) {
|
|
*pPadding_flag = true;
|
|
int t = m_tem_flag;
|
|
m_tem_flag ^= 1;
|
|
return (t ? 0xD9 : 0xFF);
|
|
}
|
|
}
|
|
*pPadding_flag = false;
|
|
uint c = *m_pIn_buf_ofs++;
|
|
--m_in_buf_left;
|
|
return c;
|
|
}
|
|
|
|
// Inserts a previously retrieved character back into the input buffer.
|
|
void stuff_char (ubyte q) {
|
|
*(--m_pIn_buf_ofs) = q;
|
|
m_in_buf_left++;
|
|
}
|
|
|
|
// Retrieves one character from the input stream, but does not read past markers. Will continue to return 0xFF when a marker is encountered.
|
|
ubyte get_octet () {
|
|
bool padding_flag;
|
|
int c = get_char(&padding_flag);
|
|
if (c == 0xFF) {
|
|
if (padding_flag) return 0xFF;
|
|
c = get_char(&padding_flag);
|
|
if (padding_flag) { stuff_char(0xFF); return 0xFF; }
|
|
if (c == 0x00) return 0xFF;
|
|
stuff_char(cast(ubyte)(c));
|
|
stuff_char(0xFF);
|
|
return 0xFF;
|
|
}
|
|
return cast(ubyte)(c);
|
|
}
|
|
|
|
// Retrieves a variable number of bits from the input stream. Does not recognize markers.
|
|
uint get_bits (int num_bits) {
|
|
if (!num_bits) return 0;
|
|
uint i = m_bit_buf >> (32 - num_bits);
|
|
if ((m_bits_left -= num_bits) <= 0) {
|
|
m_bit_buf <<= (num_bits += m_bits_left);
|
|
uint c1 = get_char();
|
|
uint c2 = get_char();
|
|
m_bit_buf = (m_bit_buf & 0xFFFF0000) | (c1 << 8) | c2;
|
|
m_bit_buf <<= -m_bits_left;
|
|
m_bits_left += 16;
|
|
assert(m_bits_left >= 0);
|
|
} else {
|
|
m_bit_buf <<= num_bits;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// Retrieves a variable number of bits from the input stream. Markers will not be read into the input bit buffer. Instead, an infinite number of all 1's will be returned when a marker is encountered.
|
|
uint get_bits_no_markers (int num_bits) {
|
|
if (!num_bits) return 0;
|
|
uint i = m_bit_buf >> (32 - num_bits);
|
|
if ((m_bits_left -= num_bits) <= 0) {
|
|
m_bit_buf <<= (num_bits += m_bits_left);
|
|
if (m_in_buf_left < 2 || m_pIn_buf_ofs[0] == 0xFF || m_pIn_buf_ofs[1] == 0xFF) {
|
|
uint c1 = get_octet();
|
|
uint c2 = get_octet();
|
|
m_bit_buf |= (c1 << 8) | c2;
|
|
} else {
|
|
m_bit_buf |= (cast(uint)m_pIn_buf_ofs[0] << 8) | m_pIn_buf_ofs[1];
|
|
m_in_buf_left -= 2;
|
|
m_pIn_buf_ofs += 2;
|
|
}
|
|
m_bit_buf <<= -m_bits_left;
|
|
m_bits_left += 16;
|
|
assert(m_bits_left >= 0);
|
|
} else {
|
|
m_bit_buf <<= num_bits;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// Decodes a Huffman encoded symbol.
|
|
int huff_decode (huff_tables *pH) {
|
|
int symbol;
|
|
// Check first 8-bits: do we have a complete symbol?
|
|
if ((symbol = pH.look_up.ptr[m_bit_buf >> 24]) < 0) {
|
|
// Decode more bits, use a tree traversal to find symbol.
|
|
int ofs = 23;
|
|
do {
|
|
symbol = pH.tree.ptr[-cast(int)(symbol + ((m_bit_buf >> ofs) & 1))];
|
|
--ofs;
|
|
} while (symbol < 0);
|
|
get_bits_no_markers(8 + (23 - ofs));
|
|
} else {
|
|
get_bits_no_markers(pH.code_size.ptr[symbol]);
|
|
}
|
|
return symbol;
|
|
}
|
|
|
|
// Decodes a Huffman encoded symbol.
|
|
int huff_decode (huff_tables *pH, ref int extra_bits) {
|
|
int symbol;
|
|
// Check first 8-bits: do we have a complete symbol?
|
|
if ((symbol = pH.look_up2.ptr[m_bit_buf >> 24]) < 0) {
|
|
// Use a tree traversal to find symbol.
|
|
int ofs = 23;
|
|
do {
|
|
symbol = pH.tree.ptr[-cast(int)(symbol + ((m_bit_buf >> ofs) & 1))];
|
|
--ofs;
|
|
} while (symbol < 0);
|
|
get_bits_no_markers(8 + (23 - ofs));
|
|
extra_bits = get_bits_no_markers(symbol & 0xF);
|
|
} else {
|
|
assert(((symbol >> 8) & 31) == pH.code_size.ptr[symbol & 255] + ((symbol & 0x8000) ? (symbol & 15) : 0));
|
|
if (symbol & 0x8000) {
|
|
get_bits_no_markers((symbol >> 8) & 31);
|
|
extra_bits = symbol >> 16;
|
|
} else {
|
|
int code_size = (symbol >> 8) & 31;
|
|
int num_extra_bits = symbol & 0xF;
|
|
int bits = code_size + num_extra_bits;
|
|
if (bits <= (m_bits_left + 16)) {
|
|
extra_bits = get_bits_no_markers(bits) & ((1 << num_extra_bits) - 1);
|
|
} else {
|
|
get_bits_no_markers(code_size);
|
|
extra_bits = get_bits_no_markers(num_extra_bits);
|
|
}
|
|
}
|
|
symbol &= 0xFF;
|
|
}
|
|
return symbol;
|
|
}
|
|
|
|
// Tables and macro used to fully decode the DPCM differences.
|
|
static immutable int[16] s_extend_test = [ 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 ];
|
|
static immutable int[16] s_extend_offset = [ 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 ];
|
|
static immutable int[18] s_extend_mask = [ 0, (1<<0), (1<<1), (1<<2), (1<<3), (1<<4), (1<<5), (1<<6), (1<<7), (1<<8), (1<<9), (1<<10), (1<<11), (1<<12), (1<<13), (1<<14), (1<<15), (1<<16) ];
|
|
// The logical AND's in this macro are to shut up static code analysis (aren't really necessary - couldn't find another way to do this)
|
|
//#define JPGD_HUFF_EXTEND(x, s) (((x) < s_extend_test[s & 15]) ? ((x) + s_extend_offset[s & 15]) : (x))
|
|
static JPGD_HUFF_EXTEND (int x, int s) nothrow @trusted @nogc { pragma(inline, true); return (((x) < s_extend_test.ptr[s & 15]) ? ((x) + s_extend_offset.ptr[s & 15]) : (x)); }
|
|
|
|
// Clamps a value between 0-255.
|
|
//static ubyte clamp (int i) { if (cast(uint)(i) > 255) i = (((~i) >> 31) & 0xFF); return cast(ubyte)(i); }
|
|
alias clamp = CLAMP;
|
|
|
|
static struct DCT_Upsample {
|
|
static:
|
|
static struct Matrix44 {
|
|
pure nothrow @trusted @nogc:
|
|
alias Element_Type = int;
|
|
enum { NUM_ROWS = 4, NUM_COLS = 4 }
|
|
|
|
Element_Type[NUM_COLS][NUM_ROWS] v;
|
|
|
|
this() (in auto ref Matrix44 m) {
|
|
foreach (immutable r; 0..NUM_ROWS) v[r][] = m.v[r][];
|
|
}
|
|
|
|
//@property int rows () const { pragma(inline, true); return NUM_ROWS; }
|
|
//@property int cols () const { pragma(inline, true); return NUM_COLS; }
|
|
|
|
ref inout(Element_Type) at (int r, int c) inout { pragma(inline, true); return v.ptr[r].ptr[c]; }
|
|
|
|
ref Matrix44 opOpAssign(string op:"+") (in auto ref Matrix44 a) {
|
|
foreach (int r; 0..NUM_ROWS) {
|
|
at(r, 0) += a.at(r, 0);
|
|
at(r, 1) += a.at(r, 1);
|
|
at(r, 2) += a.at(r, 2);
|
|
at(r, 3) += a.at(r, 3);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
ref Matrix44 opOpAssign(string op:"-") (in auto ref Matrix44 a) {
|
|
foreach (int r; 0..NUM_ROWS) {
|
|
at(r, 0) -= a.at(r, 0);
|
|
at(r, 1) -= a.at(r, 1);
|
|
at(r, 2) -= a.at(r, 2);
|
|
at(r, 3) -= a.at(r, 3);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
Matrix44 opBinary(string op:"+") (in auto ref Matrix44 b) const {
|
|
alias a = this;
|
|
Matrix44 ret;
|
|
foreach (int r; 0..NUM_ROWS) {
|
|
ret.at(r, 0) = a.at(r, 0) + b.at(r, 0);
|
|
ret.at(r, 1) = a.at(r, 1) + b.at(r, 1);
|
|
ret.at(r, 2) = a.at(r, 2) + b.at(r, 2);
|
|
ret.at(r, 3) = a.at(r, 3) + b.at(r, 3);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Matrix44 opBinary(string op:"-") (in auto ref Matrix44 b) const {
|
|
alias a = this;
|
|
Matrix44 ret;
|
|
foreach (int r; 0..NUM_ROWS) {
|
|
ret.at(r, 0) = a.at(r, 0) - b.at(r, 0);
|
|
ret.at(r, 1) = a.at(r, 1) - b.at(r, 1);
|
|
ret.at(r, 2) = a.at(r, 2) - b.at(r, 2);
|
|
ret.at(r, 3) = a.at(r, 3) - b.at(r, 3);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void add_and_store() (jpgd_block_t* pDst, in auto ref Matrix44 a, in auto ref Matrix44 b) {
|
|
foreach (int r; 0..4) {
|
|
pDst[0*8 + r] = cast(jpgd_block_t)(a.at(r, 0) + b.at(r, 0));
|
|
pDst[1*8 + r] = cast(jpgd_block_t)(a.at(r, 1) + b.at(r, 1));
|
|
pDst[2*8 + r] = cast(jpgd_block_t)(a.at(r, 2) + b.at(r, 2));
|
|
pDst[3*8 + r] = cast(jpgd_block_t)(a.at(r, 3) + b.at(r, 3));
|
|
}
|
|
}
|
|
|
|
static void sub_and_store() (jpgd_block_t* pDst, in auto ref Matrix44 a, in auto ref Matrix44 b) {
|
|
foreach (int r; 0..4) {
|
|
pDst[0*8 + r] = cast(jpgd_block_t)(a.at(r, 0) - b.at(r, 0));
|
|
pDst[1*8 + r] = cast(jpgd_block_t)(a.at(r, 1) - b.at(r, 1));
|
|
pDst[2*8 + r] = cast(jpgd_block_t)(a.at(r, 2) - b.at(r, 2));
|
|
pDst[3*8 + r] = cast(jpgd_block_t)(a.at(r, 3) - b.at(r, 3));
|
|
}
|
|
}
|
|
}
|
|
|
|
enum FRACT_BITS = 10;
|
|
enum SCALE = 1 << FRACT_BITS;
|
|
|
|
alias Temp_Type = int;
|
|
//TODO: convert defines to mixins
|
|
//#define D(i) (((i) + (SCALE >> 1)) >> FRACT_BITS)
|
|
//#define F(i) ((int)((i) * SCALE + .5f))
|
|
// Any decent C++ compiler will optimize this at compile time to a 0, or an array access.
|
|
//#define AT(c, r) ((((c)>=NUM_COLS)||((r)>=NUM_ROWS)) ? 0 : pSrc[(c)+(r)*8])
|
|
|
|
static int D(T) (T i) { pragma(inline, true); return (((i) + (SCALE >> 1)) >> FRACT_BITS); }
|
|
enum F(float i) = (cast(int)((i) * SCALE + 0.5f));
|
|
|
|
// NUM_ROWS/NUM_COLS = # of non-zero rows/cols in input matrix
|
|
static struct P_Q(int NUM_ROWS, int NUM_COLS) {
|
|
static void calc (ref Matrix44 P, ref Matrix44 Q, const(jpgd_block_t)* pSrc) {
|
|
//auto AT (int c, int r) nothrow @trusted @nogc { return (c >= NUM_COLS || r >= NUM_ROWS ? 0 : pSrc[c+r*8]); }
|
|
template AT(int c, int r) {
|
|
static if (c >= NUM_COLS || r >= NUM_ROWS) enum AT = "0"; else enum AT = "pSrc["~c.stringof~"+"~r.stringof~"*8]";
|
|
}
|
|
// 4x8 = 4x8 times 8x8, matrix 0 is constant
|
|
immutable Temp_Type X000 = mixin(AT!(0, 0));
|
|
immutable Temp_Type X001 = mixin(AT!(0, 1));
|
|
immutable Temp_Type X002 = mixin(AT!(0, 2));
|
|
immutable Temp_Type X003 = mixin(AT!(0, 3));
|
|
immutable Temp_Type X004 = mixin(AT!(0, 4));
|
|
immutable Temp_Type X005 = mixin(AT!(0, 5));
|
|
immutable Temp_Type X006 = mixin(AT!(0, 6));
|
|
immutable Temp_Type X007 = mixin(AT!(0, 7));
|
|
immutable Temp_Type X010 = D(F!(0.415735f) * mixin(AT!(1, 0)) + F!(0.791065f) * mixin(AT!(3, 0)) + F!(-0.352443f) * mixin(AT!(5, 0)) + F!(0.277785f) * mixin(AT!(7, 0)));
|
|
immutable Temp_Type X011 = D(F!(0.415735f) * mixin(AT!(1, 1)) + F!(0.791065f) * mixin(AT!(3, 1)) + F!(-0.352443f) * mixin(AT!(5, 1)) + F!(0.277785f) * mixin(AT!(7, 1)));
|
|
immutable Temp_Type X012 = D(F!(0.415735f) * mixin(AT!(1, 2)) + F!(0.791065f) * mixin(AT!(3, 2)) + F!(-0.352443f) * mixin(AT!(5, 2)) + F!(0.277785f) * mixin(AT!(7, 2)));
|
|
immutable Temp_Type X013 = D(F!(0.415735f) * mixin(AT!(1, 3)) + F!(0.791065f) * mixin(AT!(3, 3)) + F!(-0.352443f) * mixin(AT!(5, 3)) + F!(0.277785f) * mixin(AT!(7, 3)));
|
|
immutable Temp_Type X014 = D(F!(0.415735f) * mixin(AT!(1, 4)) + F!(0.791065f) * mixin(AT!(3, 4)) + F!(-0.352443f) * mixin(AT!(5, 4)) + F!(0.277785f) * mixin(AT!(7, 4)));
|
|
immutable Temp_Type X015 = D(F!(0.415735f) * mixin(AT!(1, 5)) + F!(0.791065f) * mixin(AT!(3, 5)) + F!(-0.352443f) * mixin(AT!(5, 5)) + F!(0.277785f) * mixin(AT!(7, 5)));
|
|
immutable Temp_Type X016 = D(F!(0.415735f) * mixin(AT!(1, 6)) + F!(0.791065f) * mixin(AT!(3, 6)) + F!(-0.352443f) * mixin(AT!(5, 6)) + F!(0.277785f) * mixin(AT!(7, 6)));
|
|
immutable Temp_Type X017 = D(F!(0.415735f) * mixin(AT!(1, 7)) + F!(0.791065f) * mixin(AT!(3, 7)) + F!(-0.352443f) * mixin(AT!(5, 7)) + F!(0.277785f) * mixin(AT!(7, 7)));
|
|
immutable Temp_Type X020 = mixin(AT!(4, 0));
|
|
immutable Temp_Type X021 = mixin(AT!(4, 1));
|
|
immutable Temp_Type X022 = mixin(AT!(4, 2));
|
|
immutable Temp_Type X023 = mixin(AT!(4, 3));
|
|
immutable Temp_Type X024 = mixin(AT!(4, 4));
|
|
immutable Temp_Type X025 = mixin(AT!(4, 5));
|
|
immutable Temp_Type X026 = mixin(AT!(4, 6));
|
|
immutable Temp_Type X027 = mixin(AT!(4, 7));
|
|
immutable Temp_Type X030 = D(F!(0.022887f) * mixin(AT!(1, 0)) + F!(-0.097545f) * mixin(AT!(3, 0)) + F!(0.490393f) * mixin(AT!(5, 0)) + F!(0.865723f) * mixin(AT!(7, 0)));
|
|
immutable Temp_Type X031 = D(F!(0.022887f) * mixin(AT!(1, 1)) + F!(-0.097545f) * mixin(AT!(3, 1)) + F!(0.490393f) * mixin(AT!(5, 1)) + F!(0.865723f) * mixin(AT!(7, 1)));
|
|
immutable Temp_Type X032 = D(F!(0.022887f) * mixin(AT!(1, 2)) + F!(-0.097545f) * mixin(AT!(3, 2)) + F!(0.490393f) * mixin(AT!(5, 2)) + F!(0.865723f) * mixin(AT!(7, 2)));
|
|
immutable Temp_Type X033 = D(F!(0.022887f) * mixin(AT!(1, 3)) + F!(-0.097545f) * mixin(AT!(3, 3)) + F!(0.490393f) * mixin(AT!(5, 3)) + F!(0.865723f) * mixin(AT!(7, 3)));
|
|
immutable Temp_Type X034 = D(F!(0.022887f) * mixin(AT!(1, 4)) + F!(-0.097545f) * mixin(AT!(3, 4)) + F!(0.490393f) * mixin(AT!(5, 4)) + F!(0.865723f) * mixin(AT!(7, 4)));
|
|
immutable Temp_Type X035 = D(F!(0.022887f) * mixin(AT!(1, 5)) + F!(-0.097545f) * mixin(AT!(3, 5)) + F!(0.490393f) * mixin(AT!(5, 5)) + F!(0.865723f) * mixin(AT!(7, 5)));
|
|
immutable Temp_Type X036 = D(F!(0.022887f) * mixin(AT!(1, 6)) + F!(-0.097545f) * mixin(AT!(3, 6)) + F!(0.490393f) * mixin(AT!(5, 6)) + F!(0.865723f) * mixin(AT!(7, 6)));
|
|
immutable Temp_Type X037 = D(F!(0.022887f) * mixin(AT!(1, 7)) + F!(-0.097545f) * mixin(AT!(3, 7)) + F!(0.490393f) * mixin(AT!(5, 7)) + F!(0.865723f) * mixin(AT!(7, 7)));
|
|
|
|
// 4x4 = 4x8 times 8x4, matrix 1 is constant
|
|
P.at(0, 0) = X000;
|
|
P.at(0, 1) = D(X001 * F!(0.415735f) + X003 * F!(0.791065f) + X005 * F!(-0.352443f) + X007 * F!(0.277785f));
|
|
P.at(0, 2) = X004;
|
|
P.at(0, 3) = D(X001 * F!(0.022887f) + X003 * F!(-0.097545f) + X005 * F!(0.490393f) + X007 * F!(0.865723f));
|
|
P.at(1, 0) = X010;
|
|
P.at(1, 1) = D(X011 * F!(0.415735f) + X013 * F!(0.791065f) + X015 * F!(-0.352443f) + X017 * F!(0.277785f));
|
|
P.at(1, 2) = X014;
|
|
P.at(1, 3) = D(X011 * F!(0.022887f) + X013 * F!(-0.097545f) + X015 * F!(0.490393f) + X017 * F!(0.865723f));
|
|
P.at(2, 0) = X020;
|
|
P.at(2, 1) = D(X021 * F!(0.415735f) + X023 * F!(0.791065f) + X025 * F!(-0.352443f) + X027 * F!(0.277785f));
|
|
P.at(2, 2) = X024;
|
|
P.at(2, 3) = D(X021 * F!(0.022887f) + X023 * F!(-0.097545f) + X025 * F!(0.490393f) + X027 * F!(0.865723f));
|
|
P.at(3, 0) = X030;
|
|
P.at(3, 1) = D(X031 * F!(0.415735f) + X033 * F!(0.791065f) + X035 * F!(-0.352443f) + X037 * F!(0.277785f));
|
|
P.at(3, 2) = X034;
|
|
P.at(3, 3) = D(X031 * F!(0.022887f) + X033 * F!(-0.097545f) + X035 * F!(0.490393f) + X037 * F!(0.865723f));
|
|
// 40 muls 24 adds
|
|
|
|
// 4x4 = 4x8 times 8x4, matrix 1 is constant
|
|
Q.at(0, 0) = D(X001 * F!(0.906127f) + X003 * F!(-0.318190f) + X005 * F!(0.212608f) + X007 * F!(-0.180240f));
|
|
Q.at(0, 1) = X002;
|
|
Q.at(0, 2) = D(X001 * F!(-0.074658f) + X003 * F!(0.513280f) + X005 * F!(0.768178f) + X007 * F!(-0.375330f));
|
|
Q.at(0, 3) = X006;
|
|
Q.at(1, 0) = D(X011 * F!(0.906127f) + X013 * F!(-0.318190f) + X015 * F!(0.212608f) + X017 * F!(-0.180240f));
|
|
Q.at(1, 1) = X012;
|
|
Q.at(1, 2) = D(X011 * F!(-0.074658f) + X013 * F!(0.513280f) + X015 * F!(0.768178f) + X017 * F!(-0.375330f));
|
|
Q.at(1, 3) = X016;
|
|
Q.at(2, 0) = D(X021 * F!(0.906127f) + X023 * F!(-0.318190f) + X025 * F!(0.212608f) + X027 * F!(-0.180240f));
|
|
Q.at(2, 1) = X022;
|
|
Q.at(2, 2) = D(X021 * F!(-0.074658f) + X023 * F!(0.513280f) + X025 * F!(0.768178f) + X027 * F!(-0.375330f));
|
|
Q.at(2, 3) = X026;
|
|
Q.at(3, 0) = D(X031 * F!(0.906127f) + X033 * F!(-0.318190f) + X035 * F!(0.212608f) + X037 * F!(-0.180240f));
|
|
Q.at(3, 1) = X032;
|
|
Q.at(3, 2) = D(X031 * F!(-0.074658f) + X033 * F!(0.513280f) + X035 * F!(0.768178f) + X037 * F!(-0.375330f));
|
|
Q.at(3, 3) = X036;
|
|
// 40 muls 24 adds
|
|
}
|
|
}
|
|
|
|
static struct R_S(int NUM_ROWS, int NUM_COLS) {
|
|
static void calc(ref Matrix44 R, ref Matrix44 S, const(jpgd_block_t)* pSrc) {
|
|
//auto AT (int c, int r) nothrow @trusted @nogc { return (c >= NUM_COLS || r >= NUM_ROWS ? 0 : pSrc[c+r*8]); }
|
|
template AT(int c, int r) {
|
|
static if (c >= NUM_COLS || r >= NUM_ROWS) enum AT = "0"; else enum AT = "pSrc["~c.stringof~"+"~r.stringof~"*8]";
|
|
}
|
|
// 4x8 = 4x8 times 8x8, matrix 0 is constant
|
|
immutable Temp_Type X100 = D(F!(0.906127f) * mixin(AT!(1, 0)) + F!(-0.318190f) * mixin(AT!(3, 0)) + F!(0.212608f) * mixin(AT!(5, 0)) + F!(-0.180240f) * mixin(AT!(7, 0)));
|
|
immutable Temp_Type X101 = D(F!(0.906127f) * mixin(AT!(1, 1)) + F!(-0.318190f) * mixin(AT!(3, 1)) + F!(0.212608f) * mixin(AT!(5, 1)) + F!(-0.180240f) * mixin(AT!(7, 1)));
|
|
immutable Temp_Type X102 = D(F!(0.906127f) * mixin(AT!(1, 2)) + F!(-0.318190f) * mixin(AT!(3, 2)) + F!(0.212608f) * mixin(AT!(5, 2)) + F!(-0.180240f) * mixin(AT!(7, 2)));
|
|
immutable Temp_Type X103 = D(F!(0.906127f) * mixin(AT!(1, 3)) + F!(-0.318190f) * mixin(AT!(3, 3)) + F!(0.212608f) * mixin(AT!(5, 3)) + F!(-0.180240f) * mixin(AT!(7, 3)));
|
|
immutable Temp_Type X104 = D(F!(0.906127f) * mixin(AT!(1, 4)) + F!(-0.318190f) * mixin(AT!(3, 4)) + F!(0.212608f) * mixin(AT!(5, 4)) + F!(-0.180240f) * mixin(AT!(7, 4)));
|
|
immutable Temp_Type X105 = D(F!(0.906127f) * mixin(AT!(1, 5)) + F!(-0.318190f) * mixin(AT!(3, 5)) + F!(0.212608f) * mixin(AT!(5, 5)) + F!(-0.180240f) * mixin(AT!(7, 5)));
|
|
immutable Temp_Type X106 = D(F!(0.906127f) * mixin(AT!(1, 6)) + F!(-0.318190f) * mixin(AT!(3, 6)) + F!(0.212608f) * mixin(AT!(5, 6)) + F!(-0.180240f) * mixin(AT!(7, 6)));
|
|
immutable Temp_Type X107 = D(F!(0.906127f) * mixin(AT!(1, 7)) + F!(-0.318190f) * mixin(AT!(3, 7)) + F!(0.212608f) * mixin(AT!(5, 7)) + F!(-0.180240f) * mixin(AT!(7, 7)));
|
|
immutable Temp_Type X110 = mixin(AT!(2, 0));
|
|
immutable Temp_Type X111 = mixin(AT!(2, 1));
|
|
immutable Temp_Type X112 = mixin(AT!(2, 2));
|
|
immutable Temp_Type X113 = mixin(AT!(2, 3));
|
|
immutable Temp_Type X114 = mixin(AT!(2, 4));
|
|
immutable Temp_Type X115 = mixin(AT!(2, 5));
|
|
immutable Temp_Type X116 = mixin(AT!(2, 6));
|
|
immutable Temp_Type X117 = mixin(AT!(2, 7));
|
|
immutable Temp_Type X120 = D(F!(-0.074658f) * mixin(AT!(1, 0)) + F!(0.513280f) * mixin(AT!(3, 0)) + F!(0.768178f) * mixin(AT!(5, 0)) + F!(-0.375330f) * mixin(AT!(7, 0)));
|
|
immutable Temp_Type X121 = D(F!(-0.074658f) * mixin(AT!(1, 1)) + F!(0.513280f) * mixin(AT!(3, 1)) + F!(0.768178f) * mixin(AT!(5, 1)) + F!(-0.375330f) * mixin(AT!(7, 1)));
|
|
immutable Temp_Type X122 = D(F!(-0.074658f) * mixin(AT!(1, 2)) + F!(0.513280f) * mixin(AT!(3, 2)) + F!(0.768178f) * mixin(AT!(5, 2)) + F!(-0.375330f) * mixin(AT!(7, 2)));
|
|
immutable Temp_Type X123 = D(F!(-0.074658f) * mixin(AT!(1, 3)) + F!(0.513280f) * mixin(AT!(3, 3)) + F!(0.768178f) * mixin(AT!(5, 3)) + F!(-0.375330f) * mixin(AT!(7, 3)));
|
|
immutable Temp_Type X124 = D(F!(-0.074658f) * mixin(AT!(1, 4)) + F!(0.513280f) * mixin(AT!(3, 4)) + F!(0.768178f) * mixin(AT!(5, 4)) + F!(-0.375330f) * mixin(AT!(7, 4)));
|
|
immutable Temp_Type X125 = D(F!(-0.074658f) * mixin(AT!(1, 5)) + F!(0.513280f) * mixin(AT!(3, 5)) + F!(0.768178f) * mixin(AT!(5, 5)) + F!(-0.375330f) * mixin(AT!(7, 5)));
|
|
immutable Temp_Type X126 = D(F!(-0.074658f) * mixin(AT!(1, 6)) + F!(0.513280f) * mixin(AT!(3, 6)) + F!(0.768178f) * mixin(AT!(5, 6)) + F!(-0.375330f) * mixin(AT!(7, 6)));
|
|
immutable Temp_Type X127 = D(F!(-0.074658f) * mixin(AT!(1, 7)) + F!(0.513280f) * mixin(AT!(3, 7)) + F!(0.768178f) * mixin(AT!(5, 7)) + F!(-0.375330f) * mixin(AT!(7, 7)));
|
|
immutable Temp_Type X130 = mixin(AT!(6, 0));
|
|
immutable Temp_Type X131 = mixin(AT!(6, 1));
|
|
immutable Temp_Type X132 = mixin(AT!(6, 2));
|
|
immutable Temp_Type X133 = mixin(AT!(6, 3));
|
|
immutable Temp_Type X134 = mixin(AT!(6, 4));
|
|
immutable Temp_Type X135 = mixin(AT!(6, 5));
|
|
immutable Temp_Type X136 = mixin(AT!(6, 6));
|
|
immutable Temp_Type X137 = mixin(AT!(6, 7));
|
|
// 80 muls 48 adds
|
|
|
|
// 4x4 = 4x8 times 8x4, matrix 1 is constant
|
|
R.at(0, 0) = X100;
|
|
R.at(0, 1) = D(X101 * F!(0.415735f) + X103 * F!(0.791065f) + X105 * F!(-0.352443f) + X107 * F!(0.277785f));
|
|
R.at(0, 2) = X104;
|
|
R.at(0, 3) = D(X101 * F!(0.022887f) + X103 * F!(-0.097545f) + X105 * F!(0.490393f) + X107 * F!(0.865723f));
|
|
R.at(1, 0) = X110;
|
|
R.at(1, 1) = D(X111 * F!(0.415735f) + X113 * F!(0.791065f) + X115 * F!(-0.352443f) + X117 * F!(0.277785f));
|
|
R.at(1, 2) = X114;
|
|
R.at(1, 3) = D(X111 * F!(0.022887f) + X113 * F!(-0.097545f) + X115 * F!(0.490393f) + X117 * F!(0.865723f));
|
|
R.at(2, 0) = X120;
|
|
R.at(2, 1) = D(X121 * F!(0.415735f) + X123 * F!(0.791065f) + X125 * F!(-0.352443f) + X127 * F!(0.277785f));
|
|
R.at(2, 2) = X124;
|
|
R.at(2, 3) = D(X121 * F!(0.022887f) + X123 * F!(-0.097545f) + X125 * F!(0.490393f) + X127 * F!(0.865723f));
|
|
R.at(3, 0) = X130;
|
|
R.at(3, 1) = D(X131 * F!(0.415735f) + X133 * F!(0.791065f) + X135 * F!(-0.352443f) + X137 * F!(0.277785f));
|
|
R.at(3, 2) = X134;
|
|
R.at(3, 3) = D(X131 * F!(0.022887f) + X133 * F!(-0.097545f) + X135 * F!(0.490393f) + X137 * F!(0.865723f));
|
|
// 40 muls 24 adds
|
|
// 4x4 = 4x8 times 8x4, matrix 1 is constant
|
|
S.at(0, 0) = D(X101 * F!(0.906127f) + X103 * F!(-0.318190f) + X105 * F!(0.212608f) + X107 * F!(-0.180240f));
|
|
S.at(0, 1) = X102;
|
|
S.at(0, 2) = D(X101 * F!(-0.074658f) + X103 * F!(0.513280f) + X105 * F!(0.768178f) + X107 * F!(-0.375330f));
|
|
S.at(0, 3) = X106;
|
|
S.at(1, 0) = D(X111 * F!(0.906127f) + X113 * F!(-0.318190f) + X115 * F!(0.212608f) + X117 * F!(-0.180240f));
|
|
S.at(1, 1) = X112;
|
|
S.at(1, 2) = D(X111 * F!(-0.074658f) + X113 * F!(0.513280f) + X115 * F!(0.768178f) + X117 * F!(-0.375330f));
|
|
S.at(1, 3) = X116;
|
|
S.at(2, 0) = D(X121 * F!(0.906127f) + X123 * F!(-0.318190f) + X125 * F!(0.212608f) + X127 * F!(-0.180240f));
|
|
S.at(2, 1) = X122;
|
|
S.at(2, 2) = D(X121 * F!(-0.074658f) + X123 * F!(0.513280f) + X125 * F!(0.768178f) + X127 * F!(-0.375330f));
|
|
S.at(2, 3) = X126;
|
|
S.at(3, 0) = D(X131 * F!(0.906127f) + X133 * F!(-0.318190f) + X135 * F!(0.212608f) + X137 * F!(-0.180240f));
|
|
S.at(3, 1) = X132;
|
|
S.at(3, 2) = D(X131 * F!(-0.074658f) + X133 * F!(0.513280f) + X135 * F!(0.768178f) + X137 * F!(-0.375330f));
|
|
S.at(3, 3) = X136;
|
|
// 40 muls 24 adds
|
|
}
|
|
}
|
|
} // end namespace DCT_Upsample
|
|
|
|
// Unconditionally frees all allocated m_blocks.
|
|
void free_all_blocks () {
|
|
//m_pStream = null;
|
|
readfn = null;
|
|
for (mem_block *b = m_pMem_blocks; b; ) {
|
|
mem_block* n = b.m_pNext;
|
|
jpgd_free(b);
|
|
b = n;
|
|
}
|
|
m_pMem_blocks = null;
|
|
}
|
|
|
|
// This method handles all errors. It will never return.
|
|
// It could easily be changed to use C++ exceptions.
|
|
/*JPGD_NORETURN*/ void stop_decoding (jpgd_status status, size_t line=__LINE__) {
|
|
m_error_code = status;
|
|
free_all_blocks();
|
|
//longjmp(m_jmp_state, status);
|
|
throw new Exception("jpeg decoding error", __FILE__, line);
|
|
}
|
|
|
|
void* alloc (size_t nSize, bool zero=false) {
|
|
nSize = (JPGD_MAX(nSize, 1) + 3) & ~3;
|
|
char *rv = null;
|
|
for (mem_block *b = m_pMem_blocks; b; b = b.m_pNext)
|
|
{
|
|
if ((b.m_used_count + nSize) <= b.m_size)
|
|
{
|
|
rv = b.m_data.ptr + b.m_used_count;
|
|
b.m_used_count += nSize;
|
|
break;
|
|
}
|
|
}
|
|
if (!rv)
|
|
{
|
|
size_t capacity = JPGD_MAX(32768 - 256, (nSize + 2047) & ~2047);
|
|
mem_block *b = cast(mem_block*)jpgd_malloc(mem_block.sizeof + capacity);
|
|
if (!b) { stop_decoding(JPGD_NOTENOUGHMEM); }
|
|
b.m_pNext = m_pMem_blocks; m_pMem_blocks = b;
|
|
b.m_used_count = nSize;
|
|
b.m_size = capacity;
|
|
rv = b.m_data.ptr;
|
|
}
|
|
if (zero) memset(rv, 0, nSize);
|
|
return rv;
|
|
}
|
|
|
|
void word_clear (void *p, ushort c, uint n) {
|
|
ubyte *pD = cast(ubyte*)p;
|
|
immutable ubyte l = c & 0xFF, h = (c >> 8) & 0xFF;
|
|
while (n)
|
|
{
|
|
pD[0] = l; pD[1] = h; pD += 2;
|
|
n--;
|
|
}
|
|
}
|
|
|
|
// Refill the input buffer.
|
|
// This method will sit in a loop until (A) the buffer is full or (B)
|
|
// the stream's read() method reports and end of file condition.
|
|
void prep_in_buffer () {
|
|
m_in_buf_left = 0;
|
|
m_pIn_buf_ofs = m_in_buf.ptr;
|
|
|
|
if (m_eof_flag)
|
|
return;
|
|
|
|
do
|
|
{
|
|
int bytes_read = readfn(m_in_buf.ptr + m_in_buf_left, JPGD_IN_BUF_SIZE - m_in_buf_left, &m_eof_flag);
|
|
if (bytes_read == -1)
|
|
stop_decoding(JPGD_STREAM_READ);
|
|
|
|
m_in_buf_left += bytes_read;
|
|
} while ((m_in_buf_left < JPGD_IN_BUF_SIZE) && (!m_eof_flag));
|
|
|
|
m_total_bytes_read += m_in_buf_left;
|
|
|
|
// Pad the end of the block with M_EOI (prevents the decompressor from going off the rails if the stream is invalid).
|
|
// (This dates way back to when this decompressor was written in C/asm, and the all-asm Huffman decoder did some fancy things to increase perf.)
|
|
word_clear(m_pIn_buf_ofs + m_in_buf_left, 0xD9FF, 64);
|
|
}
|
|
|
|
// Read a Huffman code table.
|
|
void read_dht_marker () {
|
|
int i, index, count;
|
|
ubyte[17] huff_num;
|
|
ubyte[256] huff_val;
|
|
|
|
uint num_left = get_bits(16);
|
|
|
|
if (num_left < 2)
|
|
stop_decoding(JPGD_BAD_DHT_MARKER);
|
|
|
|
num_left -= 2;
|
|
|
|
while (num_left)
|
|
{
|
|
index = get_bits(8);
|
|
|
|
huff_num.ptr[0] = 0;
|
|
|
|
count = 0;
|
|
|
|
for (i = 1; i <= 16; i++)
|
|
{
|
|
huff_num.ptr[i] = cast(ubyte)(get_bits(8));
|
|
count += huff_num.ptr[i];
|
|
}
|
|
|
|
if (count > 255)
|
|
stop_decoding(JPGD_BAD_DHT_COUNTS);
|
|
|
|
for (i = 0; i < count; i++)
|
|
huff_val.ptr[i] = cast(ubyte)(get_bits(8));
|
|
|
|
i = 1 + 16 + count;
|
|
|
|
if (num_left < cast(uint)i)
|
|
stop_decoding(JPGD_BAD_DHT_MARKER);
|
|
|
|
num_left -= i;
|
|
|
|
if ((index & 0x10) > 0x10)
|
|
stop_decoding(JPGD_BAD_DHT_INDEX);
|
|
|
|
index = (index & 0x0F) + ((index & 0x10) >> 4) * (JPGD_MAX_HUFF_TABLES >> 1);
|
|
|
|
if (index >= JPGD_MAX_HUFF_TABLES)
|
|
stop_decoding(JPGD_BAD_DHT_INDEX);
|
|
|
|
if (!m_huff_num.ptr[index])
|
|
m_huff_num.ptr[index] = cast(ubyte*)alloc(17);
|
|
|
|
if (!m_huff_val.ptr[index])
|
|
m_huff_val.ptr[index] = cast(ubyte*)alloc(256);
|
|
|
|
m_huff_ac.ptr[index] = (index & 0x10) != 0;
|
|
memcpy(m_huff_num.ptr[index], huff_num.ptr, 17);
|
|
memcpy(m_huff_val.ptr[index], huff_val.ptr, 256);
|
|
}
|
|
}
|
|
|
|
// Read a quantization table.
|
|
void read_dqt_marker () {
|
|
int n, i, prec;
|
|
uint num_left;
|
|
uint temp;
|
|
|
|
num_left = get_bits(16);
|
|
|
|
if (num_left < 2)
|
|
stop_decoding(JPGD_BAD_DQT_MARKER);
|
|
|
|
num_left -= 2;
|
|
|
|
while (num_left)
|
|
{
|
|
n = get_bits(8);
|
|
prec = n >> 4;
|
|
n &= 0x0F;
|
|
|
|
if (n >= JPGD_MAX_QUANT_TABLES)
|
|
stop_decoding(JPGD_BAD_DQT_TABLE);
|
|
|
|
if (!m_quant.ptr[n])
|
|
m_quant.ptr[n] = cast(jpgd_quant_t*)alloc(64 * jpgd_quant_t.sizeof);
|
|
|
|
// read quantization entries, in zag order
|
|
for (i = 0; i < 64; i++)
|
|
{
|
|
temp = get_bits(8);
|
|
|
|
if (prec)
|
|
temp = (temp << 8) + get_bits(8);
|
|
|
|
m_quant.ptr[n][i] = cast(jpgd_quant_t)(temp);
|
|
}
|
|
|
|
i = 64 + 1;
|
|
|
|
if (prec)
|
|
i += 64;
|
|
|
|
if (num_left < cast(uint)i)
|
|
stop_decoding(JPGD_BAD_DQT_LENGTH);
|
|
|
|
num_left -= i;
|
|
}
|
|
}
|
|
|
|
// Read the start of frame (SOF) marker.
|
|
void read_sof_marker () {
|
|
int i;
|
|
uint num_left;
|
|
|
|
num_left = get_bits(16);
|
|
|
|
if (get_bits(8) != 8) /* precision: sorry, only 8-bit precision is supported right now */
|
|
stop_decoding(JPGD_BAD_PRECISION);
|
|
|
|
m_image_y_size = get_bits(16);
|
|
|
|
if ((m_image_y_size < 1) || (m_image_y_size > JPGD_MAX_HEIGHT))
|
|
stop_decoding(JPGD_BAD_HEIGHT);
|
|
|
|
m_image_x_size = get_bits(16);
|
|
|
|
if ((m_image_x_size < 1) || (m_image_x_size > JPGD_MAX_WIDTH))
|
|
stop_decoding(JPGD_BAD_WIDTH);
|
|
|
|
m_comps_in_frame = get_bits(8);
|
|
|
|
if (m_comps_in_frame > JPGD_MAX_COMPONENTS)
|
|
stop_decoding(JPGD_TOO_MANY_COMPONENTS);
|
|
|
|
if (num_left != cast(uint)(m_comps_in_frame * 3 + 8))
|
|
stop_decoding(JPGD_BAD_SOF_LENGTH);
|
|
|
|
for (i = 0; i < m_comps_in_frame; i++)
|
|
{
|
|
m_comp_ident.ptr[i] = get_bits(8);
|
|
m_comp_h_samp.ptr[i] = get_bits(4);
|
|
m_comp_v_samp.ptr[i] = get_bits(4);
|
|
m_comp_quant.ptr[i] = get_bits(8);
|
|
}
|
|
}
|
|
|
|
// Used to skip unrecognized markers.
|
|
void skip_variable_marker () {
|
|
uint num_left;
|
|
|
|
num_left = get_bits(16);
|
|
|
|
if (num_left < 2)
|
|
stop_decoding(JPGD_BAD_VARIABLE_MARKER);
|
|
|
|
num_left -= 2;
|
|
|
|
while (num_left)
|
|
{
|
|
get_bits(8);
|
|
num_left--;
|
|
}
|
|
}
|
|
|
|
// Read a define restart interval (DRI) marker.
|
|
void read_dri_marker () {
|
|
if (get_bits(16) != 4)
|
|
stop_decoding(JPGD_BAD_DRI_LENGTH);
|
|
|
|
m_restart_interval = get_bits(16);
|
|
}
|
|
|
|
// Read a start of scan (SOS) marker.
|
|
void read_sos_marker () {
|
|
uint num_left;
|
|
int i, ci, n, c, cc;
|
|
|
|
num_left = get_bits(16);
|
|
|
|
n = get_bits(8);
|
|
|
|
m_comps_in_scan = n;
|
|
|
|
num_left -= 3;
|
|
|
|
if ( (num_left != cast(uint)(n * 2 + 3)) || (n < 1) || (n > JPGD_MAX_COMPS_IN_SCAN) )
|
|
stop_decoding(JPGD_BAD_SOS_LENGTH);
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
cc = get_bits(8);
|
|
c = get_bits(8);
|
|
num_left -= 2;
|
|
|
|
for (ci = 0; ci < m_comps_in_frame; ci++)
|
|
if (cc == m_comp_ident.ptr[ci])
|
|
break;
|
|
|
|
if (ci >= m_comps_in_frame)
|
|
stop_decoding(JPGD_BAD_SOS_COMP_ID);
|
|
|
|
m_comp_list.ptr[i] = ci;
|
|
m_comp_dc_tab.ptr[ci] = (c >> 4) & 15;
|
|
m_comp_ac_tab.ptr[ci] = (c & 15) + (JPGD_MAX_HUFF_TABLES >> 1);
|
|
}
|
|
|
|
m_spectral_start = get_bits(8);
|
|
m_spectral_end = get_bits(8);
|
|
m_successive_high = get_bits(4);
|
|
m_successive_low = get_bits(4);
|
|
|
|
if (!m_progressive_flag)
|
|
{
|
|
m_spectral_start = 0;
|
|
m_spectral_end = 63;
|
|
}
|
|
|
|
num_left -= 3;
|
|
|
|
/* read past whatever is num_left */
|
|
while (num_left)
|
|
{
|
|
get_bits(8);
|
|
num_left--;
|
|
}
|
|
}
|
|
|
|
// Finds the next marker.
|
|
int next_marker () {
|
|
uint c, bytes;
|
|
|
|
bytes = 0;
|
|
|
|
do
|
|
{
|
|
do
|
|
{
|
|
bytes++;
|
|
c = get_bits(8);
|
|
} while (c != 0xFF);
|
|
|
|
do
|
|
{
|
|
c = get_bits(8);
|
|
} while (c == 0xFF);
|
|
|
|
} while (c == 0);
|
|
|
|
// If bytes > 0 here, there where extra bytes before the marker (not good).
|
|
|
|
return c;
|
|
}
|
|
|
|
// Process markers. Returns when an SOFx, SOI, EOI, or SOS marker is
|
|
// encountered.
|
|
int process_markers () {
|
|
int c;
|
|
|
|
for ( ; ; ) {
|
|
c = next_marker();
|
|
|
|
switch (c)
|
|
{
|
|
case M_SOF0:
|
|
case M_SOF1:
|
|
case M_SOF2:
|
|
case M_SOF3:
|
|
case M_SOF5:
|
|
case M_SOF6:
|
|
case M_SOF7:
|
|
//case M_JPG:
|
|
case M_SOF9:
|
|
case M_SOF10:
|
|
case M_SOF11:
|
|
case M_SOF13:
|
|
case M_SOF14:
|
|
case M_SOF15:
|
|
case M_SOI:
|
|
case M_EOI:
|
|
case M_SOS:
|
|
return c;
|
|
case M_DHT:
|
|
read_dht_marker();
|
|
break;
|
|
// No arithmitic support - dumb patents!
|
|
case M_DAC:
|
|
stop_decoding(JPGD_NO_ARITHMITIC_SUPPORT);
|
|
break;
|
|
case M_DQT:
|
|
read_dqt_marker();
|
|
break;
|
|
case M_DRI:
|
|
read_dri_marker();
|
|
break;
|
|
//case M_APP0: /* no need to read the JFIF marker */
|
|
|
|
case M_JPG:
|
|
case M_RST0: /* no parameters */
|
|
case M_RST1:
|
|
case M_RST2:
|
|
case M_RST3:
|
|
case M_RST4:
|
|
case M_RST5:
|
|
case M_RST6:
|
|
case M_RST7:
|
|
case M_TEM:
|
|
stop_decoding(JPGD_UNEXPECTED_MARKER);
|
|
break;
|
|
default: /* must be DNL, DHP, EXP, APPn, JPGn, COM, or RESn or APP0 */
|
|
skip_variable_marker();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finds the start of image (SOI) marker.
|
|
// This code is rather defensive: it only checks the first 512 bytes to avoid
|
|
// false positives.
|
|
void locate_soi_marker () {
|
|
uint lastchar, thischar;
|
|
uint bytesleft;
|
|
|
|
lastchar = get_bits(8);
|
|
|
|
thischar = get_bits(8);
|
|
|
|
/* ok if it's a normal JPEG file without a special header */
|
|
|
|
if ((lastchar == 0xFF) && (thischar == M_SOI))
|
|
return;
|
|
|
|
bytesleft = 4096; //512;
|
|
|
|
for ( ; ; )
|
|
{
|
|
if (--bytesleft == 0)
|
|
stop_decoding(JPGD_NOT_JPEG);
|
|
|
|
lastchar = thischar;
|
|
|
|
thischar = get_bits(8);
|
|
|
|
if (lastchar == 0xFF)
|
|
{
|
|
if (thischar == M_SOI)
|
|
break;
|
|
else if (thischar == M_EOI) // get_bits will keep returning M_EOI if we read past the end
|
|
stop_decoding(JPGD_NOT_JPEG);
|
|
}
|
|
}
|
|
|
|
// Check the next character after marker: if it's not 0xFF, it can't be the start of the next marker, so the file is bad.
|
|
thischar = (m_bit_buf >> 24) & 0xFF;
|
|
|
|
if (thischar != 0xFF)
|
|
stop_decoding(JPGD_NOT_JPEG);
|
|
}
|
|
|
|
// Find a start of frame (SOF) marker.
|
|
void locate_sof_marker () {
|
|
locate_soi_marker();
|
|
|
|
int c = process_markers();
|
|
|
|
switch (c)
|
|
{
|
|
case M_SOF2:
|
|
m_progressive_flag = true;
|
|
goto case;
|
|
case M_SOF0: /* baseline DCT */
|
|
case M_SOF1: /* extended sequential DCT */
|
|
read_sof_marker();
|
|
break;
|
|
case M_SOF9: /* Arithmitic coding */
|
|
stop_decoding(JPGD_NO_ARITHMITIC_SUPPORT);
|
|
break;
|
|
default:
|
|
stop_decoding(JPGD_UNSUPPORTED_MARKER);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Find a start of scan (SOS) marker.
|
|
int locate_sos_marker () {
|
|
int c;
|
|
|
|
c = process_markers();
|
|
|
|
if (c == M_EOI)
|
|
return false;
|
|
else if (c != M_SOS)
|
|
stop_decoding(JPGD_UNEXPECTED_MARKER);
|
|
|
|
read_sos_marker();
|
|
|
|
return true;
|
|
}
|
|
|
|
// Reset everything to default/uninitialized state.
|
|
void initit (JpegStreamReadFunc rfn) {
|
|
m_pMem_blocks = null;
|
|
m_error_code = JPGD_SUCCESS;
|
|
m_ready_flag = false;
|
|
m_image_x_size = m_image_y_size = 0;
|
|
readfn = rfn;
|
|
m_progressive_flag = false;
|
|
|
|
memset(m_huff_ac.ptr, 0, m_huff_ac.sizeof);
|
|
memset(m_huff_num.ptr, 0, m_huff_num.sizeof);
|
|
memset(m_huff_val.ptr, 0, m_huff_val.sizeof);
|
|
memset(m_quant.ptr, 0, m_quant.sizeof);
|
|
|
|
m_scan_type = 0;
|
|
m_comps_in_frame = 0;
|
|
|
|
memset(m_comp_h_samp.ptr, 0, m_comp_h_samp.sizeof);
|
|
memset(m_comp_v_samp.ptr, 0, m_comp_v_samp.sizeof);
|
|
memset(m_comp_quant.ptr, 0, m_comp_quant.sizeof);
|
|
memset(m_comp_ident.ptr, 0, m_comp_ident.sizeof);
|
|
memset(m_comp_h_blocks.ptr, 0, m_comp_h_blocks.sizeof);
|
|
memset(m_comp_v_blocks.ptr, 0, m_comp_v_blocks.sizeof);
|
|
|
|
m_comps_in_scan = 0;
|
|
memset(m_comp_list.ptr, 0, m_comp_list.sizeof);
|
|
memset(m_comp_dc_tab.ptr, 0, m_comp_dc_tab.sizeof);
|
|
memset(m_comp_ac_tab.ptr, 0, m_comp_ac_tab.sizeof);
|
|
|
|
m_spectral_start = 0;
|
|
m_spectral_end = 0;
|
|
m_successive_low = 0;
|
|
m_successive_high = 0;
|
|
m_max_mcu_x_size = 0;
|
|
m_max_mcu_y_size = 0;
|
|
m_blocks_per_mcu = 0;
|
|
m_max_blocks_per_row = 0;
|
|
m_mcus_per_row = 0;
|
|
m_mcus_per_col = 0;
|
|
m_expanded_blocks_per_component = 0;
|
|
m_expanded_blocks_per_mcu = 0;
|
|
m_expanded_blocks_per_row = 0;
|
|
m_freq_domain_chroma_upsample = false;
|
|
|
|
memset(m_mcu_org.ptr, 0, m_mcu_org.sizeof);
|
|
|
|
m_total_lines_left = 0;
|
|
m_mcu_lines_left = 0;
|
|
m_real_dest_bytes_per_scan_line = 0;
|
|
m_dest_bytes_per_scan_line = 0;
|
|
m_dest_bytes_per_pixel = 0;
|
|
|
|
memset(m_pHuff_tabs.ptr, 0, m_pHuff_tabs.sizeof);
|
|
|
|
memset(m_dc_coeffs.ptr, 0, m_dc_coeffs.sizeof);
|
|
memset(m_ac_coeffs.ptr, 0, m_ac_coeffs.sizeof);
|
|
memset(m_block_y_mcu.ptr, 0, m_block_y_mcu.sizeof);
|
|
|
|
m_eob_run = 0;
|
|
|
|
memset(m_block_y_mcu.ptr, 0, m_block_y_mcu.sizeof);
|
|
|
|
m_pIn_buf_ofs = m_in_buf.ptr;
|
|
m_in_buf_left = 0;
|
|
m_eof_flag = false;
|
|
m_tem_flag = 0;
|
|
|
|
memset(m_in_buf_pad_start.ptr, 0, m_in_buf_pad_start.sizeof);
|
|
memset(m_in_buf.ptr, 0, m_in_buf.sizeof);
|
|
memset(m_in_buf_pad_end.ptr, 0, m_in_buf_pad_end.sizeof);
|
|
|
|
m_restart_interval = 0;
|
|
m_restarts_left = 0;
|
|
m_next_restart_num = 0;
|
|
|
|
m_max_mcus_per_row = 0;
|
|
m_max_blocks_per_mcu = 0;
|
|
m_max_mcus_per_col = 0;
|
|
|
|
memset(m_last_dc_val.ptr, 0, m_last_dc_val.sizeof);
|
|
m_pMCU_coefficients = null;
|
|
m_pSample_buf = null;
|
|
|
|
m_total_bytes_read = 0;
|
|
|
|
m_pScan_line_0 = null;
|
|
m_pScan_line_1 = null;
|
|
|
|
// Ready the input buffer.
|
|
prep_in_buffer();
|
|
|
|
// Prime the bit buffer.
|
|
m_bits_left = 16;
|
|
m_bit_buf = 0;
|
|
|
|
get_bits(16);
|
|
get_bits(16);
|
|
|
|
for (int i = 0; i < JPGD_MAX_BLOCKS_PER_MCU; i++)
|
|
m_mcu_block_max_zag.ptr[i] = 64;
|
|
}
|
|
|
|
enum SCALEBITS = 16;
|
|
enum ONE_HALF = (cast(int) 1 << (SCALEBITS-1));
|
|
enum FIX(float x) = (cast(int)((x) * (1L<<SCALEBITS) + 0.5f));
|
|
|
|
// Create a few tables that allow us to quickly convert YCbCr to RGB.
|
|
void create_look_ups () {
|
|
for (int i = 0; i <= 255; i++)
|
|
{
|
|
int k = i - 128;
|
|
m_crr.ptr[i] = ( FIX!(1.40200f) * k + ONE_HALF) >> SCALEBITS;
|
|
m_cbb.ptr[i] = ( FIX!(1.77200f) * k + ONE_HALF) >> SCALEBITS;
|
|
m_crg.ptr[i] = (-FIX!(0.71414f)) * k;
|
|
m_cbg.ptr[i] = (-FIX!(0.34414f)) * k + ONE_HALF;
|
|
}
|
|
}
|
|
|
|
// This method throws back into the stream any bytes that where read
|
|
// into the bit buffer during initial marker scanning.
|
|
void fix_in_buffer () {
|
|
// In case any 0xFF's where pulled into the buffer during marker scanning.
|
|
assert((m_bits_left & 7) == 0);
|
|
|
|
if (m_bits_left == 16)
|
|
stuff_char(cast(ubyte)(m_bit_buf & 0xFF));
|
|
|
|
if (m_bits_left >= 8)
|
|
stuff_char(cast(ubyte)((m_bit_buf >> 8) & 0xFF));
|
|
|
|
stuff_char(cast(ubyte)((m_bit_buf >> 16) & 0xFF));
|
|
stuff_char(cast(ubyte)((m_bit_buf >> 24) & 0xFF));
|
|
|
|
m_bits_left = 16;
|
|
get_bits_no_markers(16);
|
|
get_bits_no_markers(16);
|
|
}
|
|
|
|
void transform_mcu (int mcu_row) {
|
|
jpgd_block_t* pSrc_ptr = m_pMCU_coefficients;
|
|
ubyte* pDst_ptr = m_pSample_buf + mcu_row * m_blocks_per_mcu * 64;
|
|
|
|
for (int mcu_block = 0; mcu_block < m_blocks_per_mcu; mcu_block++)
|
|
{
|
|
idct(pSrc_ptr, pDst_ptr, m_mcu_block_max_zag.ptr[mcu_block]);
|
|
pSrc_ptr += 64;
|
|
pDst_ptr += 64;
|
|
}
|
|
}
|
|
|
|
static immutable ubyte[64] s_max_rc = [
|
|
17, 18, 34, 50, 50, 51, 52, 52, 52, 68, 84, 84, 84, 84, 85, 86, 86, 86, 86, 86,
|
|
102, 118, 118, 118, 118, 118, 118, 119, 120, 120, 120, 120, 120, 120, 120, 136,
|
|
136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
|
|
136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136
|
|
];
|
|
|
|
void transform_mcu_expand (int mcu_row) {
|
|
jpgd_block_t* pSrc_ptr = m_pMCU_coefficients;
|
|
ubyte* pDst_ptr = m_pSample_buf + mcu_row * m_expanded_blocks_per_mcu * 64;
|
|
|
|
// Y IDCT
|
|
int mcu_block;
|
|
for (mcu_block = 0; mcu_block < m_expanded_blocks_per_component; mcu_block++)
|
|
{
|
|
idct(pSrc_ptr, pDst_ptr, m_mcu_block_max_zag.ptr[mcu_block]);
|
|
pSrc_ptr += 64;
|
|
pDst_ptr += 64;
|
|
}
|
|
|
|
// Chroma IDCT, with upsampling
|
|
jpgd_block_t[64] temp_block;
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
DCT_Upsample.Matrix44 P, Q, R, S;
|
|
|
|
assert(m_mcu_block_max_zag.ptr[mcu_block] >= 1);
|
|
assert(m_mcu_block_max_zag.ptr[mcu_block] <= 64);
|
|
|
|
int max_zag = m_mcu_block_max_zag.ptr[mcu_block++] - 1;
|
|
if (max_zag <= 0) max_zag = 0; // should never happen, only here to shut up static analysis
|
|
switch (s_max_rc.ptr[max_zag])
|
|
{
|
|
case 1*16+1:
|
|
DCT_Upsample.P_Q!(1, 1).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(1, 1).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 1*16+2:
|
|
DCT_Upsample.P_Q!(1, 2).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(1, 2).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 2*16+2:
|
|
DCT_Upsample.P_Q!(2, 2).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(2, 2).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 3*16+2:
|
|
DCT_Upsample.P_Q!(3, 2).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(3, 2).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 3*16+3:
|
|
DCT_Upsample.P_Q!(3, 3).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(3, 3).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 3*16+4:
|
|
DCT_Upsample.P_Q!(3, 4).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(3, 4).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 4*16+4:
|
|
DCT_Upsample.P_Q!(4, 4).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(4, 4).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 5*16+4:
|
|
DCT_Upsample.P_Q!(5, 4).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(5, 4).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 5*16+5:
|
|
DCT_Upsample.P_Q!(5, 5).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(5, 5).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 5*16+6:
|
|
DCT_Upsample.P_Q!(5, 6).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(5, 6).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 6*16+6:
|
|
DCT_Upsample.P_Q!(6, 6).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(6, 6).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 7*16+6:
|
|
DCT_Upsample.P_Q!(7, 6).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(7, 6).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 7*16+7:
|
|
DCT_Upsample.P_Q!(7, 7).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(7, 7).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 7*16+8:
|
|
DCT_Upsample.P_Q!(7, 8).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(7, 8).calc(R, S, pSrc_ptr);
|
|
break;
|
|
case 8*16+8:
|
|
DCT_Upsample.P_Q!(8, 8).calc(P, Q, pSrc_ptr);
|
|
DCT_Upsample.R_S!(8, 8).calc(R, S, pSrc_ptr);
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
auto a = DCT_Upsample.Matrix44(P + Q);
|
|
P -= Q;
|
|
DCT_Upsample.Matrix44* b = &P;
|
|
auto c = DCT_Upsample.Matrix44(R + S);
|
|
R -= S;
|
|
DCT_Upsample.Matrix44* d = &R;
|
|
|
|
DCT_Upsample.Matrix44.add_and_store(temp_block.ptr, a, c);
|
|
idct_4x4(temp_block.ptr, pDst_ptr);
|
|
pDst_ptr += 64;
|
|
|
|
DCT_Upsample.Matrix44.sub_and_store(temp_block.ptr, a, c);
|
|
idct_4x4(temp_block.ptr, pDst_ptr);
|
|
pDst_ptr += 64;
|
|
|
|
DCT_Upsample.Matrix44.add_and_store(temp_block.ptr, *b, *d);
|
|
idct_4x4(temp_block.ptr, pDst_ptr);
|
|
pDst_ptr += 64;
|
|
|
|
DCT_Upsample.Matrix44.sub_and_store(temp_block.ptr, *b, *d);
|
|
idct_4x4(temp_block.ptr, pDst_ptr);
|
|
pDst_ptr += 64;
|
|
|
|
pSrc_ptr += 64;
|
|
}
|
|
}
|
|
|
|
// Loads and dequantizes the next row of (already decoded) coefficients.
|
|
// Progressive images only.
|
|
void load_next_row () {
|
|
int i;
|
|
jpgd_block_t *p;
|
|
jpgd_quant_t *q;
|
|
int mcu_row, mcu_block, row_block = 0;
|
|
int component_num, component_id;
|
|
int[JPGD_MAX_COMPONENTS] block_x_mcu;
|
|
|
|
memset(block_x_mcu.ptr, 0, JPGD_MAX_COMPONENTS * int.sizeof);
|
|
|
|
for (mcu_row = 0; mcu_row < m_mcus_per_row; mcu_row++)
|
|
{
|
|
int block_x_mcu_ofs = 0, block_y_mcu_ofs = 0;
|
|
|
|
for (mcu_block = 0; mcu_block < m_blocks_per_mcu; mcu_block++)
|
|
{
|
|
component_id = m_mcu_org.ptr[mcu_block];
|
|
q = m_quant.ptr[m_comp_quant.ptr[component_id]];
|
|
|
|
p = m_pMCU_coefficients + 64 * mcu_block;
|
|
|
|
jpgd_block_t* pAC = coeff_buf_getp(m_ac_coeffs.ptr[component_id], block_x_mcu.ptr[component_id] + block_x_mcu_ofs, m_block_y_mcu.ptr[component_id] + block_y_mcu_ofs);
|
|
jpgd_block_t* pDC = coeff_buf_getp(m_dc_coeffs.ptr[component_id], block_x_mcu.ptr[component_id] + block_x_mcu_ofs, m_block_y_mcu.ptr[component_id] + block_y_mcu_ofs);
|
|
p[0] = pDC[0];
|
|
memcpy(&p[1], &pAC[1], 63 * jpgd_block_t.sizeof);
|
|
|
|
for (i = 63; i > 0; i--)
|
|
if (p[g_ZAG[i]])
|
|
break;
|
|
|
|
m_mcu_block_max_zag.ptr[mcu_block] = i + 1;
|
|
|
|
for ( ; i >= 0; i--)
|
|
if (p[g_ZAG[i]])
|
|
p[g_ZAG[i]] = cast(jpgd_block_t)(p[g_ZAG[i]] * q[i]);
|
|
|
|
row_block++;
|
|
|
|
if (m_comps_in_scan == 1)
|
|
block_x_mcu.ptr[component_id]++;
|
|
else
|
|
{
|
|
if (++block_x_mcu_ofs == m_comp_h_samp.ptr[component_id])
|
|
{
|
|
block_x_mcu_ofs = 0;
|
|
|
|
if (++block_y_mcu_ofs == m_comp_v_samp.ptr[component_id])
|
|
{
|
|
block_y_mcu_ofs = 0;
|
|
|
|
block_x_mcu.ptr[component_id] += m_comp_h_samp.ptr[component_id];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_freq_domain_chroma_upsample)
|
|
transform_mcu_expand(mcu_row);
|
|
else
|
|
transform_mcu(mcu_row);
|
|
}
|
|
|
|
if (m_comps_in_scan == 1)
|
|
m_block_y_mcu.ptr[m_comp_list.ptr[0]]++;
|
|
else
|
|
{
|
|
for (component_num = 0; component_num < m_comps_in_scan; component_num++)
|
|
{
|
|
component_id = m_comp_list.ptr[component_num];
|
|
|
|
m_block_y_mcu.ptr[component_id] += m_comp_v_samp.ptr[component_id];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Restart interval processing.
|
|
void process_restart () {
|
|
int i;
|
|
int c = 0;
|
|
|
|
// Align to a byte boundry
|
|
// FIXME: Is this really necessary? get_bits_no_markers() never reads in markers!
|
|
//get_bits_no_markers(m_bits_left & 7);
|
|
|
|
// Let's scan a little bit to find the marker, but not _too_ far.
|
|
// 1536 is a "fudge factor" that determines how much to scan.
|
|
for (i = 1536; i > 0; i--)
|
|
if (get_char() == 0xFF)
|
|
break;
|
|
|
|
if (i == 0)
|
|
stop_decoding(JPGD_BAD_RESTART_MARKER);
|
|
|
|
for ( ; i > 0; i--)
|
|
if ((c = get_char()) != 0xFF)
|
|
break;
|
|
|
|
if (i == 0)
|
|
stop_decoding(JPGD_BAD_RESTART_MARKER);
|
|
|
|
// Is it the expected marker? If not, something bad happened.
|
|
if (c != (m_next_restart_num + M_RST0))
|
|
stop_decoding(JPGD_BAD_RESTART_MARKER);
|
|
|
|
// Reset each component's DC prediction values.
|
|
memset(&m_last_dc_val, 0, m_comps_in_frame * uint.sizeof);
|
|
|
|
m_eob_run = 0;
|
|
|
|
m_restarts_left = m_restart_interval;
|
|
|
|
m_next_restart_num = (m_next_restart_num + 1) & 7;
|
|
|
|
// Get the bit buffer going again...
|
|
|
|
m_bits_left = 16;
|
|
get_bits_no_markers(16);
|
|
get_bits_no_markers(16);
|
|
}
|
|
|
|
static int dequantize_ac (int c, int q) { pragma(inline, true); c *= q; return c; }
|
|
|
|
// Decodes and dequantizes the next row of coefficients.
|
|
void decode_next_row () {
|
|
int row_block = 0;
|
|
|
|
for (int mcu_row = 0; mcu_row < m_mcus_per_row; mcu_row++)
|
|
{
|
|
if ((m_restart_interval) && (m_restarts_left == 0))
|
|
process_restart();
|
|
|
|
jpgd_block_t* p = m_pMCU_coefficients;
|
|
for (int mcu_block = 0; mcu_block < m_blocks_per_mcu; mcu_block++, p += 64)
|
|
{
|
|
int component_id = m_mcu_org.ptr[mcu_block];
|
|
jpgd_quant_t* q = m_quant.ptr[m_comp_quant.ptr[component_id]];
|
|
|
|
int r, s;
|
|
s = huff_decode(m_pHuff_tabs.ptr[m_comp_dc_tab.ptr[component_id]], r);
|
|
s = JPGD_HUFF_EXTEND(r, s);
|
|
|
|
m_last_dc_val.ptr[component_id] = (s += m_last_dc_val.ptr[component_id]);
|
|
|
|
p[0] = cast(jpgd_block_t)(s * q[0]);
|
|
|
|
int prev_num_set = m_mcu_block_max_zag.ptr[mcu_block];
|
|
|
|
huff_tables *pH = m_pHuff_tabs.ptr[m_comp_ac_tab.ptr[component_id]];
|
|
|
|
int k;
|
|
for (k = 1; k < 64; k++)
|
|
{
|
|
int extra_bits;
|
|
s = huff_decode(pH, extra_bits);
|
|
|
|
r = s >> 4;
|
|
s &= 15;
|
|
|
|
if (s)
|
|
{
|
|
if (r)
|
|
{
|
|
if ((k + r) > 63)
|
|
stop_decoding(JPGD_DECODE_ERROR);
|
|
|
|
if (k < prev_num_set)
|
|
{
|
|
int n = JPGD_MIN(r, prev_num_set - k);
|
|
int kt = k;
|
|
while (n--)
|
|
p[g_ZAG[kt++]] = 0;
|
|
}
|
|
|
|
k += r;
|
|
}
|
|
|
|
s = JPGD_HUFF_EXTEND(extra_bits, s);
|
|
|
|
assert(k < 64);
|
|
|
|
p[g_ZAG[k]] = cast(jpgd_block_t)(dequantize_ac(s, q[k])); //s * q[k];
|
|
}
|
|
else
|
|
{
|
|
if (r == 15)
|
|
{
|
|
if ((k + 16) > 64)
|
|
stop_decoding(JPGD_DECODE_ERROR);
|
|
|
|
if (k < prev_num_set)
|
|
{
|
|
int n = JPGD_MIN(16, prev_num_set - k);
|
|
int kt = k;
|
|
while (n--)
|
|
{
|
|
assert(kt <= 63);
|
|
p[g_ZAG[kt++]] = 0;
|
|
}
|
|
}
|
|
|
|
k += 16 - 1; // - 1 because the loop counter is k
|
|
assert(p[g_ZAG[k]] == 0);
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (k < prev_num_set)
|
|
{
|
|
int kt = k;
|
|
while (kt < prev_num_set)
|
|
p[g_ZAG[kt++]] = 0;
|
|
}
|
|
|
|
m_mcu_block_max_zag.ptr[mcu_block] = k;
|
|
|
|
row_block++;
|
|
}
|
|
|
|
if (m_freq_domain_chroma_upsample)
|
|
transform_mcu_expand(mcu_row);
|
|
else
|
|
transform_mcu(mcu_row);
|
|
|
|
m_restarts_left--;
|
|
}
|
|
}
|
|
|
|
// YCbCr H1V1 (1x1:1:1, 3 m_blocks per MCU) to RGB
|
|
void H1V1Convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
ubyte *d = m_pScan_line_0;
|
|
ubyte *s = m_pSample_buf + row * 8;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
int y = s[j];
|
|
int cb = s[64+j];
|
|
int cr = s[128+j];
|
|
|
|
d[0] = clamp(y + m_crr.ptr[cr]);
|
|
d[1] = clamp(y + ((m_crg.ptr[cr] + m_cbg.ptr[cb]) >> 16));
|
|
d[2] = clamp(y + m_cbb.ptr[cb]);
|
|
d[3] = 255;
|
|
|
|
d += 4;
|
|
}
|
|
|
|
s += 64*3;
|
|
}
|
|
}
|
|
|
|
// YCbCr H2V1 (2x1:1:1, 4 m_blocks per MCU) to RGB
|
|
void H2V1Convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
ubyte *d0 = m_pScan_line_0;
|
|
ubyte *y = m_pSample_buf + row * 8;
|
|
ubyte *c = m_pSample_buf + 2*64 + row * 8;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
for (int l = 0; l < 2; l++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
int cb = c[0];
|
|
int cr = c[64];
|
|
|
|
int rc = m_crr.ptr[cr];
|
|
int gc = ((m_crg.ptr[cr] + m_cbg.ptr[cb]) >> 16);
|
|
int bc = m_cbb.ptr[cb];
|
|
|
|
int yy = y[j<<1];
|
|
d0[0] = clamp(yy+rc);
|
|
d0[1] = clamp(yy+gc);
|
|
d0[2] = clamp(yy+bc);
|
|
d0[3] = 255;
|
|
|
|
yy = y[(j<<1)+1];
|
|
d0[4] = clamp(yy+rc);
|
|
d0[5] = clamp(yy+gc);
|
|
d0[6] = clamp(yy+bc);
|
|
d0[7] = 255;
|
|
|
|
d0 += 8;
|
|
|
|
c++;
|
|
}
|
|
y += 64;
|
|
}
|
|
|
|
y += 64*4 - 64*2;
|
|
c += 64*4 - 8;
|
|
}
|
|
}
|
|
|
|
// YCbCr H2V1 (1x2:1:1, 4 m_blocks per MCU) to RGB
|
|
void H1V2Convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
ubyte *d0 = m_pScan_line_0;
|
|
ubyte *d1 = m_pScan_line_1;
|
|
ubyte *y;
|
|
ubyte *c;
|
|
|
|
if (row < 8)
|
|
y = m_pSample_buf + row * 8;
|
|
else
|
|
y = m_pSample_buf + 64*1 + (row & 7) * 8;
|
|
|
|
c = m_pSample_buf + 64*2 + (row >> 1) * 8;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
int cb = c[0+j];
|
|
int cr = c[64+j];
|
|
|
|
int rc = m_crr.ptr[cr];
|
|
int gc = ((m_crg.ptr[cr] + m_cbg.ptr[cb]) >> 16);
|
|
int bc = m_cbb.ptr[cb];
|
|
|
|
int yy = y[j];
|
|
d0[0] = clamp(yy+rc);
|
|
d0[1] = clamp(yy+gc);
|
|
d0[2] = clamp(yy+bc);
|
|
d0[3] = 255;
|
|
|
|
yy = y[8+j];
|
|
d1[0] = clamp(yy+rc);
|
|
d1[1] = clamp(yy+gc);
|
|
d1[2] = clamp(yy+bc);
|
|
d1[3] = 255;
|
|
|
|
d0 += 4;
|
|
d1 += 4;
|
|
}
|
|
|
|
y += 64*4;
|
|
c += 64*4;
|
|
}
|
|
}
|
|
|
|
// YCbCr H2V2 (2x2:1:1, 6 m_blocks per MCU) to RGB
|
|
void H2V2Convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
ubyte *d0 = m_pScan_line_0;
|
|
ubyte *d1 = m_pScan_line_1;
|
|
ubyte *y;
|
|
ubyte *c;
|
|
|
|
if (row < 8)
|
|
y = m_pSample_buf + row * 8;
|
|
else
|
|
y = m_pSample_buf + 64*2 + (row & 7) * 8;
|
|
|
|
c = m_pSample_buf + 64*4 + (row >> 1) * 8;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
for (int l = 0; l < 2; l++)
|
|
{
|
|
for (int j = 0; j < 8; j += 2)
|
|
{
|
|
int cb = c[0];
|
|
int cr = c[64];
|
|
|
|
int rc = m_crr.ptr[cr];
|
|
int gc = ((m_crg.ptr[cr] + m_cbg.ptr[cb]) >> 16);
|
|
int bc = m_cbb.ptr[cb];
|
|
|
|
int yy = y[j];
|
|
d0[0] = clamp(yy+rc);
|
|
d0[1] = clamp(yy+gc);
|
|
d0[2] = clamp(yy+bc);
|
|
d0[3] = 255;
|
|
|
|
yy = y[j+1];
|
|
d0[4] = clamp(yy+rc);
|
|
d0[5] = clamp(yy+gc);
|
|
d0[6] = clamp(yy+bc);
|
|
d0[7] = 255;
|
|
|
|
yy = y[j+8];
|
|
d1[0] = clamp(yy+rc);
|
|
d1[1] = clamp(yy+gc);
|
|
d1[2] = clamp(yy+bc);
|
|
d1[3] = 255;
|
|
|
|
yy = y[j+8+1];
|
|
d1[4] = clamp(yy+rc);
|
|
d1[5] = clamp(yy+gc);
|
|
d1[6] = clamp(yy+bc);
|
|
d1[7] = 255;
|
|
|
|
d0 += 8;
|
|
d1 += 8;
|
|
|
|
c++;
|
|
}
|
|
y += 64;
|
|
}
|
|
|
|
y += 64*6 - 64*2;
|
|
c += 64*6 - 8;
|
|
}
|
|
}
|
|
|
|
// Y (1 block per MCU) to 8-bit grayscale
|
|
void gray_convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
ubyte *d = m_pScan_line_0;
|
|
ubyte *s = m_pSample_buf + row * 8;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
*cast(uint*)d = *cast(uint*)s;
|
|
*cast(uint*)(&d[4]) = *cast(uint*)(&s[4]);
|
|
|
|
s += 64;
|
|
d += 8;
|
|
}
|
|
}
|
|
|
|
void expanded_convert () {
|
|
int row = m_max_mcu_y_size - m_mcu_lines_left;
|
|
|
|
ubyte* Py = m_pSample_buf + (row / 8) * 64 * m_comp_h_samp.ptr[0] + (row & 7) * 8;
|
|
|
|
ubyte* d = m_pScan_line_0;
|
|
|
|
for (int i = m_max_mcus_per_row; i > 0; i--)
|
|
{
|
|
for (int k = 0; k < m_max_mcu_x_size; k += 8)
|
|
{
|
|
immutable int Y_ofs = k * 8;
|
|
immutable int Cb_ofs = Y_ofs + 64 * m_expanded_blocks_per_component;
|
|
immutable int Cr_ofs = Y_ofs + 64 * m_expanded_blocks_per_component * 2;
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
int y = Py[Y_ofs + j];
|
|
int cb = Py[Cb_ofs + j];
|
|
int cr = Py[Cr_ofs + j];
|
|
|
|
d[0] = clamp(y + m_crr.ptr[cr]);
|
|
d[1] = clamp(y + ((m_crg.ptr[cr] + m_cbg.ptr[cb]) >> 16));
|
|
d[2] = clamp(y + m_cbb.ptr[cb]);
|
|
d[3] = 255;
|
|
|
|
d += 4;
|
|
}
|
|
}
|
|
|
|
Py += 64 * m_expanded_blocks_per_mcu;
|
|
}
|
|
}
|
|
|
|
// Find end of image (EOI) marker, so we can return to the user the exact size of the input stream.
|
|
void find_eoi () {
|
|
if (!m_progressive_flag)
|
|
{
|
|
// Attempt to read the EOI marker.
|
|
//get_bits_no_markers(m_bits_left & 7);
|
|
|
|
// Prime the bit buffer
|
|
m_bits_left = 16;
|
|
get_bits(16);
|
|
get_bits(16);
|
|
|
|
// The next marker _should_ be EOI
|
|
process_markers();
|
|
}
|
|
|
|
m_total_bytes_read -= m_in_buf_left;
|
|
}
|
|
|
|
// Creates the tables needed for efficient Huffman decoding.
|
|
void make_huff_table (int index, huff_tables *pH) {
|
|
int p, i, l, si;
|
|
ubyte[257] huffsize;
|
|
uint[257] huffcode;
|
|
uint code;
|
|
uint subtree;
|
|
int code_size;
|
|
int lastp;
|
|
int nextfreeentry;
|
|
int currententry;
|
|
|
|
pH.ac_table = m_huff_ac.ptr[index] != 0;
|
|
|
|
p = 0;
|
|
|
|
for (l = 1; l <= 16; l++)
|
|
{
|
|
for (i = 1; i <= m_huff_num.ptr[index][l]; i++)
|
|
huffsize.ptr[p++] = cast(ubyte)(l);
|
|
}
|
|
|
|
huffsize.ptr[p] = 0;
|
|
|
|
lastp = p;
|
|
|
|
code = 0;
|
|
si = huffsize.ptr[0];
|
|
p = 0;
|
|
|
|
while (huffsize.ptr[p])
|
|
{
|
|
while (huffsize.ptr[p] == si)
|
|
{
|
|
huffcode.ptr[p++] = code;
|
|
code++;
|
|
}
|
|
|
|
code <<= 1;
|
|
si++;
|
|
}
|
|
|
|
memset(pH.look_up.ptr, 0, pH.look_up.sizeof);
|
|
memset(pH.look_up2.ptr, 0, pH.look_up2.sizeof);
|
|
memset(pH.tree.ptr, 0, pH.tree.sizeof);
|
|
memset(pH.code_size.ptr, 0, pH.code_size.sizeof);
|
|
|
|
nextfreeentry = -1;
|
|
|
|
p = 0;
|
|
|
|
while (p < lastp)
|
|
{
|
|
i = m_huff_val.ptr[index][p];
|
|
code = huffcode.ptr[p];
|
|
code_size = huffsize.ptr[p];
|
|
|
|
pH.code_size.ptr[i] = cast(ubyte)(code_size);
|
|
|
|
if (code_size <= 8)
|
|
{
|
|
code <<= (8 - code_size);
|
|
|
|
for (l = 1 << (8 - code_size); l > 0; l--)
|
|
{
|
|
assert(i < 256);
|
|
|
|
pH.look_up.ptr[code] = i;
|
|
|
|
bool has_extrabits = false;
|
|
int extra_bits = 0;
|
|
int num_extra_bits = i & 15;
|
|
|
|
int bits_to_fetch = code_size;
|
|
if (num_extra_bits)
|
|
{
|
|
int total_codesize = code_size + num_extra_bits;
|
|
if (total_codesize <= 8)
|
|
{
|
|
has_extrabits = true;
|
|
extra_bits = ((1 << num_extra_bits) - 1) & (code >> (8 - total_codesize));
|
|
assert(extra_bits <= 0x7FFF);
|
|
bits_to_fetch += num_extra_bits;
|
|
}
|
|
}
|
|
|
|
if (!has_extrabits)
|
|
pH.look_up2.ptr[code] = i | (bits_to_fetch << 8);
|
|
else
|
|
pH.look_up2.ptr[code] = i | 0x8000 | (extra_bits << 16) | (bits_to_fetch << 8);
|
|
|
|
code++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
subtree = (code >> (code_size - 8)) & 0xFF;
|
|
|
|
currententry = pH.look_up.ptr[subtree];
|
|
|
|
if (currententry == 0)
|
|
{
|
|
pH.look_up.ptr[subtree] = currententry = nextfreeentry;
|
|
pH.look_up2.ptr[subtree] = currententry = nextfreeentry;
|
|
|
|
nextfreeentry -= 2;
|
|
}
|
|
|
|
code <<= (16 - (code_size - 8));
|
|
|
|
for (l = code_size; l > 9; l--)
|
|
{
|
|
if ((code & 0x8000) == 0)
|
|
currententry--;
|
|
|
|
if (pH.tree.ptr[-currententry - 1] == 0)
|
|
{
|
|
pH.tree.ptr[-currententry - 1] = nextfreeentry;
|
|
|
|
currententry = nextfreeentry;
|
|
|
|
nextfreeentry -= 2;
|
|
}
|
|
else
|
|
currententry = pH.tree.ptr[-currententry - 1];
|
|
|
|
code <<= 1;
|
|
}
|
|
|
|
if ((code & 0x8000) == 0)
|
|
currententry--;
|
|
|
|
pH.tree.ptr[-currententry - 1] = i;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
}
|
|
|
|
// Verifies the quantization tables needed for this scan are available.
|
|
void check_quant_tables () {
|
|
for (int i = 0; i < m_comps_in_scan; i++)
|
|
if (m_quant.ptr[m_comp_quant.ptr[m_comp_list.ptr[i]]] == null)
|
|
stop_decoding(JPGD_UNDEFINED_QUANT_TABLE);
|
|
}
|
|
|
|
// Verifies that all the Huffman tables needed for this scan are available.
|
|
void check_huff_tables () {
|
|
for (int i = 0; i < m_comps_in_scan; i++)
|
|
{
|
|
if ((m_spectral_start == 0) && (m_huff_num.ptr[m_comp_dc_tab.ptr[m_comp_list.ptr[i]]] == null))
|
|
stop_decoding(JPGD_UNDEFINED_HUFF_TABLE);
|
|
|
|
if ((m_spectral_end > 0) && (m_huff_num.ptr[m_comp_ac_tab.ptr[m_comp_list.ptr[i]]] == null))
|
|
stop_decoding(JPGD_UNDEFINED_HUFF_TABLE);
|
|
}
|
|
|
|
for (int i = 0; i < JPGD_MAX_HUFF_TABLES; i++)
|
|
if (m_huff_num.ptr[i])
|
|
{
|
|
if (!m_pHuff_tabs.ptr[i])
|
|
m_pHuff_tabs.ptr[i] = cast(huff_tables*)alloc(huff_tables.sizeof);
|
|
|
|
make_huff_table(i, m_pHuff_tabs.ptr[i]);
|
|
}
|
|
}
|
|
|
|
// Determines the component order inside each MCU.
|
|
// Also calcs how many MCU's are on each row, etc.
|
|
void calc_mcu_block_order () {
|
|
int component_num, component_id;
|
|
int max_h_samp = 0, max_v_samp = 0;
|
|
|
|
for (component_id = 0; component_id < m_comps_in_frame; component_id++)
|
|
{
|
|
if (m_comp_h_samp.ptr[component_id] > max_h_samp)
|
|
max_h_samp = m_comp_h_samp.ptr[component_id];
|
|
|
|
if (m_comp_v_samp.ptr[component_id] > max_v_samp)
|
|
max_v_samp = m_comp_v_samp.ptr[component_id];
|
|
}
|
|
|
|
for (component_id = 0; component_id < m_comps_in_frame; component_id++)
|
|
{
|
|
m_comp_h_blocks.ptr[component_id] = ((((m_image_x_size * m_comp_h_samp.ptr[component_id]) + (max_h_samp - 1)) / max_h_samp) + 7) / 8;
|
|
m_comp_v_blocks.ptr[component_id] = ((((m_image_y_size * m_comp_v_samp.ptr[component_id]) + (max_v_samp - 1)) / max_v_samp) + 7) / 8;
|
|
}
|
|
|
|
if (m_comps_in_scan == 1)
|
|
{
|
|
m_mcus_per_row = m_comp_h_blocks.ptr[m_comp_list.ptr[0]];
|
|
m_mcus_per_col = m_comp_v_blocks.ptr[m_comp_list.ptr[0]];
|
|
}
|
|
else
|
|
{
|
|
m_mcus_per_row = (((m_image_x_size + 7) / 8) + (max_h_samp - 1)) / max_h_samp;
|
|
m_mcus_per_col = (((m_image_y_size + 7) / 8) + (max_v_samp - 1)) / max_v_samp;
|
|
}
|
|
|
|
if (m_comps_in_scan == 1)
|
|
{
|
|
m_mcu_org.ptr[0] = m_comp_list.ptr[0];
|
|
|
|
m_blocks_per_mcu = 1;
|
|
}
|
|
else
|
|
{
|
|
m_blocks_per_mcu = 0;
|
|
|
|
for (component_num = 0; component_num < m_comps_in_scan; component_num++)
|
|
{
|
|
int num_blocks;
|
|
|
|
component_id = m_comp_list.ptr[component_num];
|
|
|
|
num_blocks = m_comp_h_samp.ptr[component_id] * m_comp_v_samp.ptr[component_id];
|
|
|
|
while (num_blocks--)
|
|
m_mcu_org.ptr[m_blocks_per_mcu++] = component_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Starts a new scan.
|
|
int init_scan () {
|
|
if (!locate_sos_marker())
|
|
return false;
|
|
|
|
calc_mcu_block_order();
|
|
|
|
check_huff_tables();
|
|
|
|
check_quant_tables();
|
|
|
|
memset(m_last_dc_val.ptr, 0, m_comps_in_frame * uint.sizeof);
|
|
|
|
m_eob_run = 0;
|
|
|
|
if (m_restart_interval)
|
|
{
|
|
m_restarts_left = m_restart_interval;
|
|
m_next_restart_num = 0;
|
|
}
|
|
|
|
fix_in_buffer();
|
|
|
|
return true;
|
|
}
|
|
|
|
// Starts a frame. Determines if the number of components or sampling factors
|
|
// are supported.
|
|
void init_frame () {
|
|
int i;
|
|
|
|
if (m_comps_in_frame == 1)
|
|
{
|
|
version(jpegd_test) {{ import std.stdio; stderr.writeln("m_comp_h_samp=", m_comp_h_samp.ptr[0], "; m_comp_v_samp=", m_comp_v_samp.ptr[0]); }}
|
|
|
|
//if ((m_comp_h_samp.ptr[0] != 1) || (m_comp_v_samp.ptr[0] != 1))
|
|
// stop_decoding(JPGD_UNSUPPORTED_SAMP_FACTORS);
|
|
|
|
if ((m_comp_h_samp.ptr[0] == 1) && (m_comp_v_samp.ptr[0] == 1))
|
|
{
|
|
m_scan_type = JPGD_GRAYSCALE;
|
|
m_max_blocks_per_mcu = 1;
|
|
m_max_mcu_x_size = 8;
|
|
m_max_mcu_y_size = 8;
|
|
}
|
|
else if ((m_comp_h_samp.ptr[0] == 2) && (m_comp_v_samp.ptr[0] == 2))
|
|
{
|
|
//k8: i added this, and i absolutely don't know what it means; but it decoded two sample images i found
|
|
m_scan_type = JPGD_GRAYSCALE;
|
|
m_max_blocks_per_mcu = 4;
|
|
m_max_mcu_x_size = 8;
|
|
m_max_mcu_y_size = 8;
|
|
}
|
|
else
|
|
stop_decoding(JPGD_UNSUPPORTED_SAMP_FACTORS);
|
|
}
|
|
else if (m_comps_in_frame == 3)
|
|
{
|
|
if ( ((m_comp_h_samp.ptr[1] != 1) || (m_comp_v_samp.ptr[1] != 1)) ||
|
|
((m_comp_h_samp.ptr[2] != 1) || (m_comp_v_samp.ptr[2] != 1)) )
|
|
stop_decoding(JPGD_UNSUPPORTED_SAMP_FACTORS);
|
|
|
|
if ((m_comp_h_samp.ptr[0] == 1) && (m_comp_v_samp.ptr[0] == 1))
|
|
{
|
|
m_scan_type = JPGD_YH1V1;
|
|
|
|
m_max_blocks_per_mcu = 3;
|
|
m_max_mcu_x_size = 8;
|
|
m_max_mcu_y_size = 8;
|
|
}
|
|
else if ((m_comp_h_samp.ptr[0] == 2) && (m_comp_v_samp.ptr[0] == 1))
|
|
{
|
|
m_scan_type = JPGD_YH2V1;
|
|
m_max_blocks_per_mcu = 4;
|
|
m_max_mcu_x_size = 16;
|
|
m_max_mcu_y_size = 8;
|
|
}
|
|
else if ((m_comp_h_samp.ptr[0] == 1) && (m_comp_v_samp.ptr[0] == 2))
|
|
{
|
|
m_scan_type = JPGD_YH1V2;
|
|
m_max_blocks_per_mcu = 4;
|
|
m_max_mcu_x_size = 8;
|
|
m_max_mcu_y_size = 16;
|
|
}
|
|
else if ((m_comp_h_samp.ptr[0] == 2) && (m_comp_v_samp.ptr[0] == 2))
|
|
{
|
|
m_scan_type = JPGD_YH2V2;
|
|
m_max_blocks_per_mcu = 6;
|
|
m_max_mcu_x_size = 16;
|
|
m_max_mcu_y_size = 16;
|
|
}
|
|
else
|
|
stop_decoding(JPGD_UNSUPPORTED_SAMP_FACTORS);
|
|
}
|
|
else
|
|
stop_decoding(JPGD_UNSUPPORTED_COLORSPACE);
|
|
|
|
m_max_mcus_per_row = (m_image_x_size + (m_max_mcu_x_size - 1)) / m_max_mcu_x_size;
|
|
m_max_mcus_per_col = (m_image_y_size + (m_max_mcu_y_size - 1)) / m_max_mcu_y_size;
|
|
|
|
// These values are for the *destination* pixels: after conversion.
|
|
if (m_scan_type == JPGD_GRAYSCALE)
|
|
m_dest_bytes_per_pixel = 1;
|
|
else
|
|
m_dest_bytes_per_pixel = 4;
|
|
|
|
m_dest_bytes_per_scan_line = ((m_image_x_size + 15) & 0xFFF0) * m_dest_bytes_per_pixel;
|
|
|
|
m_real_dest_bytes_per_scan_line = (m_image_x_size * m_dest_bytes_per_pixel);
|
|
|
|
// Initialize two scan line buffers.
|
|
m_pScan_line_0 = cast(ubyte*)alloc(m_dest_bytes_per_scan_line, true);
|
|
if ((m_scan_type == JPGD_YH1V2) || (m_scan_type == JPGD_YH2V2))
|
|
m_pScan_line_1 = cast(ubyte*)alloc(m_dest_bytes_per_scan_line, true);
|
|
|
|
m_max_blocks_per_row = m_max_mcus_per_row * m_max_blocks_per_mcu;
|
|
|
|
// Should never happen
|
|
if (m_max_blocks_per_row > JPGD_MAX_BLOCKS_PER_ROW)
|
|
stop_decoding(JPGD_ASSERTION_ERROR);
|
|
|
|
// Allocate the coefficient buffer, enough for one MCU
|
|
m_pMCU_coefficients = cast(jpgd_block_t*)alloc(m_max_blocks_per_mcu * 64 * jpgd_block_t.sizeof);
|
|
|
|
for (i = 0; i < m_max_blocks_per_mcu; i++)
|
|
m_mcu_block_max_zag.ptr[i] = 64;
|
|
|
|
m_expanded_blocks_per_component = m_comp_h_samp.ptr[0] * m_comp_v_samp.ptr[0];
|
|
m_expanded_blocks_per_mcu = m_expanded_blocks_per_component * m_comps_in_frame;
|
|
m_expanded_blocks_per_row = m_max_mcus_per_row * m_expanded_blocks_per_mcu;
|
|
// Freq. domain chroma upsampling is only supported for H2V2 subsampling factor (the most common one I've seen).
|
|
m_freq_domain_chroma_upsample = false;
|
|
version(JPGD_SUPPORT_FREQ_DOMAIN_UPSAMPLING) {
|
|
m_freq_domain_chroma_upsample = (m_expanded_blocks_per_mcu == 4*3);
|
|
}
|
|
|
|
if (m_freq_domain_chroma_upsample)
|
|
m_pSample_buf = cast(ubyte*)alloc(m_expanded_blocks_per_row * 64);
|
|
else
|
|
m_pSample_buf = cast(ubyte*)alloc(m_max_blocks_per_row * 64);
|
|
|
|
m_total_lines_left = m_image_y_size;
|
|
|
|
m_mcu_lines_left = 0;
|
|
|
|
create_look_ups();
|
|
}
|
|
|
|
// The coeff_buf series of methods originally stored the coefficients
|
|
// into a "virtual" file which was located in EMS, XMS, or a disk file. A cache
|
|
// was used to make this process more efficient. Now, we can store the entire
|
|
// thing in RAM.
|
|
coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y) {
|
|
coeff_buf* cb = cast(coeff_buf*)alloc(coeff_buf.sizeof);
|
|
|
|
cb.block_num_x = block_num_x;
|
|
cb.block_num_y = block_num_y;
|
|
cb.block_len_x = block_len_x;
|
|
cb.block_len_y = block_len_y;
|
|
cb.block_size = cast(int)((block_len_x * block_len_y) * jpgd_block_t.sizeof);
|
|
cb.pData = cast(ubyte*)alloc(cb.block_size * block_num_x * block_num_y, true);
|
|
return cb;
|
|
}
|
|
|
|
jpgd_block_t* coeff_buf_getp (coeff_buf *cb, int block_x, int block_y) {
|
|
assert((block_x < cb.block_num_x) && (block_y < cb.block_num_y));
|
|
return cast(jpgd_block_t*)(cb.pData + block_x * cb.block_size + block_y * (cb.block_size * cb.block_num_x));
|
|
}
|
|
|
|
// The following methods decode the various types of m_blocks encountered
|
|
// in progressively encoded images.
|
|
static void decode_block_dc_first (ref jpeg_decoder pD, int component_id, int block_x, int block_y) {
|
|
int s, r;
|
|
jpgd_block_t *p = pD.coeff_buf_getp(pD.m_dc_coeffs.ptr[component_id], block_x, block_y);
|
|
|
|
if ((s = pD.huff_decode(pD.m_pHuff_tabs.ptr[pD.m_comp_dc_tab.ptr[component_id]])) != 0)
|
|
{
|
|
r = pD.get_bits_no_markers(s);
|
|
s = JPGD_HUFF_EXTEND(r, s);
|
|
}
|
|
|
|
pD.m_last_dc_val.ptr[component_id] = (s += pD.m_last_dc_val.ptr[component_id]);
|
|
|
|
p[0] = cast(jpgd_block_t)(s << pD.m_successive_low);
|
|
}
|
|
|
|
static void decode_block_dc_refine (ref jpeg_decoder pD, int component_id, int block_x, int block_y) {
|
|
if (pD.get_bits_no_markers(1))
|
|
{
|
|
jpgd_block_t *p = pD.coeff_buf_getp(pD.m_dc_coeffs.ptr[component_id], block_x, block_y);
|
|
|
|
p[0] |= (1 << pD.m_successive_low);
|
|
}
|
|
}
|
|
|
|
static void decode_block_ac_first (ref jpeg_decoder pD, int component_id, int block_x, int block_y) {
|
|
int k, s, r;
|
|
|
|
if (pD.m_eob_run)
|
|
{
|
|
pD.m_eob_run--;
|
|
return;
|
|
}
|
|
|
|
jpgd_block_t *p = pD.coeff_buf_getp(pD.m_ac_coeffs.ptr[component_id], block_x, block_y);
|
|
|
|
for (k = pD.m_spectral_start; k <= pD.m_spectral_end; k++)
|
|
{
|
|
s = pD.huff_decode(pD.m_pHuff_tabs.ptr[pD.m_comp_ac_tab.ptr[component_id]]);
|
|
|
|
r = s >> 4;
|
|
s &= 15;
|
|
|
|
if (s)
|
|
{
|
|
if ((k += r) > 63)
|
|
pD.stop_decoding(JPGD_DECODE_ERROR);
|
|
|
|
r = pD.get_bits_no_markers(s);
|
|
s = JPGD_HUFF_EXTEND(r, s);
|
|
|
|
p[g_ZAG[k]] = cast(jpgd_block_t)(s << pD.m_successive_low);
|
|
}
|
|
else
|
|
{
|
|
if (r == 15)
|
|
{
|
|
if ((k += 15) > 63)
|
|
pD.stop_decoding(JPGD_DECODE_ERROR);
|
|
}
|
|
else
|
|
{
|
|
pD.m_eob_run = 1 << r;
|
|
|
|
if (r)
|
|
pD.m_eob_run += pD.get_bits_no_markers(r);
|
|
|
|
pD.m_eob_run--;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void decode_block_ac_refine (ref jpeg_decoder pD, int component_id, int block_x, int block_y) {
|
|
int s, k, r;
|
|
int p1 = 1 << pD.m_successive_low;
|
|
int m1 = (-1) << pD.m_successive_low;
|
|
jpgd_block_t *p = pD.coeff_buf_getp(pD.m_ac_coeffs.ptr[component_id], block_x, block_y);
|
|
|
|
assert(pD.m_spectral_end <= 63);
|
|
|
|
k = pD.m_spectral_start;
|
|
|
|
if (pD.m_eob_run == 0)
|
|
{
|
|
for ( ; k <= pD.m_spectral_end; k++)
|
|
{
|
|
s = pD.huff_decode(pD.m_pHuff_tabs.ptr[pD.m_comp_ac_tab.ptr[component_id]]);
|
|
|
|
r = s >> 4;
|
|
s &= 15;
|
|
|
|
if (s)
|
|
{
|
|
if (s != 1)
|
|
pD.stop_decoding(JPGD_DECODE_ERROR);
|
|
|
|
if (pD.get_bits_no_markers(1))
|
|
s = p1;
|
|
else
|
|
s = m1;
|
|
}
|
|
else
|
|
{
|
|
if (r != 15)
|
|
{
|
|
pD.m_eob_run = 1 << r;
|
|
|
|
if (r)
|
|
pD.m_eob_run += pD.get_bits_no_markers(r);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
do
|
|
{
|
|
jpgd_block_t *this_coef = p + g_ZAG[k & 63];
|
|
|
|
if (*this_coef != 0)
|
|
{
|
|
if (pD.get_bits_no_markers(1))
|
|
{
|
|
if ((*this_coef & p1) == 0)
|
|
{
|
|
if (*this_coef >= 0)
|
|
*this_coef = cast(jpgd_block_t)(*this_coef + p1);
|
|
else
|
|
*this_coef = cast(jpgd_block_t)(*this_coef + m1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (--r < 0)
|
|
break;
|
|
}
|
|
|
|
k++;
|
|
|
|
} while (k <= pD.m_spectral_end);
|
|
|
|
if ((s) && (k < 64))
|
|
{
|
|
p[g_ZAG[k]] = cast(jpgd_block_t)(s);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pD.m_eob_run > 0)
|
|
{
|
|
for ( ; k <= pD.m_spectral_end; k++)
|
|
{
|
|
jpgd_block_t *this_coef = p + g_ZAG[k & 63]; // logical AND to shut up static code analysis
|
|
|
|
if (*this_coef != 0)
|
|
{
|
|
if (pD.get_bits_no_markers(1))
|
|
{
|
|
if ((*this_coef & p1) == 0)
|
|
{
|
|
if (*this_coef >= 0)
|
|
*this_coef = cast(jpgd_block_t)(*this_coef + p1);
|
|
else
|
|
*this_coef = cast(jpgd_block_t)(*this_coef + m1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pD.m_eob_run--;
|
|
}
|
|
}
|
|
|
|
// Decode a scan in a progressively encoded image.
|
|
void decode_scan (pDecode_block_func decode_block_func) {
|
|
int mcu_row, mcu_col, mcu_block;
|
|
int[JPGD_MAX_COMPONENTS] block_x_mcu;
|
|
int[JPGD_MAX_COMPONENTS] m_block_y_mcu;
|
|
|
|
memset(m_block_y_mcu.ptr, 0, m_block_y_mcu.sizeof);
|
|
|
|
for (mcu_col = 0; mcu_col < m_mcus_per_col; mcu_col++)
|
|
{
|
|
int component_num, component_id;
|
|
|
|
memset(block_x_mcu.ptr, 0, block_x_mcu.sizeof);
|
|
|
|
for (mcu_row = 0; mcu_row < m_mcus_per_row; mcu_row++)
|
|
{
|
|
int block_x_mcu_ofs = 0, block_y_mcu_ofs = 0;
|
|
|
|
if ((m_restart_interval) && (m_restarts_left == 0))
|
|
process_restart();
|
|
|
|
for (mcu_block = 0; mcu_block < m_blocks_per_mcu; mcu_block++)
|
|
{
|
|
component_id = m_mcu_org.ptr[mcu_block];
|
|
|
|
decode_block_func(this, component_id, block_x_mcu.ptr[component_id] + block_x_mcu_ofs, m_block_y_mcu.ptr[component_id] + block_y_mcu_ofs);
|
|
|
|
if (m_comps_in_scan == 1)
|
|
block_x_mcu.ptr[component_id]++;
|
|
else
|
|
{
|
|
if (++block_x_mcu_ofs == m_comp_h_samp.ptr[component_id])
|
|
{
|
|
block_x_mcu_ofs = 0;
|
|
|
|
if (++block_y_mcu_ofs == m_comp_v_samp.ptr[component_id])
|
|
{
|
|
block_y_mcu_ofs = 0;
|
|
block_x_mcu.ptr[component_id] += m_comp_h_samp.ptr[component_id];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_restarts_left--;
|
|
}
|
|
|
|
if (m_comps_in_scan == 1)
|
|
m_block_y_mcu.ptr[m_comp_list.ptr[0]]++;
|
|
else
|
|
{
|
|
for (component_num = 0; component_num < m_comps_in_scan; component_num++)
|
|
{
|
|
component_id = m_comp_list.ptr[component_num];
|
|
m_block_y_mcu.ptr[component_id] += m_comp_v_samp.ptr[component_id];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decode a progressively encoded image.
|
|
void init_progressive () {
|
|
int i;
|
|
|
|
if (m_comps_in_frame == 4)
|
|
stop_decoding(JPGD_UNSUPPORTED_COLORSPACE);
|
|
|
|
// Allocate the coefficient buffers.
|
|
for (i = 0; i < m_comps_in_frame; i++)
|
|
{
|
|
m_dc_coeffs.ptr[i] = coeff_buf_open(m_max_mcus_per_row * m_comp_h_samp.ptr[i], m_max_mcus_per_col * m_comp_v_samp.ptr[i], 1, 1);
|
|
m_ac_coeffs.ptr[i] = coeff_buf_open(m_max_mcus_per_row * m_comp_h_samp.ptr[i], m_max_mcus_per_col * m_comp_v_samp.ptr[i], 8, 8);
|
|
}
|
|
|
|
for ( ; ; )
|
|
{
|
|
int dc_only_scan, refinement_scan;
|
|
pDecode_block_func decode_block_func;
|
|
|
|
if (!init_scan())
|
|
break;
|
|
|
|
dc_only_scan = (m_spectral_start == 0);
|
|
refinement_scan = (m_successive_high != 0);
|
|
|
|
if ((m_spectral_start > m_spectral_end) || (m_spectral_end > 63))
|
|
stop_decoding(JPGD_BAD_SOS_SPECTRAL);
|
|
|
|
if (dc_only_scan)
|
|
{
|
|
if (m_spectral_end)
|
|
stop_decoding(JPGD_BAD_SOS_SPECTRAL);
|
|
}
|
|
else if (m_comps_in_scan != 1) /* AC scans can only contain one component */
|
|
stop_decoding(JPGD_BAD_SOS_SPECTRAL);
|
|
|
|
if ((refinement_scan) && (m_successive_low != m_successive_high - 1))
|
|
stop_decoding(JPGD_BAD_SOS_SUCCESSIVE);
|
|
|
|
if (dc_only_scan)
|
|
{
|
|
if (refinement_scan)
|
|
decode_block_func = &decode_block_dc_refine;
|
|
else
|
|
decode_block_func = &decode_block_dc_first;
|
|
}
|
|
else
|
|
{
|
|
if (refinement_scan)
|
|
decode_block_func = &decode_block_ac_refine;
|
|
else
|
|
decode_block_func = &decode_block_ac_first;
|
|
}
|
|
|
|
decode_scan(decode_block_func);
|
|
|
|
m_bits_left = 16;
|
|
get_bits(16);
|
|
get_bits(16);
|
|
}
|
|
|
|
m_comps_in_scan = m_comps_in_frame;
|
|
|
|
for (i = 0; i < m_comps_in_frame; i++)
|
|
m_comp_list.ptr[i] = i;
|
|
|
|
calc_mcu_block_order();
|
|
}
|
|
|
|
void init_sequential () {
|
|
if (!init_scan())
|
|
stop_decoding(JPGD_UNEXPECTED_MARKER);
|
|
}
|
|
|
|
void decode_start () {
|
|
init_frame();
|
|
|
|
if (m_progressive_flag)
|
|
init_progressive();
|
|
else
|
|
init_sequential();
|
|
}
|
|
|
|
void decode_init (JpegStreamReadFunc rfn) {
|
|
initit(rfn);
|
|
locate_sof_marker();
|
|
}
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// read JPEG image header, determine dimensions and number of components.
|
|
/// return `false` if image is not JPEG (i hope).
|
|
public bool detect_jpeg_image_from_stream (scope JpegStreamReadFunc rfn, out int width, out int height, out int actual_comps) {
|
|
if (rfn is null) return false;
|
|
auto decoder = jpeg_decoder(rfn);
|
|
version(jpegd_test) { import core.stdc.stdio : printf; printf("%u bytes read.\n", cast(uint)decoder.total_bytes_read); }
|
|
if (decoder.error_code != JPGD_SUCCESS) return false;
|
|
width = decoder.width;
|
|
height = decoder.height;
|
|
actual_comps = decoder.num_components;
|
|
return true;
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// read JPEG image header, determine dimensions and number of components.
|
|
/// return `false` if image is not JPEG (i hope).
|
|
public bool detect_jpeg_image_from_file (const(char)[] filename, out int width, out int height, out int actual_comps) {
|
|
import core.stdc.stdio;
|
|
|
|
FILE* m_pFile;
|
|
bool m_eof_flag, m_error_flag;
|
|
|
|
if (filename.length == 0) throw new Exception("cannot open unnamed file");
|
|
if (filename.length < 512) {
|
|
char[513] buffer;
|
|
//import core.stdc.stdlib : alloca;
|
|
auto tfn = buffer[0 .. filename.length + 1]; // (cast(char*)alloca(filename.length+1))[0..filename.length+1];
|
|
tfn[0..filename.length] = filename[];
|
|
tfn[filename.length] = 0;
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
} else {
|
|
import core.stdc.stdlib : malloc, free;
|
|
auto tfn = (cast(char*)malloc(filename.length+1))[0..filename.length+1];
|
|
if (tfn !is null) {
|
|
scope(exit) free(tfn.ptr);
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
}
|
|
}
|
|
if (m_pFile is null) throw new Exception("cannot open file '"~filename.idup~"'");
|
|
scope(exit) if (m_pFile) fclose(m_pFile);
|
|
|
|
return detect_jpeg_image_from_stream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (m_pFile is null) return -1;
|
|
if (m_eof_flag) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (m_error_flag) return -1;
|
|
int bytes_read = cast(int)(fread(pBuf, 1, max_bytes_to_read, m_pFile));
|
|
if (bytes_read < max_bytes_to_read) {
|
|
if (ferror(m_pFile)) {
|
|
m_error_flag = true;
|
|
return -1;
|
|
}
|
|
m_eof_flag = true;
|
|
*pEOF_flag = true;
|
|
}
|
|
return bytes_read;
|
|
},
|
|
width, height, actual_comps);
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// read JPEG image header, determine dimensions and number of components.
|
|
/// return `false` if image is not JPEG (i hope).
|
|
public bool detect_jpeg_image_from_memory (const(void)[] buf, out int width, out int height, out int actual_comps) {
|
|
size_t bufpos;
|
|
return detect_jpeg_image_from_stream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
import core.stdc.string : memcpy;
|
|
if (bufpos >= buf.length) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (buf.length-bufpos < max_bytes_to_read) max_bytes_to_read = cast(int)(buf.length-bufpos);
|
|
memcpy(pBuf, (cast(const(ubyte)*)buf.ptr)+bufpos, max_bytes_to_read);
|
|
bufpos += max_bytes_to_read;
|
|
return max_bytes_to_read;
|
|
},
|
|
width, height, actual_comps);
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image, what else?
|
|
/// you can specify required color components in `req_comps` (3 for RGB or 4 for RGBA), or leave it as is to use image value.
|
|
public ubyte[] decompress_jpeg_image_from_stream(bool useMalloc=false) (scope JpegStreamReadFunc rfn, out int width, out int height, out int actual_comps, int req_comps=-1) {
|
|
import core.stdc.string : memcpy;
|
|
|
|
//actual_comps = 0;
|
|
if (rfn is null) return null;
|
|
if (req_comps != -1 && req_comps != 1 && req_comps != 3 && req_comps != 4) return null;
|
|
|
|
auto decoder = jpeg_decoder(rfn);
|
|
if (decoder.error_code != JPGD_SUCCESS) return null;
|
|
version(jpegd_test) scope(exit) { import core.stdc.stdio : printf; printf("%u bytes read.\n", cast(uint)decoder.total_bytes_read); }
|
|
|
|
immutable int image_width = decoder.width;
|
|
immutable int image_height = decoder.height;
|
|
width = image_width;
|
|
height = image_height;
|
|
actual_comps = decoder.num_components;
|
|
if (req_comps < 0) req_comps = decoder.num_components;
|
|
|
|
if (decoder.begin_decoding() != JPGD_SUCCESS) return null;
|
|
|
|
immutable int dst_bpl = image_width*req_comps;
|
|
|
|
static if (useMalloc) {
|
|
ubyte* pImage_data = cast(ubyte*)jpgd_malloc(dst_bpl*image_height);
|
|
if (pImage_data is null) return null;
|
|
auto idata = pImage_data[0..dst_bpl*image_height];
|
|
} else {
|
|
auto idata = new ubyte[](dst_bpl*image_height);
|
|
auto pImage_data = idata.ptr;
|
|
}
|
|
|
|
scope(failure) {
|
|
static if (useMalloc) {
|
|
jpgd_free(pImage_data);
|
|
} else {
|
|
import core.memory : GC;
|
|
GC.free(idata.ptr);
|
|
idata = null;
|
|
}
|
|
}
|
|
|
|
for (int y = 0; y < image_height; ++y) {
|
|
const(ubyte)* pScan_line;
|
|
uint scan_line_len;
|
|
if (decoder.decode(/*(const void**)*/cast(void**)&pScan_line, &scan_line_len) != JPGD_SUCCESS) {
|
|
static if (useMalloc) {
|
|
jpgd_free(pImage_data);
|
|
} else {
|
|
import core.memory : GC;
|
|
GC.free(idata.ptr);
|
|
idata = null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ubyte* pDst = pImage_data+y*dst_bpl;
|
|
|
|
if ((req_comps == 1 && decoder.num_components == 1) || (req_comps == 4 && decoder.num_components == 3)) {
|
|
memcpy(pDst, pScan_line, dst_bpl);
|
|
} else if (decoder.num_components == 1) {
|
|
if (req_comps == 3) {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
ubyte luma = pScan_line[x];
|
|
pDst[0] = luma;
|
|
pDst[1] = luma;
|
|
pDst[2] = luma;
|
|
pDst += 3;
|
|
}
|
|
} else {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
ubyte luma = pScan_line[x];
|
|
pDst[0] = luma;
|
|
pDst[1] = luma;
|
|
pDst[2] = luma;
|
|
pDst[3] = 255;
|
|
pDst += 4;
|
|
}
|
|
}
|
|
} else if (decoder.num_components == 3) {
|
|
if (req_comps == 1) {
|
|
immutable int YR = 19595, YG = 38470, YB = 7471;
|
|
for (int x = 0; x < image_width; ++x) {
|
|
int r = pScan_line[x*4+0];
|
|
int g = pScan_line[x*4+1];
|
|
int b = pScan_line[x*4+2];
|
|
*pDst++ = cast(ubyte)((r * YR + g * YG + b * YB + 32768) >> 16);
|
|
}
|
|
} else {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
pDst[0] = pScan_line[x*4+0];
|
|
pDst[1] = pScan_line[x*4+1];
|
|
pDst[2] = pScan_line[x*4+2];
|
|
pDst += 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return idata;
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image from disk file.
|
|
/// you can specify required color components in `req_comps` (3 for RGB or 4 for RGBA), or leave it as is to use image value.
|
|
public ubyte[] decompress_jpeg_image_from_file(bool useMalloc=false) (const(char)[] filename, out int width, out int height, out int actual_comps, int req_comps=-1) {
|
|
import core.stdc.stdio;
|
|
|
|
FILE* m_pFile;
|
|
bool m_eof_flag, m_error_flag;
|
|
|
|
if (filename.length == 0) throw new Exception("cannot open unnamed file");
|
|
if (filename.length < 512) {
|
|
char[513] buffer;
|
|
//import core.stdc.stdlib : alloca;
|
|
auto tfn = buffer[0 .. filename.length + 1]; // (cast(char*)alloca(filename.length+1))[0..filename.length+1];
|
|
tfn[0..filename.length] = filename[];
|
|
tfn[filename.length] = 0;
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
} else {
|
|
import core.stdc.stdlib : malloc, free;
|
|
auto tfn = (cast(char*)malloc(filename.length+1))[0..filename.length+1];
|
|
if (tfn !is null) {
|
|
scope(exit) free(tfn.ptr);
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
}
|
|
}
|
|
if (m_pFile is null) throw new Exception("cannot open file '"~filename.idup~"'");
|
|
scope(exit) if (m_pFile) fclose(m_pFile);
|
|
|
|
return decompress_jpeg_image_from_stream!useMalloc(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (m_pFile is null) return -1;
|
|
if (m_eof_flag) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (m_error_flag) return -1;
|
|
int bytes_read = cast(int)(fread(pBuf, 1, max_bytes_to_read, m_pFile));
|
|
if (bytes_read < max_bytes_to_read) {
|
|
if (ferror(m_pFile)) {
|
|
m_error_flag = true;
|
|
return -1;
|
|
}
|
|
m_eof_flag = true;
|
|
*pEOF_flag = true;
|
|
}
|
|
return bytes_read;
|
|
},
|
|
width, height, actual_comps, req_comps);
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image from memory buffer.
|
|
/// you can specify required color components in `req_comps` (3 for RGB or 4 for RGBA), or leave it as is to use image value.
|
|
public ubyte[] decompress_jpeg_image_from_memory(bool useMalloc=false) (const(void)[] buf, out int width, out int height, out int actual_comps, int req_comps=-1) {
|
|
size_t bufpos;
|
|
return decompress_jpeg_image_from_stream!useMalloc(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
import core.stdc.string : memcpy;
|
|
if (bufpos >= buf.length) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (buf.length-bufpos < max_bytes_to_read) max_bytes_to_read = cast(int)(buf.length-bufpos);
|
|
memcpy(pBuf, (cast(const(ubyte)*)buf.ptr)+bufpos, max_bytes_to_read);
|
|
bufpos += max_bytes_to_read;
|
|
return max_bytes_to_read;
|
|
},
|
|
width, height, actual_comps, req_comps);
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
// if we have access "iv.vfs", add some handy API
|
|
static if (__traits(compiles, { import iv.vfs; })) enum JpegHasIVVFS = true; else enum JpegHasIVVFS = false;
|
|
|
|
static if (JpegHasIVVFS) {
|
|
import iv.vfs;
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image from disk file.
|
|
/// you can specify required color components in `req_comps` (3 for RGB or 4 for RGBA), or leave it as is to use image value.
|
|
public ubyte[] decompress_jpeg_image_from_file(bool useMalloc=false) (VFile fl, out int width, out int height, out int actual_comps, int req_comps=-1) {
|
|
return decompress_jpeg_image_from_stream!useMalloc(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (!fl.isOpen) return -1;
|
|
if (fl.eof) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
auto rd = fl.rawRead(pBuf[0..max_bytes_to_read]);
|
|
if (fl.eof) *pEOF_flag = true;
|
|
return cast(int)rd.length;
|
|
},
|
|
width, height, actual_comps, req_comps);
|
|
}
|
|
// vfs API
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
// if we have access "arsd.color", add some handy API
|
|
static if (__traits(compiles, { import arsd.color; })) enum JpegHasArsd = true; else enum JpegHasArsd = false;
|
|
|
|
static if (JpegHasArsd) {
|
|
import arsd.color;
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image, what else?
|
|
public MemoryImage readJpegFromStream (scope JpegStreamReadFunc rfn) {
|
|
import core.stdc.string : memcpy;
|
|
enum req_comps = 4;
|
|
|
|
if (rfn is null) return null;
|
|
|
|
auto decoder = jpeg_decoder(rfn);
|
|
if (decoder.error_code != JPGD_SUCCESS) return null;
|
|
version(jpegd_test) scope(exit) { import core.stdc.stdio : printf; printf("%u bytes read.\n", cast(uint)decoder.total_bytes_read); }
|
|
|
|
immutable int image_width = decoder.width;
|
|
immutable int image_height = decoder.height;
|
|
//width = image_width;
|
|
//height = image_height;
|
|
//actual_comps = decoder.num_components;
|
|
|
|
version(jpegd_test) {{ import core.stdc.stdio; stderr.fprintf("starting (%dx%d)...\n", image_width, image_height); }}
|
|
|
|
if (decoder.begin_decoding() != JPGD_SUCCESS || image_width < 1 || image_height < 1) return null;
|
|
|
|
immutable int dst_bpl = image_width*req_comps;
|
|
auto img = new TrueColorImage(image_width, image_height);
|
|
scope(failure) { img.clearInternal(); img = null; }
|
|
ubyte* pImage_data = img.imageData.bytes.ptr;
|
|
|
|
for (int y = 0; y < image_height; ++y) {
|
|
//version(jpegd_test) {{ import core.stdc.stdio; stderr.fprintf("loading line %d...\n", y); }}
|
|
|
|
const(ubyte)* pScan_line;
|
|
uint scan_line_len;
|
|
if (decoder.decode(/*(const void**)*/cast(void**)&pScan_line, &scan_line_len) != JPGD_SUCCESS) {
|
|
img.clearInternal();
|
|
img = null;
|
|
//jpgd_free(pImage_data);
|
|
return null;
|
|
}
|
|
|
|
ubyte* pDst = pImage_data+y*dst_bpl;
|
|
|
|
if ((req_comps == 1 && decoder.num_components == 1) || (req_comps == 4 && decoder.num_components == 3)) {
|
|
memcpy(pDst, pScan_line, dst_bpl);
|
|
} else if (decoder.num_components == 1) {
|
|
if (req_comps == 3) {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
ubyte luma = pScan_line[x];
|
|
pDst[0] = luma;
|
|
pDst[1] = luma;
|
|
pDst[2] = luma;
|
|
pDst += 3;
|
|
}
|
|
} else {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
ubyte luma = pScan_line[x];
|
|
pDst[0] = luma;
|
|
pDst[1] = luma;
|
|
pDst[2] = luma;
|
|
pDst[3] = 255;
|
|
pDst += 4;
|
|
}
|
|
}
|
|
} else if (decoder.num_components == 3) {
|
|
if (req_comps == 1) {
|
|
immutable int YR = 19595, YG = 38470, YB = 7471;
|
|
for (int x = 0; x < image_width; ++x) {
|
|
int r = pScan_line[x*4+0];
|
|
int g = pScan_line[x*4+1];
|
|
int b = pScan_line[x*4+2];
|
|
*pDst++ = cast(ubyte)((r * YR + g * YG + b * YB + 32768) >> 16);
|
|
}
|
|
} else {
|
|
for (int x = 0; x < image_width; ++x) {
|
|
pDst[0] = pScan_line[x*4+0];
|
|
pDst[1] = pScan_line[x*4+1];
|
|
pDst[2] = pScan_line[x*4+2];
|
|
pDst += 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image from disk file.
|
|
public MemoryImage readJpeg (const(char)[] filename) {
|
|
import core.stdc.stdio;
|
|
|
|
FILE* m_pFile;
|
|
bool m_eof_flag, m_error_flag;
|
|
|
|
if (filename.length == 0) throw new Exception("cannot open unnamed file");
|
|
if (filename.length < 512) {
|
|
char[513] buffer;
|
|
//import core.stdc.stdlib : alloca;
|
|
auto tfn = buffer[0 .. filename.length + 1]; // (cast(char*)alloca(filename.length+1))[0..filename.length+1];
|
|
tfn[0..filename.length] = filename[];
|
|
tfn[filename.length] = 0;
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
} else {
|
|
import core.stdc.stdlib : malloc, free;
|
|
auto tfn = (cast(char*)malloc(filename.length+1))[0..filename.length+1];
|
|
if (tfn !is null) {
|
|
scope(exit) free(tfn.ptr);
|
|
m_pFile = fopen(tfn.ptr, "rb");
|
|
}
|
|
}
|
|
if (m_pFile is null) throw new Exception("cannot open file '"~filename.idup~"'");
|
|
scope(exit) if (m_pFile) fclose(m_pFile);
|
|
|
|
return readJpegFromStream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (m_pFile is null) return -1;
|
|
if (m_eof_flag) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (m_error_flag) return -1;
|
|
int bytes_read = cast(int)(fread(pBuf, 1, max_bytes_to_read, m_pFile));
|
|
if (bytes_read < max_bytes_to_read) {
|
|
if (ferror(m_pFile)) {
|
|
m_error_flag = true;
|
|
return -1;
|
|
}
|
|
m_eof_flag = true;
|
|
*pEOF_flag = true;
|
|
}
|
|
return bytes_read;
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
/// decompress JPEG image from memory buffer.
|
|
public MemoryImage readJpegFromMemory (const(void)[] buf) {
|
|
size_t bufpos;
|
|
return readJpegFromStream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
import core.stdc.string : memcpy;
|
|
if (bufpos >= buf.length) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
if (buf.length-bufpos < max_bytes_to_read) max_bytes_to_read = cast(int)(buf.length-bufpos);
|
|
memcpy(pBuf, (cast(const(ubyte)*)buf.ptr)+bufpos, max_bytes_to_read);
|
|
bufpos += max_bytes_to_read;
|
|
return max_bytes_to_read;
|
|
}
|
|
);
|
|
}
|
|
// done with arsd API
|
|
}
|
|
|
|
|
|
static if (JpegHasIVVFS) {
|
|
public MemoryImage readJpeg (VFile fl) {
|
|
return readJpegFromStream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (!fl.isOpen) return -1;
|
|
if (fl.eof) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
auto rd = fl.rawRead(pBuf[0..max_bytes_to_read]);
|
|
if (fl.eof) *pEOF_flag = true;
|
|
return cast(int)rd.length;
|
|
}
|
|
);
|
|
}
|
|
|
|
public bool detectJpeg (VFile fl, out int width, out int height, out int actual_comps) {
|
|
return detect_jpeg_image_from_stream(
|
|
delegate int (void* pBuf, int max_bytes_to_read, bool *pEOF_flag) {
|
|
if (!fl.isOpen) return -1;
|
|
if (fl.eof) {
|
|
*pEOF_flag = true;
|
|
return 0;
|
|
}
|
|
auto rd = fl.rawRead(pBuf[0..max_bytes_to_read]);
|
|
if (fl.eof) *pEOF_flag = true;
|
|
return cast(int)rd.length;
|
|
},
|
|
width, height, actual_comps);
|
|
}
|
|
// vfs API
|
|
}
|
|
|
|
|
|
// ////////////////////////////////////////////////////////////////////////// //
|
|
version(jpegd_test) {
|
|
import arsd.color;
|
|
import arsd.png;
|
|
|
|
void main (string[] args) {
|
|
import std.stdio;
|
|
int width, height, comps;
|
|
{
|
|
assert(detect_jpeg_image_from_file((args.length > 1 ? args[1] : "image.jpg"), width, height, comps));
|
|
writeln(width, "x", height, "x", comps);
|
|
auto img = readJpeg((args.length > 1 ? args[1] : "image.jpg"));
|
|
writeln(img.width, "x", img.height);
|
|
writePng("z00.png", img);
|
|
}
|
|
{
|
|
ubyte[] file;
|
|
{
|
|
auto fl = File(args.length > 1 ? args[1] : "image.jpg");
|
|
file.length = cast(int)fl.size;
|
|
fl.rawRead(file[]);
|
|
}
|
|
assert(detect_jpeg_image_from_memory(file[], width, height, comps));
|
|
writeln(width, "x", height, "x", comps);
|
|
auto img = readJpegFromMemory(file[]);
|
|
writeln(img.width, "x", img.height);
|
|
writePng("z01.png", img);
|
|
}
|
|
}
|
|
}
|