#include <math.h>
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
#include <malloc.h>
#include "libqscale.h"
#define M_PI 3.14159265358979323846264
#endif
+#if USE_VERTICAL_SSE || USE_HORIZONTAL_SSE
+typedef float v4sf __attribute__((vector_size(16)));
+typedef int v4si __attribute__((vector_size(16)));
+typedef short v8hi __attribute__((vector_size(16)));
+typedef char v16qi __attribute__((vector_size(16)));
+#endif
+
qscale_img *qscale_load_jpeg(const char *filename)
{
FILE *file = fopen(filename, "rb");
dinfo.raw_data_out = TRUE;
jpeg_start_decompress(&dinfo);
- /* We do not handle anything but YCbCr images (yet?). */
- if (dinfo.num_components != 3) {
+ if (dinfo.num_components != 1 && dinfo.num_components != 3) {
qscale_destroy(img);
return NULL;
}
+ img->num_components = dinfo.num_components;
img->width = dinfo.image_width;
img->height = dinfo.image_height;
img->w0 = dinfo.image_width * dinfo.comp_info[0].h_samp_factor / dinfo.max_h_samp_factor;
img->h0 = dinfo.image_height * dinfo.comp_info[0].v_samp_factor / dinfo.max_v_samp_factor;
- img->w1 = dinfo.image_width * dinfo.comp_info[1].h_samp_factor / dinfo.max_h_samp_factor;
- img->h1 = dinfo.image_height * dinfo.comp_info[1].v_samp_factor / dinfo.max_v_samp_factor;
+ if (img->num_components == 3) {
+ img->w1 = dinfo.image_width * dinfo.comp_info[1].h_samp_factor / dinfo.max_h_samp_factor;
+ img->h1 = dinfo.image_height * dinfo.comp_info[1].v_samp_factor / dinfo.max_v_samp_factor;
- img->w2 = dinfo.image_width * dinfo.comp_info[2].h_samp_factor / dinfo.max_h_samp_factor;
- img->h2 = dinfo.image_height * dinfo.comp_info[2].v_samp_factor / dinfo.max_v_samp_factor;
+ img->w2 = dinfo.image_width * dinfo.comp_info[2].h_samp_factor / dinfo.max_h_samp_factor;
+ img->h2 = dinfo.image_height * dinfo.comp_info[2].v_samp_factor / dinfo.max_v_samp_factor;
+ }
img->samp_h0 = dinfo.comp_info[0].h_samp_factor;
img->samp_v0 = dinfo.comp_info[0].v_samp_factor;
- img->samp_h1 = dinfo.comp_info[1].h_samp_factor;
- img->samp_v1 = dinfo.comp_info[1].v_samp_factor;
+ if (img->num_components == 3) {
+ img->samp_h1 = dinfo.comp_info[1].h_samp_factor;
+ img->samp_v1 = dinfo.comp_info[1].v_samp_factor;
- img->samp_h2 = dinfo.comp_info[2].h_samp_factor;
- img->samp_v2 = dinfo.comp_info[2].v_samp_factor;
+ img->samp_h2 = dinfo.comp_info[2].h_samp_factor;
+ img->samp_v2 = dinfo.comp_info[2].v_samp_factor;
+ }
img->data_y = (JSAMPLE*)memalign(16, dinfo.comp_info[0].height_in_blocks * dinfo.comp_info[0].width_in_blocks * DCTSIZE * DCTSIZE);
- img->data_cb = (JSAMPLE*)memalign(16, dinfo.comp_info[1].height_in_blocks * dinfo.comp_info[1].width_in_blocks * DCTSIZE * DCTSIZE);
- img->data_cr = (JSAMPLE*)memalign(16, dinfo.comp_info[2].height_in_blocks * dinfo.comp_info[2].width_in_blocks * DCTSIZE * DCTSIZE);
-
- if (img->data_y == NULL || img->data_cb == NULL || img->data_cr == NULL) {
+ if (img->data_y == NULL) {
qscale_destroy(img);
return NULL;
}
+ if (img->num_components == 3) {
+ img->data_cb = (JSAMPLE*)memalign(16, dinfo.comp_info[1].height_in_blocks * dinfo.comp_info[1].width_in_blocks * DCTSIZE * DCTSIZE);
+ img->data_cr = (JSAMPLE*)memalign(16, dinfo.comp_info[2].height_in_blocks * dinfo.comp_info[2].width_in_blocks * DCTSIZE * DCTSIZE);
+ if (img->data_cb == NULL || img->data_cr == NULL) {
+ qscale_destroy(img);
+ return NULL;
+ }
+ }
+
int total_lines = 0, blocks = 0;
while (total_lines < dinfo.comp_info[0].height_in_blocks * DCTSIZE) {
unsigned max_lines = dinfo.max_v_samp_factor * DCTSIZE;
int i;
for (i = 0; i < max_lines; ++i) {
y_row_ptrs[i] = img->data_y + (i+blocks*DCTSIZE*dinfo.comp_info[0].v_samp_factor) * dinfo.comp_info[0].width_in_blocks * DCTSIZE;
- cb_row_ptrs[i] = img->data_cb + (i+blocks*DCTSIZE*dinfo.comp_info[1].v_samp_factor) * dinfo.comp_info[1].width_in_blocks * DCTSIZE;
- cr_row_ptrs[i] = img->data_cr + (i+blocks*DCTSIZE*dinfo.comp_info[2].v_samp_factor) * dinfo.comp_info[2].width_in_blocks * DCTSIZE;
+ if (img->num_components == 3) {
+ cb_row_ptrs[i] = img->data_cb + (i+blocks*DCTSIZE*dinfo.comp_info[1].v_samp_factor) * dinfo.comp_info[1].width_in_blocks * DCTSIZE;
+ cr_row_ptrs[i] = img->data_cr + (i+blocks*DCTSIZE*dinfo.comp_info[2].v_samp_factor) * dinfo.comp_info[2].width_in_blocks * DCTSIZE;
+ }
}
total_lines += max_lines;
return sinc(x*M_PI) * sinc(x*M_PI / 3.0);
}
+static double mitchell_tap(double x)
+{
+ const double b = 1.0 / 3.0;
+ const double c = 1.0 / 3.0;
+ const double p0 = ( 6.0 - 2.0*b ) / 6.0;
+ const double p2 = (-18.0 + 12.0*b + 6.0*c) / 6.0;
+ const double p3 = ( 12.0 - 9.0*b - 6.0*c) / 6.0;
+ const double q0 = ( 8.0*b + 24.0*c) / 6.0;
+ const double q1 = ( - 12.0*b - 48.0*c) / 6.0;
+ const double q2 = ( 6.0*b + 30.0*c) / 6.0;
+ const double q3 = ( - b - 6.0*c) / 6.0;
+
+ if (x < -2.0) {
+ return 0.0;
+ } else if (x < -1.0) {
+ return q0 - x * (q1 - x * (q2 - x * q3));
+ } else if (x < 0.0) {
+ return p0 + x * x * (p2 - x * p3);
+ } else if (x < 1.0) {
+ return p0 + x * x * (p2 + x * p3);
+ } else if (x < 2.0) {
+ return q0 + x * (q1 + x * (q2 + x * q3));
+ } else {
+ return 0.0;
+ }
+}
+
struct pix_desc {
unsigned start, end;
unsigned startcoeff;
};
-static void hscale(float *pix, unsigned char *npix, unsigned w, unsigned h, unsigned nw, unsigned sstride, unsigned dstride)
+static void hscale(float *pix, unsigned char *npix, unsigned w, unsigned h, unsigned nw, unsigned sstride, unsigned dstride, enum qscale_scaling_filter scaling_filter)
{
struct pix_desc *pd = (struct pix_desc *)malloc(nw * sizeof(struct pix_desc));
int size_coeffs = 8;
int num_coeffs = 0;
int x, y;
double sf = (double)w / (double)nw;
- double support = (w > nw) ? (3.0 * sf) : (3.0 / sf);
+ double support;
+
+ if (scaling_filter == LANCZOS) {
+ support = (w > nw) ? (3.0 * sf) : (3.0 / sf);
+ } else { /* Mitchell */
+ support = (w > nw) ? (2.0 * sf) : (2.0 / sf);
+ }
/* calculate the filter */
for (x = 0; x < nw; ++x) {
for (sx = start; sx <= end; ++sx) {
double nd = (w > nw) ? (sx/sf - x) : (sx - x*sf);
- double f = lanczos_tap(nd);
+ double f;
+ if (scaling_filter == LANCZOS) {
+ f = lanczos_tap(nd);
+ } else { /* Mitchell */
+ f = mitchell_tap(nd);
+ }
if (num_coeffs == size_coeffs) {
size_coeffs <<= 1;
coeffs = (float *)realloc(coeffs, size_coeffs * sizeof(float));
unsigned char ch;
for (x = 0; x < nw; ++x) {
#if USE_HORIZONTAL_SSE
+ v4sf acc = { 0.0f, 0.0f, 0.0f, 0.0f };
+ static const v4sf low = { 0.0f, 0.0f, 0.0f, 0.0f };
+ static const v4sf high = { 255.0f, 255.0f, 255.0f, 255.0f };
int result;
- float acc;
- long tmp;
- static const float low = 0.0, high = 255.0;
- __asm__ (
- "pxor %1, %1 \n"
- "xor %2, %2 \n"
- "0: \n"
- "movups (%4,%2),%%xmm1 \n"
- "movups (%3,%2),%%xmm2 \n"
- "mulps %%xmm2,%%xmm1 \n"
- "addps %%xmm1,%1 \n"
- "add $16,%2 \n"
- "dec %5 \n"
- "jnz 0b \n"
- "haddps %1,%1 \n"
- "haddps %1,%1 \n"
- "maxss %6,%1 \n"
- "minss %7,%1 \n"
- "cvtss2si %1,%0 \n"
- : "=r" (result),
- "=&x" (acc),
- "=&r" (tmp)
- : "r" (&coeffs[pd[x].startcoeff]),
- "r" (&sptr[pd[x].start]),
- "r" ((pd[x].end - pd[x].start + 1)/4),
- "m" (low),
- "m" (high)
- : "memory", "xmm1", "xmm2"
- );
+ int i;
+
+ const float *sptr_xmm = &sptr[pd[x].start];
+ const float *coeffptr = &coeffs[pd[x].startcoeff];
+ const int filter_len = (pd[x].end - pd[x].start + 1) / 4;
+
+ for (i = 0; i < filter_len; ++i) {
+ v4sf pixels = __builtin_ia32_loadups(&sptr_xmm[i * 4]);
+ v4sf coeffs = __builtin_ia32_loadups(&coeffptr[i * 4]);
+ acc = __builtin_ia32_addps(acc, __builtin_ia32_mulps(pixels, coeffs));
+ }
+ acc = __builtin_ia32_haddps(acc, acc);
+ acc = __builtin_ia32_haddps(acc, acc);
+ acc = __builtin_ia32_maxss(acc, low);
+ acc = __builtin_ia32_minss(acc, high);
+ result = __builtin_ia32_cvtss2si(acc);
*dptr++ = (unsigned char)result;
#else
*dptr++ = ch;
}
}
+
+ free(pd);
+ free(coeffs);
}
-static void vscale(unsigned char *pix, float *npix, unsigned w, unsigned h, unsigned nh, unsigned dstride)
+static void vscale(unsigned char *pix, float *npix, unsigned w, unsigned h, unsigned nh, unsigned dstride, enum qscale_scaling_filter scaling_filter)
{
struct pix_desc *pd = (struct pix_desc *)malloc(nh * sizeof(struct pix_desc));
int size_coeffs = 8;
int num_coeffs = 0;
int x, y, sy;
double sf = (double)h / (double)nh;
- double support = (h > nh) ? (3.0 * sf) : (3.0 / sf);
+ double support;
+
+ if (scaling_filter == LANCZOS) {
+ support = (h > nh) ? (3.0 * sf) : (3.0 / sf);
+ } else { /* Mitchell */
+ support = (h > nh) ? (2.0 * sf) : (2.0 / sf);
+ }
/* calculate the filter */
for (y = 0; y < nh; ++y) {
for (sy = start; sy <= end; ++sy) {
double nd = (h > nh) ? (sy/sf - y) : (sy - y*sf);
- double f = lanczos_tap(nd);
+ double f;
+ if (scaling_filter == LANCZOS) {
+ f = lanczos_tap(nd);
+ } else { /* Mitchell */
+ f = mitchell_tap(nd);
+ }
if (num_coeffs == size_coeffs) {
size_coeffs <<= 1;
coeffs = (float *)realloc(coeffs, size_coeffs * sizeof(float));
float *dptr = npix + x;
for (y = 0; y < nh; ++y) {
#if USE_VERTICAL_SSE
- /*
- * xmm0 - xmm3: acc[0..15]
- * xmm4: current filter coefficient
- * xmm5, xmm6, xmm7: scratchpad
- */
- __asm__ (
- /* clear */
- "pxor %%xmm0, %%xmm0 \n"
- "pxor %%xmm1, %%xmm1 \n"
- "pxor %%xmm2, %%xmm2 \n"
- "pxor %%xmm3, %%xmm3 \n"
-
- /* main loop */
- "0: \n"
-
- /* a zero is useful during unpacking */
- "pxor %%xmm4, %%xmm4 \n"
-
- /* fetch all 16 source bytes */
- "movups (%0), %%xmm5 \n"
- "prefetcht0 (%0,%3,4) \n"
-
- /* unpack into words (xmm5, xmm7) */
- "movaps %%xmm5, %%xmm7 \n"
- "punpcklbw %%xmm4, %%xmm5 \n"
- "punpckhbw %%xmm4, %%xmm7 \n"
-
- /* unpack xmm5 into dwords (xmm5, xmm6) */
- "movaps %%xmm5, %%xmm6 \n"
- "punpcklwd %%xmm4, %%xmm5 \n"
- "punpckhwd %%xmm4, %%xmm6 \n"
-
- /* convert xmm5, xmm6 to floats */
- "cvtdq2ps %%xmm5, %%xmm5 \n"
- "cvtdq2ps %%xmm6, %%xmm6 \n"
-
- /* fetch the coefficient */
- "movss (%2), %%xmm4 \n"
- "shufps $0x0, %%xmm4, %%xmm4 \n"
-
- /* do the muls for xmm5 and xmm6 */
- "mulps %%xmm4, %%xmm5 \n"
- "mulps %%xmm4, %%xmm6 \n"
- "addps %%xmm5, %%xmm0 \n"
- "addps %%xmm6, %%xmm1 \n"
-
- /* get the zero back again */
- "pxor %%xmm4, %%xmm4 \n"
-
- /* unpack xmm7 into dwords (xmm7, xmm6) */
- "movaps %%xmm7, %%xmm6 \n"
- "punpcklwd %%xmm4, %%xmm7 \n"
- "punpckhwd %%xmm4, %%xmm6 \n"
-
- /* convert xmm7, xmm6 to floats */
- "cvtdq2ps %%xmm7, %%xmm7 \n"
- "cvtdq2ps %%xmm6, %%xmm6 \n"
-
- /* fetch the coefficient */
- "movss (%2), %%xmm4 \n"
- "shufps $0x0, %%xmm4, %%xmm4 \n"
-
- /* do the second set of muls */
- "mulps %%xmm4, %%xmm7 \n"
- "mulps %%xmm4, %%xmm6 \n"
- "addps %%xmm7, %%xmm2 \n"
- "addps %%xmm6, %%xmm3 \n"
-
- /* move along, and loop */
- "add $4, %2 \n"
- "add %3, %0 \n"
- "dec %1 \n"
- "jnz 0b \n"
-
- /* store the values */
- "movaps %%xmm0, (%4) \n"
- "movaps %%xmm1, 16(%4) \n"
- "movaps %%xmm2, 32(%4) \n"
- "movaps %%xmm3, 48(%4) \n"
- : :
- "r" (&sptr[pd[y].start * w]), /* 0: srcptr base */
- "r" (pd[y].end - pd[y].start + 1), /* 1: filter len */
- "r" (&coeffs[pd[y].startcoeff]), /* 2: coeffs base */
- "r" ((long)w), /* 3: stride */
- "r" (dptr) /* 4: dstptr base */
- : "memory", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
- );
+ /* A zero is useful during unpacking. */
+ static const v4sf zero = { 0.0f, 0.0f, 0.0f, 0.0f };
+ const unsigned char *sptr_xmm = &sptr[pd[y].start * w];
+ const float *coeffptr = &coeffs[pd[y].startcoeff];
+ const int filter_len = pd[y].end - pd[y].start + 1;
+ int i;
+
+ v4sf acc0 = { 0.0f, 0.0f, 0.0f, 0.0f };
+ v4sf acc1 = { 0.0f, 0.0f, 0.0f, 0.0f };
+ v4sf acc2 = { 0.0f, 0.0f, 0.0f, 0.0f };
+ v4sf acc3 = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+ for (i = 0; i < filter_len; ++i, ++coeffptr, sptr_xmm += w) {
+ __builtin_prefetch(sptr_xmm + w, 0);
+ v16qi src = (v16qi)__builtin_ia32_loadups((float*)sptr_xmm);
+
+ // unpack into words
+ v8hi src_lo = (v8hi)__builtin_ia32_punpcklbw128(src, (v16qi)zero);
+ v8hi src_hi = (v8hi)__builtin_ia32_punpckhbw128(src, (v16qi)zero);
+
+ // unpack into dwords, convert to floats
+ v4si src0_i = (v4si)__builtin_ia32_punpcklwd128(src_lo, (v8hi)zero);
+ v4si src1_i = (v4si)__builtin_ia32_punpckhwd128(src_lo, (v8hi)zero);
+ v4si src2_i = (v4si)__builtin_ia32_punpcklwd128(src_hi, (v8hi)zero);
+ v4si src3_i = (v4si)__builtin_ia32_punpckhwd128(src_hi, (v8hi)zero);
+
+ v4sf src0 = __builtin_ia32_cvtdq2ps(src0_i);
+ v4sf src1 = __builtin_ia32_cvtdq2ps(src1_i);
+ v4sf src2 = __builtin_ia32_cvtdq2ps(src2_i);
+ v4sf src3 = __builtin_ia32_cvtdq2ps(src3_i);
+
+ // fetch the coefficient, and replicate it
+ v4sf coeff = { *coeffptr, *coeffptr, *coeffptr, *coeffptr };
+
+ // do the actual muladds
+ acc0 = __builtin_ia32_addps(acc0, __builtin_ia32_mulps(src0, coeff));
+ acc1 = __builtin_ia32_addps(acc1, __builtin_ia32_mulps(src1, coeff));
+ acc2 = __builtin_ia32_addps(acc2, __builtin_ia32_mulps(src2, coeff));
+ acc3 = __builtin_ia32_addps(acc3, __builtin_ia32_mulps(src3, coeff));
+ }
+
+ *(v4sf *)(&dptr[0]) = acc0;
+ *(v4sf *)(&dptr[4]) = acc1;
+ *(v4sf *)(&dptr[8]) = acc2;
+ *(v4sf *)(&dptr[12]) = acc3;
#else
int i;
float acc[CACHE_LINE_FACTOR];
dptr += dstride;
}
}
+
+ free(pd);
+ free(coeffs);
+}
+
+qscale_img *qscale_clone(const qscale_img *img)
+{
+ qscale_img *dst = (qscale_img *)malloc(sizeof(qscale_img));
+ if (dst == NULL) {
+ return NULL;
+ }
+
+ *dst = *img;
+
+ unsigned dstride0 = (dst->w0 + DCTSIZE-1) & ~(DCTSIZE-1);
+ unsigned dstride1 = (dst->w1 + DCTSIZE-1) & ~(DCTSIZE-1);
+ unsigned dstride2 = (dst->w2 + DCTSIZE-1) & ~(DCTSIZE-1);
+
+ /* FIXME: handle out-of-memory gracefully */
+ {
+ dst->data_y = (unsigned char *)malloc(dst->h0 * dstride0);
+ memcpy(dst->data_y, img->data_y, dst->h0 * dstride0);
+ }
+ {
+ dst->data_cb = (unsigned char *)malloc(dst->h1 * dstride1);
+ memcpy(dst->data_cb, img->data_cb, dst->h1 * dstride1);
+ }
+ {
+ dst->data_cr = (unsigned char *)malloc(dst->h2 * dstride2);
+ memcpy(dst->data_cr, img->data_cr, dst->h2 * dstride2);
+ }
+
+ return dst;
}
qscale_img *qscale_scale(qscale_img *src, unsigned width, unsigned height, unsigned samp_h0, unsigned samp_v0, unsigned samp_h1, unsigned samp_v1, unsigned samp_h2, unsigned samp_v2, enum qscale_scaling_filter scaling_filter)
dst->width = width;
dst->height = height;
+ dst->num_components = src->num_components;
unsigned max_samp_h, max_samp_v;
max_samp_h = samp_h0;
- if (samp_h1 > max_samp_h)
- max_samp_h = samp_h1;
- if (samp_h2 > max_samp_h)
- max_samp_h = samp_h2;
+ if (src->num_components == 3) {
+ if (samp_h1 > max_samp_h)
+ max_samp_h = samp_h1;
+ if (samp_h2 > max_samp_h)
+ max_samp_h = samp_h2;
+ }
max_samp_v = samp_v0;
- if (samp_v1 > max_samp_v)
- max_samp_v = samp_v1;
- if (samp_v2 > max_samp_v)
- max_samp_v = samp_v2;
+ if (src->num_components == 3) {
+ if (samp_v1 > max_samp_v)
+ max_samp_v = samp_v1;
+ if (samp_v2 > max_samp_v)
+ max_samp_v = samp_v2;
+ }
dst->w0 = width * samp_h0 / max_samp_h;
dst->h0 = height * samp_v0 / max_samp_v;
- dst->w1 = width * samp_h1 / max_samp_h;
- dst->h1 = height * samp_v1 / max_samp_v;
+ if (src->num_components == 3) {
+ dst->w1 = width * samp_h1 / max_samp_h;
+ dst->h1 = height * samp_v1 / max_samp_v;
- dst->w2 = width * samp_h2 / max_samp_h;
- dst->h2 = height * samp_v2 / max_samp_v;
+ dst->w2 = width * samp_h2 / max_samp_h;
+ dst->h2 = height * samp_v2 / max_samp_v;
+ }
dst->samp_h0 = samp_h0;
dst->samp_v0 = samp_v0;
- dst->samp_h1 = samp_h1;
- dst->samp_v1 = samp_v1;
+ if (src->num_components == 3) {
+ dst->samp_h1 = samp_h1;
+ dst->samp_v1 = samp_v1;
- dst->samp_h2 = samp_h2;
- dst->samp_v2 = samp_v2;
+ dst->samp_h2 = samp_h2;
+ dst->samp_v2 = samp_v2;
+ }
unsigned dstride0 = (dst->w0 + DCTSIZE-1) & ~(DCTSIZE-1);
unsigned dstride1 = (dst->w1 + DCTSIZE-1) & ~(DCTSIZE-1);
/* FIXME: handle out-of-memory gracefully */
{
float *npix = (float*)memalign(16, sstride0 * dst->h0 * sizeof(float));
- vscale(src->data_y, npix, sstride0, src->h0, dst->h0, sstride0);
+ vscale(src->data_y, npix, sstride0, src->h0, dst->h0, sstride0, scaling_filter);
dst->data_y = (unsigned char *)malloc(dst->h0 * dstride0);
- hscale(npix, dst->data_y, src->w0, dst->h0, dst->w0, sstride0, dstride0);
- free(npix);
- }
- {
- float *npix = (float*)memalign(16, sstride1 * dst->h1 * sizeof(float));
- vscale(src->data_cr, npix, sstride1, src->h1, dst->h1, sstride1);
- dst->data_cr = (unsigned char *)malloc(dst->h1 * dstride1);
- hscale(npix, dst->data_cr, src->w1, dst->h1, dst->w1, sstride1, dstride1);
+ hscale(npix, dst->data_y, src->w0, dst->h0, dst->w0, sstride0, dstride0, scaling_filter);
free(npix);
}
- {
- float *npix = (float*)memalign(16, sstride2 * dst->h2 * sizeof(float));
- vscale(src->data_cb, npix, sstride2, src->h2, dst->h2, sstride2);
- dst->data_cb = (unsigned char *)malloc(dst->h2 * dstride2);
- hscale(npix, dst->data_cb, src->w2, dst->h2, dst->w2, sstride2, dstride2);
- free(npix);
+ if (src->num_components == 3) {
+ {
+ float *npix = (float*)memalign(16, sstride1 * dst->h1 * sizeof(float));
+ vscale(src->data_cr, npix, sstride1, src->h1, dst->h1, sstride1, scaling_filter);
+ dst->data_cr = (unsigned char *)malloc(dst->h1 * dstride1);
+ hscale(npix, dst->data_cr, src->w1, dst->h1, dst->w1, sstride1, dstride1, scaling_filter);
+ free(npix);
+ }
+ {
+ float *npix = (float*)memalign(16, sstride2 * dst->h2 * sizeof(float));
+ vscale(src->data_cb, npix, sstride2, src->h2, dst->h2, sstride2, scaling_filter);
+ dst->data_cb = (unsigned char *)malloc(dst->h2 * dstride2);
+ hscale(npix, dst->data_cb, src->w2, dst->h2, dst->w2, sstride2, dstride2, scaling_filter);
+ free(npix);
+ }
}
return dst;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, file);
- cinfo.input_components = 3;
+ cinfo.input_components = img->num_components;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, jpeg_quality, FALSE);
+
+ if (jpeg_mode == PROGRESSIVE) {
+ jpeg_simple_progression(&cinfo);
+ }
+
cinfo.image_width = img->width;
cinfo.image_height = img->height;
cinfo.raw_data_in = TRUE;
- jpeg_set_colorspace(&cinfo, JCS_YCbCr);
+ if (img->num_components == 3) {
+ jpeg_set_colorspace(&cinfo, JCS_YCbCr);
+ } else {
+ jpeg_set_colorspace(&cinfo, JCS_GRAYSCALE);
+ }
cinfo.comp_info[0].h_samp_factor = img->samp_h0;
cinfo.comp_info[0].v_samp_factor = img->samp_v0;
- cinfo.comp_info[1].h_samp_factor = img->samp_h1;
- cinfo.comp_info[1].v_samp_factor = img->samp_v1;
- cinfo.comp_info[2].h_samp_factor = img->samp_h2;
- cinfo.comp_info[2].v_samp_factor = img->samp_v2;
+ if (img->num_components == 3) {
+ cinfo.comp_info[1].h_samp_factor = img->samp_h1;
+ cinfo.comp_info[1].v_samp_factor = img->samp_v1;
+ cinfo.comp_info[2].h_samp_factor = img->samp_h2;
+ cinfo.comp_info[2].v_samp_factor = img->samp_v2;
+ }
jpeg_start_compress(&cinfo, TRUE);
unsigned dstride0 = (img->w0 + DCTSIZE-1) & ~(DCTSIZE-1);
if (yline > img->h0 - 1)
yline = img->h0 - 1;
- int cbline = i + blocks*DCTSIZE*cinfo.comp_info[1].v_samp_factor;
- if (cbline > img->h1 - 1)
- cbline = img->h1 - 1;
+ y_row_ptrs[i] = img->data_y + yline * dstride0;
- int crline = i + blocks*DCTSIZE*cinfo.comp_info[2].v_samp_factor;
- if (crline > img->h2 - 1)
- crline = img->h2 - 1;
+ if (img->num_components == 3) {
+ int cbline = i + blocks*DCTSIZE*cinfo.comp_info[1].v_samp_factor;
+ if (cbline > img->h1 - 1)
+ cbline = img->h1 - 1;
- y_row_ptrs[i] = img->data_y + yline * dstride0;
- cb_row_ptrs[i] = img->data_cb + cbline * dstride1;
- cr_row_ptrs[i] = img->data_cr + crline * dstride2;
+ int crline = i + blocks*DCTSIZE*cinfo.comp_info[2].v_samp_factor;
+ if (crline > img->h2 - 1)
+ crline = img->h2 - 1;
+
+ cb_row_ptrs[i] = img->data_cb + cbline * dstride1;
+ cr_row_ptrs[i] = img->data_cr + crline * dstride2;
+ }
}
total_lines += max_lines;
projects / qscale / blobdiff