static void
convertToJasperImage(struct pam * const inpamP,
jas_image_t ** const jasperPP) {
jas_image_t * jasperP;
createJasperImage(inpamP, &jasperP);
if (strncmp(inpamP->tuple_type, "RGB", 3) == 0) {
if (inpamP->depth < 3)
pm_error("Input tuple type is RGB*, but depth is only %d. "
"It should be at least 3.", inpamP->depth);
else {
jas_image_setclrspc(jasperP, JAS_CLRSPC_GENRGB);
jas_image_setcmpttype(jasperP, 0,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R));
jas_image_setcmpttype(jasperP, 1,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G));
jas_image_setcmpttype(jasperP, 2,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B));
}
} else {
if (strncmp(inpamP->tuple_type, "GRAYSCALE", 9 == 0) ||
strncmp(inpamP->tuple_type, "BLACKANDWHITE", 13) == 0) {
jas_image_setclrspc(jasperP, JAS_CLRSPC_GENGRAY);
jas_image_setcmpttype(jasperP, 0,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y));
}
}
createJasperRaster(inpamP, jasperP);
*jasperPP = jasperP;
}
static uint_fast32_t jp2_gettypeasoc(int colorspace, int ctype)
{
int type;
int asoc;
if (ctype & JAS_IMAGE_CT_OPACITY) {
type = JP2_CDEF_TYPE_OPACITY;
asoc = JP2_CDEF_ASOC_ALL;
goto done;
}
type = JP2_CDEF_TYPE_UNSPEC;
asoc = JP2_CDEF_ASOC_NONE;
switch (jas_clrspc_fam(colorspace)) {
case JAS_CLRSPC_FAM_RGB:
switch (JAS_IMAGE_CT_COLOR(ctype)) {
case JAS_IMAGE_CT_RGB_R:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_RGB_R;
break;
case JAS_IMAGE_CT_RGB_G:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_RGB_G;
break;
case JAS_IMAGE_CT_RGB_B:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_RGB_B;
break;
}
break;
case JAS_CLRSPC_FAM_YCBCR:
switch (JAS_IMAGE_CT_COLOR(ctype)) {
case JAS_IMAGE_CT_YCBCR_Y:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_YCBCR_Y;
break;
case JAS_IMAGE_CT_YCBCR_CB:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_YCBCR_CB;
break;
case JAS_IMAGE_CT_YCBCR_CR:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_YCBCR_CR;
break;
}
break;
case JAS_CLRSPC_FAM_GRAY:
type = JP2_CDEF_TYPE_COLOR;
asoc = JP2_CDEF_GRAY_Y;
break;
}
done:
return (type << 16) | asoc;
}
jas_image_t *pnm_decode(jas_stream_t *in, char *opts)
{
pnm_hdr_t hdr;
jas_image_t *image;
jas_image_cmptparm_t cmptparms[3];
jas_image_cmptparm_t *cmptparm;
int i;
if (opts) {
jas_eprintf("warning: ignoring options\n");
}
/* Read the file header. */
if (pnm_gethdr(in, &hdr)) {
return 0;
}
/* Create an image of the correct size. */
for (i = 0, cmptparm = cmptparms; i < hdr.numcmpts; ++i, ++cmptparm) {
cmptparm->tlx = 0;
cmptparm->tly = 0;
cmptparm->hstep = 1;
cmptparm->vstep = 1;
cmptparm->width = hdr.width;
cmptparm->height = hdr.height;
cmptparm->prec = pnm_maxvaltodepth(hdr.maxval);
cmptparm->sgnd = hdr.sgnd;
}
if (!(image = jas_image_create(hdr.numcmpts, cmptparms, JAS_CLRSPC_UNKNOWN))) {
return 0;
}
if (hdr.numcmpts == 3) {
jas_image_setclrspc(image, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
jas_image_setcmpttype(image, 1,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
jas_image_setcmpttype(image, 2,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
} else {
jas_image_setclrspc(image, JAS_CLRSPC_SGRAY);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
}
/* Read image data from stream into image. */
if (pnm_getdata(in, &hdr, image)) {
jas_image_destroy(image);
return 0;
}
return image;
}
static jas_image_t *jpg_mkimage(j_decompress_ptr cinfo)
{
jas_image_t *image;
int cmptno;
jas_image_cmptparm_t cmptparm;
int numcmpts;
image = 0;
numcmpts = cinfo->output_components;
if (!(image = jas_image_create0())) {
goto error;
}
for (cmptno = 0; cmptno < numcmpts; ++cmptno) {
cmptparm.tlx = 0;
cmptparm.tly = 0;
cmptparm.hstep = 1;
cmptparm.vstep = 1;
cmptparm.width = cinfo->image_width;
cmptparm.height = cinfo->image_height;
cmptparm.prec = 8;
cmptparm.sgnd = false;
if (jas_image_addcmpt(image, cmptno, &cmptparm)) {
goto error;
}
}
if (numcmpts == 3) {
jas_image_setclrspc(image, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
jas_image_setcmpttype(image, 1,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
jas_image_setcmpttype(image, 2,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
} else {
jas_image_setclrspc(image, JAS_CLRSPC_SGRAY);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
}
return image;
error:
if (image) {
jas_image_destroy(image);
}
return 0;
}
static void
getRgbComponents(int jasperCmpnt[], jas_image_t * const jasperP) {
{
int const rc =
jas_image_getcmptbytype(jasperP,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R));
if (rc < 0)
pm_error("Input says it has RGB color space, but contains "
"no red component");
else
jasperCmpnt[PAM_RED_PLANE] = rc;
if (jas_image_cmptsgnd(jasperP, rc))
pm_error("Input image says it is RGB, but has signed values "
"for what should be the red intensities.");
}
{
int const rc =
jas_image_getcmptbytype(jasperP,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G));
if (rc < 0)
pm_error("Input says it has RGB color space, but contains "
"no green component");
else
jasperCmpnt[PAM_GRN_PLANE] = rc;
if (jas_image_cmptsgnd(jasperP, rc))
pm_error("Input image says it is RGB, but has signed values "
"for what should be the green intensities.");
}
{
int const rc =
jas_image_getcmptbytype(jasperP,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B));
if (rc < 0)
pm_error("Input says it has RGB color space, but contains "
"no blue component");
else
jasperCmpnt[PAM_BLU_PLANE] = rc;
if (jas_image_cmptsgnd(jasperP, rc))
pm_error("Input image says it is RGB, but has signed values "
"for what should be the blue intensities.");
}
}
int imFileFormatJP2::WriteImageData(void* data)
{
int count = imFileLineBufferCount(this);
imCounterTotal(this->counter, count, "Writing JP2..."); /* first time count */
int depth = imColorModeDepth(this->file_color_mode);
if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode))
{
jas_image_setcmpttype(image, depth-1, JAS_IMAGE_CT_OPACITY);
depth--;
}
for (int d = 0; d < depth; d++)
jas_image_setcmpttype(image, d, JAS_IMAGE_CT_COLOR(d));
int row = 0, plane = 0;
for (int i = 0; i < count; i++)
{
imFileLineBufferWrite(this, data, row, plane);
int ret = 1;
if (this->file_data_type == IM_BYTE)
ret = iJP2WriteLine(image, row, plane, (imbyte*)this->line_buffer);
else
ret = iJP2WriteLine(image, row, plane, (imushort*)this->line_buffer);
if (!ret)
return IM_ERR_ACCESS;
if (!imCounterInc(this->counter))
return IM_ERR_COUNTER;
imFileLineBufferInc(this, &row, &plane);
}
char outopts[512] = "";
imAttribTable* attrib_table = AttribTable();
float* ratio = (float*)attrib_table->Get("CompressionRatio");
if (ratio)
sprintf(outopts, "rate=%g", (double)(1.0 / *ratio));
// The counter continuous because in Jasper all image writing is done here. BAD!
ijp2_counter = this->counter;
ijp2_abort = 0;
ijp2_message = NULL; /* other counts */
int err = jas_image_encode(image, stream, 0 /*JP2 format always */, outopts);
ijp2_counter = -1;
if (err)
return IM_ERR_ACCESS;
jas_stream_flush(stream);
return IM_ERR_NONE;
}
int jp2_getct(int colorspace, int type, int assoc)
{
if (type == 1 && assoc == 0) {
return JAS_IMAGE_CT_OPACITY;
}
if (type == 0 && assoc >= 1 && assoc <= 65534) {
switch (colorspace) {
case JAS_IMAGE_CS_RGB:
switch (assoc) {
case JP2_CDEF_RGB_R:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R);
break;
case JP2_CDEF_RGB_G:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G);
break;
case JP2_CDEF_RGB_B:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B);
break;
}
break;
case JAS_IMAGE_CS_YCBCR:
switch (assoc) {
case JP2_CDEF_YCBCR_Y:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_Y);
break;
case JP2_CDEF_YCBCR_CB:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CB);
break;
case JP2_CDEF_YCBCR_CR:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CR);
break;
}
break;
case JAS_IMAGE_CS_GRAY:
switch (assoc) {
case JP2_CDEF_GRAY_Y:
return JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y);
break;
}
break;
#if 0
case JAS_IMAGE_CS_ICC:
#endif
default:
return JAS_IMAGE_CT_COLOR(assoc - 1);
break;
}
}
return JAS_IMAGE_CT_UNKNOWN;
}
static int jp2_getct(int colorspace, int type, int assoc)
{
if (type == 1 && assoc == 0) {
return JAS_IMAGE_CT_OPACITY;
}
if (type == 0 && assoc >= 1 && assoc <= 65534) {
switch (colorspace) {
case JAS_CLRSPC_FAM_RGB:
switch (assoc) {
case JP2_CDEF_RGB_R:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R);
break;
case JP2_CDEF_RGB_G:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G);
break;
case JP2_CDEF_RGB_B:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B);
break;
}
break;
case JAS_CLRSPC_FAM_YCBCR:
switch (assoc) {
case JP2_CDEF_YCBCR_Y:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y);
break;
case JP2_CDEF_YCBCR_CB:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB);
break;
case JP2_CDEF_YCBCR_CR:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR);
break;
}
break;
case JAS_CLRSPC_FAM_GRAY:
switch (assoc) {
case JP2_CDEF_GRAY_Y:
return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
break;
}
break;
default:
return JAS_IMAGE_CT_COLOR(assoc - 1);
break;
}
}
return JAS_IMAGE_CT_UNKNOWN;
}
static void
getGrayComponent(int * jasperCmptP, jas_image_t * const jasperP) {
int const rc =
jas_image_getcmptbytype(jasperP,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y));
if (rc < 0)
pm_error("Input says it has Grayscale color space, but contains "
"no gray intensity component");
else
*jasperCmptP = rc;
if (jas_image_cmptsgnd(jasperP, 0))
pm_error("Input image says it is grayscale, but has signed values "
"for what should be the gray levels.");
}
int imFileFormatJP2::ReadImageData(void* data)
{
int count = imFileLineBufferCount(this);
imCounterTotal(this->counter, count, NULL);
int alpha_plane = -1;
if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode))
alpha_plane = imColorModeDepth(this->file_color_mode) - 1;
int row = 0, plane = 0;
for (int i = 0; i < count; i++)
{
int cmpno;
if (plane == alpha_plane)
cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_OPACITY);
else
cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_COLOR(plane));
if (cmpno == -1)
return IM_ERR_DATA;
int ret = 1;
if (this->file_data_type == IM_BYTE)
ret = iJP2ReadLine(image, row, cmpno, (imbyte*)this->line_buffer);
else
ret = iJP2ReadLine(image, row, cmpno, (imushort*)this->line_buffer);
if (!ret)
return IM_ERR_ACCESS;
imFileLineBufferRead(this, data, row, plane);
if (!imCounterInc(this->counter))
return IM_ERR_COUNTER;
imFileLineBufferInc(this, &row, &plane);
}
return IM_ERR_NONE;
}
DEFINE_LOADER_PLUGIN_LOAD(p, st, vw
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, c
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, priv
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
)
{
jas_image_t *ji;
jas_stream_t *js;
unsigned char *d;
char *buf = NULL;
int k, cmp[3];
unsigned int i, j;
int tlx, tly;
int vs, hs;
//debug_message("JasPer: load() called\n");
#ifdef IDENTIFY_BEFORE_LOAD
{
LoaderStatus status;
if ((status = identify(p, st, vw, c, priv)) != LOAD_OK)
return status;
stream_rewind(st);
}
#endif
/* Read whole stream into buffer... */
{
char *tmp;
int size = 0, len;
int bufsize = 65536;
for (;;) {
if ((tmp = realloc(buf, bufsize)) == NULL) {
free(buf);
return LOAD_ERROR;
}
buf = tmp;
len = stream_read(st, (unsigned char *)(buf + size), bufsize - size);
size += len;
if (len < bufsize - size)
break;
bufsize += 65536;
}
if ((js = jas_stream_memopen(buf, size)) == NULL) {
free(buf);
return LOAD_ERROR;
}
}
/* loading... */
if ((ji = jas_image_decode(js, -1, 0)) == NULL) {
err_message_fnc("jas_image_decode() failed.\n");
goto error_clear;
}
/* colorspace conversion */
{
jas_cmprof_t *jc;
jas_image_t *new_ji;
if ((jc = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)) == NULL)
goto error_destroy_free;
if ((new_ji = jas_image_chclrspc(ji, jc, JAS_CMXFORM_INTENT_PER)) == NULL)
goto error_destroy_free;
jas_image_destroy(ji);
ji = new_ji;
}
jas_stream_close(js);
free(buf);
debug_message("JasPer: jas_image_decode() OK: (%ld,%ld)\n", jas_image_cmptwidth(ji, 0), jas_image_cmptheight(ji, 0));
/* convert to enfle format */
p->bits_per_pixel = 24;
p->type = _RGB24;
p->depth = 24;
cmp[0] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
cmp[1] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
cmp[2] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
/* dimension */
image_width(p) = jas_image_cmptwidth(ji, cmp[0]);
image_height(p) = jas_image_cmptheight(ji, cmp[0]);
image_left(p) = 0;
image_top(p) = 0;
image_bpl(p) = image_width(p) * 3;
tlx = jas_image_cmpttlx(ji, cmp[0]);
tly = jas_image_cmpttly(ji, cmp[0]);
vs = jas_image_cmptvstep(ji, cmp[0]);
hs = jas_image_cmpthstep(ji, cmp[0]);
debug_message("JasPer: tlx %d tly %d vs %d hs %d ncomponents %d\n", tlx, tly, vs, hs, jas_image_numcmpts(ji));
/* memory allocation */
if ((d = memory_alloc(image_image(p), image_bpl(p) * image_height(p))) == NULL) {
err_message("No enough memory (%d bytes)\n", image_bpl(p) * image_height(p));
goto error_destroy_free;
}
for (i = 0; i < image_height(p); i++) {
for (j = 0; j < image_width(p); j++) {
for (k = 0; k < 3; k++)
*d++ = jas_image_readcmptsample(ji, cmp[k], j, i);
}
}
jas_image_destroy(ji);
return LOAD_OK;
error_destroy_free:
jas_image_destroy(ji);
error_clear:
return LOAD_ERROR;
}
static DFBResult
IDirectFBImageProvider_JPEG2000_RenderTo( IDirectFBImageProvider *thiz,
IDirectFBSurface *destination,
const DFBRectangle *dest_rect )
{
IDirectFBSurface_data *dst_data;
CoreSurface *dst_surface;
CoreSurfaceBufferLock lock;
DFBRectangle rect;
DFBRegion clip;
DIRenderCallbackResult cb_result = DIRCR_OK;
DFBResult ret = DFB_OK;
DIRECT_INTERFACE_GET_DATA( IDirectFBImageProvider_JPEG2000 )
if (!destination)
return DFB_INVARG;
dst_data = destination->priv;
if (!dst_data || !dst_data->surface)
return DFB_DESTROYED;
dst_surface = dst_data->surface;
if (dest_rect) {
if (dest_rect->w < 1 || dest_rect->h < 1)
return DFB_INVARG;
rect = *dest_rect;
rect.x += dst_data->area.wanted.x;
rect.y += dst_data->area.wanted.y;
}
else {
rect = dst_data->area.wanted;
}
dfb_region_from_rectangle( &clip, &dst_data->area.current );
if (!dfb_rectangle_region_intersects( &rect, &clip ))
return DFB_OK;
ret = dfb_surface_lock_buffer( dst_surface, CSBR_BACK, CSAID_CPU, CSAF_WRITE, &lock );
if (ret)
return ret;
if (!data->buf) {
int cmptlut[3];
int width, height;
int tlx, tly;
int hs, vs;
int i, j;
bool direct, mono;
if (jas_image_numcmpts(data->image) > 1) {
cmptlut[0] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
cmptlut[1] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
cmptlut[2] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
if (cmptlut[0] < 0 || cmptlut[1] < 0 || cmptlut[2] < 0) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return DFB_UNSUPPORTED;
}
mono = false;
}
else {
cmptlut[0] = cmptlut[1] = cmptlut[2] = 0;
mono = true;
}
width = jas_image_width(data->image);
height = jas_image_height(data->image);
tlx = jas_image_cmpttlx(data->image, 0);
tly = jas_image_cmpttly(data->image, 0);
hs = jas_image_cmpthstep(data->image, 0);
vs = jas_image_cmptvstep(data->image, 0);
data->buf = D_MALLOC( width*height*4 );
if (!data->buf) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return D_OOM();
}
direct = (rect.w == width && rect.h == height && data->render_callback);
#define GET_SAMPLE( n, x, y ) ({ \
int _s; \
_s = jas_image_readcmptsample(data->image, cmptlut[n], x, y); \
_s >>= jas_image_cmptprec(data->image, cmptlut[n]) - 8; \
if (_s > 255) \
_s = 255; \
else if (_s < 0) \
_s = 0; \
_s; \
})
for (i = 0; i < height; i++) {
u32 *dst = data->buf + i * width;
int x, y;
y = (i - tly) / vs;
if (y >= 0 && y < height) {
for (j = 0; j < width; j++) {
x = (j - tlx) / hs;
if (x >= 0 && x < width) {
unsigned int r, g, b;
if (mono) {
r = g = b = GET_SAMPLE(0, x, y);
}
else {
r = GET_SAMPLE(0, x, y);
g = GET_SAMPLE(1, x, y);
b = GET_SAMPLE(2, x, y);
}
*dst++ = 0xff000000 | (r << 16) | (g << 8) | b;
}
else {
*dst++ = 0;
}
}
}
else {
memset( dst, 0, width*4 );
}
if (direct) {
DFBRectangle r = { rect.x, rect.y+i, width, 1 };
dfb_copy_buffer_32( data->buf + i*width,
lock.addr, lock.pitch, &r, dst_surface, &clip );
if (data->render_callback) {
r = (DFBRectangle) { 0, i, width, 1 };
cb_result = data->render_callback( &r, data->render_callback_ctx );
if (cb_result != DIRCR_OK)
break;
}
}
}
if (!direct) {
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = { 0, 0, width, height };
data->render_callback( &r, data->render_callback_ctx );
}
}
if (cb_result != DIRCR_OK) {
D_FREE( data->buf );
data->buf = NULL;
ret = DFB_INTERRUPTED;
}
}
else {
int width = jas_image_width(data->image);
int height = jas_image_height(data->image);
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = {0, 0, width, height};
data->render_callback( &r, data->render_callback_ctx );
}
}
dfb_surface_unlock_buffer( dst_surface, &lock );
return ret;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *output,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle rect = {0,0,0,0};
jas_image_t *image;
gint width, height, depth;
gsize bpc;
guchar *data = NULL;
gboolean ret;
int components[3];
jas_matrix_t *matrices[3] = {NULL, NULL, NULL};
gint i;
gint row;
gboolean b;
gushort *ptr_s;
guchar *ptr_b;
image = NULL;
width = height = depth = 0;
if (!query_jp2 (o->path, &width, &height, &depth, &image))
return FALSE;
rect.height = height;
rect.width = width;
switch (depth)
{
case 8:
bpc = sizeof (guchar);
break;
case 16:
bpc = sizeof (gushort);
break;
default:
g_warning ("%s: Programmer stupidity error", G_STRLOC);
return FALSE;
}
data = (guchar *) g_malloc (width * height * 3 * bpc);
ptr_s = (gushort *) data;
ptr_b = data;
switch (depth)
{
case 16:
gegl_buffer_get (output, 1.0, &rect, babl_format ("R'G'B' u16"), data,
GEGL_AUTO_ROWSTRIDE);
break;
case 8:
default:
gegl_buffer_get (output, 1.0, &rect, babl_format ("R'G'B' u8"), data,
GEGL_AUTO_ROWSTRIDE);
}
ret = FALSE;
b = FALSE;
do
{
components[0] = jas_image_getcmptbytype
(image, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R));
components[1] = jas_image_getcmptbytype
(image, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G));
components[2] = jas_image_getcmptbytype
(image, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B));
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
g_warning (_("One or more of R, G, B components are missing "
"from '%s'"), o->path);
break;
}
if (jas_image_cmptsgnd (image, components[0]) ||
jas_image_cmptsgnd (image, components[1]) ||
jas_image_cmptsgnd (image, components[2]))
{
g_warning (_("One or more of R, G, B components have signed "
"data in '%s'"), o->path);
break;
}
for (i = 0; i < 3; i++)
matrices[i] = jas_matrix_create(1, width);
for (row = 0; row < height; row++)
{
gint plane, col;
jas_seqent_t *jrow[3] = {NULL, NULL, NULL};
for (plane = 0; plane < 3; plane++)
{
int r = jas_image_readcmpt (image, components[plane], 0, row,
width, 1, matrices[plane]);
if (r)
{
g_warning (_("Error reading row %d component %d from '%s'"),
row, plane, o->path);
b = TRUE;
break;
}
}
if (b)
break;
for (plane = 0; plane < 3; plane++)
jrow[plane] = jas_matrix_getref (matrices[plane], 0, 0);
for (col = 0; col < width; col++)
{
switch (depth)
{
case 16:
*ptr_s++ = (gushort) jrow[0][col];
*ptr_s++ = (gushort) jrow[1][col];
*ptr_s++ = (gushort) jrow[2][col];
break;
case 8:
default:
*ptr_b++ = (guchar) jrow[0][col];
*ptr_b++ = (guchar) jrow[1][col];
*ptr_b++ = (guchar) jrow[2][col];
}
}
}
if (b)
break;
switch (depth)
{
case 16:
gegl_buffer_set (output, &rect, babl_format ("R'G'B' u16"), data,
GEGL_AUTO_ROWSTRIDE);
break;
case 8:
default:
gegl_buffer_set (output, &rect, babl_format ("R'G'B' u8"), data,
GEGL_AUTO_ROWSTRIDE);
}
ret = TRUE;
}
while (FALSE); /* structured goto */
for (i = 0; i < 3; i++)
if (matrices[i])
jas_matrix_destroy (matrices[i]);
if (data)
g_free (data);
if (image)
jas_image_destroy (image);
return ret;
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e J P 2 I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method WriteJP2Image writes an image in the JPEG 2000 image format. % % JP2 support originally written by Nathan Brown, [email protected] % % The format of the WriteJP2Image method is: % % MagickPassFail WriteJP2Image(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o status: Method WriteJP2Image return MagickTrue if the image is written. % MagickFalse is returned is there is a memory shortage or if the image file % fails to write. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o image: A pointer to an Image structure. % % */ static MagickPassFail WriteJP2Image(const ImageInfo *image_info,Image *image) { char magick[MaxTextExtent], option_keyval[MaxTextExtent], *options = NULL; int format; long y; jas_image_cmptparm_t component_info; jas_image_t *jp2_image; jas_matrix_t *jp2_pixels; jas_stream_t *jp2_stream; register const PixelPacket *p; register int x; unsigned int rate_specified=False, status; int component, number_components; unsigned short *lut; ImageCharacteristics characteristics; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == False) ThrowWriterException(FileOpenError,UnableToOpenFile,image); /* Ensure that image is in RGB space. */ (void) TransformColorspace(image,RGBColorspace); /* Analyze image to be written. */ if (!GetImageCharacteristics(image,&characteristics, (OptimizeType == image_info->type), &image->exception)) { CloseBlob(image); return MagickFail; } /* Obtain a JP2 stream. */ jp2_stream=JP2StreamManager(image); if (jp2_stream == (jas_stream_t *) NULL) ThrowWriterException(DelegateError,UnableToManageJP2Stream,image); number_components=image->matte ? 4 : 3; if ((image_info->type != TrueColorType) && (characteristics.grayscale)) number_components=1; jp2_image=jas_image_create0(); if (jp2_image == (jas_image_t *) NULL) ThrowWriterException(DelegateError,UnableToCreateImage,image); for (component=0; component < number_components; component++) { (void) memset((void *)&component_info,0,sizeof(jas_image_cmptparm_t)); component_info.tlx=0; /* top left x ordinate */ component_info.tly=0; /* top left y ordinate */ component_info.hstep=1; /* horizontal pixels per step */ component_info.vstep=1; /* vertical pixels per step */ component_info.width=(unsigned int) image->columns; component_info.height=(unsigned int) image->rows; component_info.prec=(unsigned int) Max(2,Min(image->depth,16)); /* bits in range */ component_info.sgnd = false; /* range is signed value? */ if (jas_image_addcmpt(jp2_image, component,&component_info)) { jas_image_destroy(jp2_image); ThrowWriterException(DelegateError,UnableToCreateImageComponent,image); } } /* Allocate and compute LUT. */ { unsigned long i, max_value; double scale_to_component; lut=MagickAllocateArray(unsigned short *,MaxMap+1,sizeof(*lut)); if (lut == (unsigned short *) NULL) { jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); } max_value=MaxValueGivenBits(component_info.prec); scale_to_component=max_value/MaxRGBDouble; for(i=0; i <= MaxMap; i++) lut[i]=scale_to_component*i+0.5; } if (number_components == 1) { /* FIXME: If image has an attached ICC profile, then the profile should be transferred and the image colorspace set to JAS_CLRSPC_GENGRAY */ /* sRGB Grayscale */ (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting SGRAY colorspace"); jas_image_setclrspc(jp2_image, JAS_CLRSPC_SGRAY); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting GRAY channel to channel 0"); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y)); } else { /* FIXME: If image has an attached ICC profile, then the profile should be transferred and the image colorspace set to JAS_CLRSPC_GENRGB */ /* sRGB */ (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting SRGB colorspace"); jas_image_setclrspc(jp2_image, JAS_CLRSPC_SRGB); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting RED channel to channel 0"); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R)); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting GREEN channel to channel 1"); jas_image_setcmpttype(jp2_image,1, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G)); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting BLUE channel to channel 2"); jas_image_setcmpttype(jp2_image,2, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B)); if (number_components == 4 ) { (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting OPACITY channel to channel 3"); jas_image_setcmpttype(jp2_image,3, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY)); } } /* Convert to JPEG 2000 pixels. */ jp2_pixels=jas_matrix_create(1,(unsigned int) image->columns); if (jp2_pixels == (jas_matrix_t *) NULL) { MagickFreeMemory(lut); jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); } for (y=0; y < (long) image->rows; y++) { p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception); if (p == (const PixelPacket *) NULL) break; if (number_components == 1) { for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(PixelIntensityToQuantum(&p[x]))]); (void) jas_image_writecmpt(jp2_image,0,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); } else { for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].red)]); (void) jas_image_writecmpt(jp2_image,0,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].green)]); (void) jas_image_writecmpt(jp2_image,1,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].blue)]); (void) jas_image_writecmpt(jp2_image,2,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); if (number_components > 3) for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(MaxRGB-p[x].opacity)]); (void) jas_image_writecmpt(jp2_image,3,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); } if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,&image->exception, SaveImageText,image->filename, image->columns,image->rows)) break; } (void) strlcpy(magick,image_info->magick,MaxTextExtent); /* J2C is an alias for JPC but Jasper only supports "JPC". */ if (LocaleCompare(magick,"j2c") == 0) (void) strlcpy(magick,"jpc",sizeof(magick)); LocaleLower(magick); format=jas_image_strtofmt(magick); /* Support passing Jasper options. */ { const char **option_name; static const char *jasper_options[] = { "imgareatlx", "imgareatly", "tilegrdtlx", "tilegrdtly", "tilewidth", "tileheight", "prcwidth", "prcheight", "cblkwidth", "cblkheight", "mode", "ilyrrates", "prg", "nomct", "numrlvls", "sop", "eph", "lazy", "rate", "termall", "segsym", "vcausal", "pterm", "resetprob", "numgbits", NULL }; for (option_name = jasper_options; *option_name != NULL; option_name++) { const char *value; if ((value=AccessDefinition(image_info,"jp2",*option_name)) != NULL) { if(LocaleCompare(*option_name,"rate") == 0) rate_specified=True; FormatString(option_keyval,"%s=%.1024s ",*option_name,value); ConcatenateString(&options,option_keyval); } } } /* Provide an emulation of IJG JPEG "quality" by default. */ if (rate_specified == False) { double rate=1.0; /* A rough approximation to JPEG v1 quality using JPEG-2000. Default "quality" 75 results in a request for 16:1 compression, which results in image sizes approximating that of JPEG v1. */ if ((image_info->quality < 99.5) && (image->rows*image->columns > 2500)) { double header_size, current_size, target_size, d; d=115-image_info->quality; /* Best number is 110-115 */ rate=100.0/(d*d); header_size=550.0; /* Base file size. */ header_size+=(number_components-1)*142; /* Additional components */ /* FIXME: Need to account for any ICC profiles here */ current_size=(double)((image->rows*image->columns*image->depth)/8)* number_components; target_size=(current_size*rate)+header_size; rate=target_size/current_size; } FormatString(option_keyval,"%s=%g ","rate",rate); ConcatenateString(&options,option_keyval); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Compression rate: %g (%3.2f:1)",rate,1.0/rate); } if (options) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Jasper options: \"%s\"", options); (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Encoding image"); status=jas_image_encode(jp2_image,jp2_stream,format,options); (void) jas_stream_close(jp2_stream); MagickFreeMemory(options); MagickFreeMemory(lut); jas_matrix_destroy(jp2_pixels); jas_image_destroy(jp2_image); if (status) ThrowWriterException(DelegateError,UnableToEncodeImageFile,image); return(True); }
static Image *ReadJP2Image(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
long
y;
jas_image_t
*jp2_image;
jas_matrix_t
*pixels;
jas_stream_t
*jp2_stream;
register long
x;
register PixelPacket
*q;
int
component,
components[4],
number_components;
Quantum
*channel_lut[4];
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Obtain a JP2 Stream.
*/
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowReaderException(DelegateError,UnableToManageJP2Stream,image);
jp2_image=jas_image_decode(jp2_stream,-1,0);
if (jp2_image == (jas_image_t *) NULL)
{
(void) jas_stream_close(jp2_stream);
ThrowReaderException(DelegateError,UnableToDecodeImageFile,image);
}
/*
Validate that we can handle the image and obtain component
indexes.
*/
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
if (((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0) ||
((components[1]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0) ||
((components[2]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in RGB colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"RED is in channel %d, GREEN is in channel %d, BLUE is in channel %d",
components[0],components[1],components[2]);
if((components[3]=jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY))) > 0)
{
image->matte=MagickTrue;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"OPACITY is in channel %d",components[3]);
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
if ((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in GRAY colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"GRAY is in channel %d",components[0]);
number_components=1;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_OPACITY);
if (components[3] > 0)
{
image->matte=True;
number_components++;
}
image->colorspace=YCbCrColorspace;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in YCBCR colorspace family");
break;
}
default:
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,ColorspaceModelIsNotSupported,image);
}
}
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"columns=%lu rows=%lu components=%d",image->columns,image->rows,
number_components);
for (component=0; component < number_components; component++)
{
if(((unsigned long) jas_image_cmptwidth(jp2_image,components[component]) != image->columns) ||
((unsigned long) jas_image_cmptheight(jp2_image,components[component]) != image->rows) ||
(jas_image_cmpttlx(jp2_image, components[component]) != 0) ||
(jas_image_cmpttly(jp2_image, components[component]) != 0) ||
(jas_image_cmpthstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptvstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptsgnd(jp2_image, components[component]) != false))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,IrregularChannelGeometryNotSupported,image);
}
}
image->matte=number_components > 3;
for (component=0; component < number_components; component++)
{
unsigned int
component_depth;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Component[%d] depth is %u",component,component_depth);
if (0 == component)
image->depth=component_depth;
else
image->depth=Max(image->depth,component_depth);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image depth is %u",image->depth);
if (image_info->ping)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
/*
Allocate Jasper pixels.
*/
pixels=jas_matrix_create(1,(unsigned int) image->columns);
if (pixels == (jas_matrix_t *) NULL)
{
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
/*
Allocate and populate channel LUTs
*/
for (component=0; component < (long) number_components; component++)
{
unsigned long
component_depth,
i,
max_value;
double
scale_to_quantum;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
max_value=MaxValueGivenBits(component_depth);
scale_to_quantum=MaxRGBDouble/max_value;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Channel %d scale is %g", component, scale_to_quantum);
channel_lut[component]=MagickAllocateArray(Quantum *,max_value+1,sizeof(Quantum));
if (channel_lut[component] == (Quantum *) NULL)
{
for ( --component; component >= 0; --component)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
for(i=0; i <= max_value; i++)
(channel_lut[component])[i]=scale_to_quantum*i+0.5;
}
/*
Convert JPEG 2000 pixels.
*/
for (y=0; y < (long) image->rows; y++)
{
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
if (1 == number_components)
{
/* Grayscale */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
{
q->red=q->green=q->blue=(channel_lut[0])[jas_matrix_getv(pixels,x)];
q->opacity=OpaqueOpacity;
q++;
}
}
else
{
/* Red */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].red=(channel_lut[0])[jas_matrix_getv(pixels,x)];
/* Green */
(void) jas_image_readcmpt(jp2_image,(short) components[1],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].green=(channel_lut[1])[jas_matrix_getv(pixels,x)];
/* Blue */
(void) jas_image_readcmpt(jp2_image,(short) components[2],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].blue=(channel_lut[2])[jas_matrix_getv(pixels,x)];
/* Opacity */
if (number_components > 3)
{
(void) jas_image_readcmpt(jp2_image,(short) components[3],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].opacity=MaxRGB-(channel_lut[3])[jas_matrix_getv(pixels,x)];
}
else
{
for (x=0; x < (long) image->columns; x++)
q[x].opacity=OpaqueOpacity;
}
}
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
}
if (number_components == 1)
image->is_grayscale=MagickTrue;
{
/*
Obtain ICC ICM color profile
*/
jas_cmprof_t
*cm_profile;
/* Obtain a pointer to the existing jas_cmprof_t profile handle. */
cm_profile=jas_image_cmprof(jp2_image);
if (cm_profile != (jas_cmprof_t *) NULL)
{
jas_iccprof_t
*icc_profile;
/* Obtain a copy of the jas_iccprof_t ICC profile handle */
icc_profile=jas_iccprof_createfromcmprof(cm_profile);
/* or maybe just icc_profile=cm_profile->iccprof */
if (icc_profile != (jas_iccprof_t *) NULL)
{
jas_stream_t
*icc_stream;
icc_stream=jas_stream_memopen(NULL,0);
if ((icc_stream != (jas_stream_t *) NULL) &&
(jas_iccprof_save(icc_profile,icc_stream) == 0) &&
(jas_stream_flush(icc_stream) == 0))
{
jas_stream_memobj_t
*blob;
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"ICC profile: %lu bytes",(unsigned long) blob->len_);
SetImageProfile(image,"ICM",blob->buf_,blob->len_);
(void) jas_stream_close(icc_stream);
jas_iccprof_destroy(icc_profile);
}
}
}
}
for (component=0; component < (long) number_components; component++)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
int TO_jpeg2000(unsigned char *cin,int width,int height,int nbits,
int ltype, float ratio, int retry, char *outjpc,
int jpclen)
/*$$$ SUBPROGRAM DOCUMENTATION BLOCK
* . . . .
* SUBPROGRAM: TO_jpeg2000 Encodes JPEG2000 code stream
* PRGMMR: Gilbert ORG: W/NP11 DATE: 2002-12-02
*
* ABSTRACT: This Function encodes a grayscale image into a JPEG2000 code stream
* specified in the JPEG2000 Part-1 standard (i.e., ISO/IEC 15444-1)
* using JasPer Software version 1.700.2 or better written by the
* University of British Columbia, Image Power Inc, and others.
* JasPer is available at http://www.ece.uvic.ca/~mdadams/jasper/.
*
* PROGRAM HISTORY LOG:
* 2002-12-02 Gilbert
* 2004-12-16 Gilbert - Added retry argument/option to allow option of
* increasing the maximum number of guard bits to the
* JPEG2000 algorithm.
* 2015-10-26 M.Valin - removed GRIB library connections, light refactoring,
* changed function name
*
* USAGE: int TO_jpeg2000(unsigned char *cin,int width,int height,
* int nbits, int ltype, int ratio,
* int retry, char *outjpc, int jpclen)
*
* INPUT ARGUMENTS:
* cin - Packed matrix of Grayscale image values to encode.
* (byte stream, MSB first, LSB last for each multibyte item)
* width - width of image
* height - height of image
* nbits - depth (in bits) of image. i.e number of bits
* used to hold each data value
* ltype - indicator of lossless or lossy compression
* = 1, for lossy compression
* != 1, for lossless compression
* ratio - target compression ratio. (ratio:1)
* Used only when ltype == 1.
* retry - Pointer to option type.
* 1 = try increasing number of guard bits
* otherwise, no additional options
* jpclen - Number of bytes allocated for new JPEG2000 code stream in
* outjpc.
*
* INPUT ARGUMENTS:
* outjpc - Output encoded JPEG2000 code stream
*
* RETURN VALUES :
* > 0 = Length in bytes of encoded JPEG2000 code stream
* -3 = Error encoding jpeg2000 code stream.
*
* REMARKS:
*
* Requires JasPer Software version 1.700.2 or better
*
* ATTRIBUTES:
* LANGUAGE: C
* OS: Linux
*
*$$$*/
{
int ier,rwcnt;
jas_image_t image;
jas_stream_t *jpcstream,*istream;
jas_image_cmpt_t cmpt,*pcmpt;
#define MAXOPTSSIZE 1024
char opts[MAXOPTSSIZE];
/*
printf(" TO_jpeg2000:width %ld\n",width);
printf(" TO_jpeg2000:height %ld\n",height);
printf(" TO_jpeg2000:nbits %ld\n",nbits);
printf(" TO_jpeg2000:jpclen %ld\n",jpclen);
*/
// jas_init();
//
// Set lossy compression options, if requested.
//
if ( ltype != 1 ) {
opts[0]=(char)0;
}
else {
// snprintf(opts,MAXOPTSSIZE,"mode=real\nrate=%f",1.0/(float)ratio);
snprintf(opts,MAXOPTSSIZE,"mode=real\nrate=%f",1.0/ratio);
fprintf(stderr,"using lossy compression\n");
}
if ( retry == 1 ) { // option to increase number of guard bits
strcat(opts,"\nnumgbits=4");
}
//printf("SAGopts: %s\n",opts);
//
// Initialize the JasPer image structure describing the grayscale
// image to encode into the JPEG2000 code stream.
//
image.tlx_=0;
image.tly_=0;
image.brx_=(jas_image_coord_t)width;
image.bry_=(jas_image_coord_t)height;
image.numcmpts_=1;
image.maxcmpts_=1;
image.clrspc_=JAS_CLRSPC_SGRAY; /* grayscale Image */
image.cmprof_=0;
image.inmem_=1;
cmpt.tlx_=0;
cmpt.tly_=0;
cmpt.hstep_=1;
cmpt.vstep_=1;
cmpt.width_=(jas_image_coord_t)width;
cmpt.height_=(jas_image_coord_t)height;
cmpt.type_=JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
cmpt.prec_=nbits;
cmpt.sgnd_=0;
cmpt.cps_=(nbits+7)/8;
pcmpt=&cmpt;
image.cmpts_=&pcmpt;
#if defined(DEBUG)
printf(" SAGOUT ENCODE:\n");
printf(" tlx %d \n",image.tlx_);
printf(" tly %d \n",image.tly_);
printf(" brx %d \n",image.brx_);
printf(" bry %d \n",image.bry_);
printf(" numcmpts %d \n",image.numcmpts_);
printf(" maxcmpts %d \n",image.maxcmpts_);
printf(" colorspace %d \n",image.clrspc_);
printf(" inmem %d \n",image.inmem_);
printf(" COMPONENT:\n");
printf(" tlx %d \n",pcmpt->tlx_);
printf(" tly %d \n",pcmpt->tly_);
printf(" hstep %d \n",pcmpt->hstep_);
printf(" vstep %d \n",pcmpt->vstep_);
printf(" width %d \n",pcmpt->width_);
printf(" height %d \n",pcmpt->height_);
printf(" prec %d \n",pcmpt->prec_);
printf(" sgnd %d \n",pcmpt->sgnd_);
printf(" cps %d \n",pcmpt->cps_);
printf(" type %d \n",pcmpt->type_);
#endif
//
// Open a JasPer stream containing the input grayscale values
//
istream=jas_stream_memopen((char *)cin,height*width*cmpt.cps_);
cmpt.stream_=istream;
//
// Open an output stream that will contain the encoded jpeg2000
// code stream.
//
jpcstream=jas_stream_memopen(outjpc,(int)jpclen);
//
// Encode image.
//
ier=jpc_encode(&image,jpcstream,opts);
if ( ier != 0 ) {
printf(" jpc_encode return = %d \n",ier);
return -3;
}
//
// Clean up JasPer work structures.
//
rwcnt=jpcstream->rwcnt_;
ier=jas_stream_close(istream);
ier=jas_stream_close(jpcstream);
//
// Return size of jpeg2000 code stream
//
return (rwcnt);
}
int jpg_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
{
JDIMENSION numscanlines;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
jas_image_coord_t width;
jas_image_coord_t height;
jpg_src_t src_mgr_buf;
jpg_src_t *src_mgr = &src_mgr_buf;
FILE *output_file;
int cmptno;
jpg_enc_t encbuf;
jpg_enc_t *enc = &encbuf;
jpg_encopts_t encopts;
output_file = 0;
if (jpg_parseencopts(optstr, &encopts))
goto error;
switch (jas_clrspc_fam(jas_image_clrspc(image))) {
case JAS_CLRSPC_FAM_RGB:
if (jas_image_clrspc(image) != JAS_CLRSPC_SRGB)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 3;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
(enc->cmpts[1] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
(enc->cmpts[2] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
case JAS_CLRSPC_FAM_YCBCR:
if (jas_image_clrspc(image) != JAS_CLRSPC_SYCBCR)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 3;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y))) < 0 ||
(enc->cmpts[1] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB))) < 0 ||
(enc->cmpts[2] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
case JAS_CLRSPC_FAM_GRAY:
if (jas_image_clrspc(image) != JAS_CLRSPC_SGRAY)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 1;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
default:
jas_eprintf("error: JPG format does not support color space\n");
goto error;
break;
}
width = jas_image_width(image);
height = jas_image_height(image);
for (cmptno = 0; cmptno < enc->numcmpts; ++cmptno) {
if (jas_image_cmptwidth(image, enc->cmpts[cmptno]) != width ||
jas_image_cmptheight(image, enc->cmpts[cmptno]) != height ||
jas_image_cmpttlx(image, enc->cmpts[cmptno]) != 0 ||
jas_image_cmpttly(image, enc->cmpts[cmptno]) != 0 ||
jas_image_cmpthstep(image, enc->cmpts[cmptno]) != 1 ||
jas_image_cmptvstep(image, enc->cmpts[cmptno]) != 1 ||
jas_image_cmptprec(image, enc->cmpts[cmptno]) != 8 ||
jas_image_cmptsgnd(image, enc->cmpts[cmptno]) != jas_false) {
jas_eprintf("error: The JPG encoder cannot handle an image with this geometry.\n");
goto error;
}
}
if (!(output_file = tmpfile())) {
goto error;
}
/* Create a JPEG compression object. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);
cinfo.in_color_space = tojpgcs(jas_image_clrspc(image));
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = enc->numcmpts;
jpeg_set_defaults(&cinfo);
src_mgr->error = 0;
src_mgr->image = image;
src_mgr->data = jas_matrix_create(1, width);
src_mgr->buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo,
JPOOL_IMAGE, (JDIMENSION) width * cinfo.input_components,
(JDIMENSION) 1);
src_mgr->buffer_height = 1;
src_mgr->enc = enc;
/* Read the input file header to obtain file size & colorspace. */
jpg_start_input(&cinfo, src_mgr);
if (encopts.qual >= 0) {
jpeg_set_quality(&cinfo, encopts.qual, jas_true);
}
/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);
/* Start compressor */
jpeg_start_compress(&cinfo, jas_true );
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
if ((numscanlines = jpg_get_pixel_rows(&cinfo, src_mgr)) <= 0) {
break;
}
jpeg_write_scanlines(&cinfo, src_mgr->buffer, numscanlines);
}
/* Finish compression and release memory */
jpg_finish_input(&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
rewind(output_file);
jpg_copyfiletostream(out, output_file);
fclose(output_file);
output_file = 0;
return 0;
error:
if (output_file) {
fclose(output_file);
}
return -1;
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e J P 2 I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % WriteJP2Image() writes an image in the JPEG 2000 image format. % % JP2 support originally written by Nathan Brown, [email protected] % % The format of the WriteJP2Image method is: % % MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o image_info: the image info. % % o image: The image. % */ static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image) { char *key, magick[MaxTextExtent], *options; const char *option; long format, y; jas_image_cmptparm_t component_info[4]; jas_image_t *jp2_image; jas_matrix_t *pixels[4]; jas_stream_t *jp2_stream; MagickBooleanType status; QuantumAny range; register const PixelPacket *p; register long i, x; unsigned short *map; unsigned long number_components; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == MagickFalse) return(status); /* Intialize JPEG 2000 API. */ if (image->colorspace != RGBColorspace) (void) TransformImageColorspace(image,RGBColorspace); jp2_stream=JP2StreamManager(image); if (jp2_stream == (jas_stream_t *) NULL) ThrowWriterException(DelegateError,"UnableToManageJP2Stream"); number_components=image->matte ? 4UL : 3UL; if ((image_info->type != TrueColorType) && IsGrayImage(image,&image->exception)) number_components=1; if ((image->columns != (unsigned int) image->columns) || (image->rows != (unsigned int) image->rows)) ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit"); (void) ResetMagickMemory(&component_info,0,sizeof(component_info)); for (i=0; i < (long) number_components; i++) { component_info[i].tlx=0; component_info[i].tly=0; component_info[i].hstep=1; component_info[i].vstep=1; component_info[i].width=(unsigned int) image->columns; component_info[i].height=(unsigned int) image->rows; component_info[i].prec=(int) MagickMax(MagickMin(image->depth,16),2); component_info[i].sgnd=MagickFalse; } jp2_image=jas_image_create((int) number_components,component_info, JAS_CLRSPC_UNKNOWN); if (jp2_image == (jas_image_t *) NULL) ThrowWriterException(DelegateError,"UnableToCreateImage"); if (number_components == 1) { /* sRGB Grayscale. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_SGRAY); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y)); } else { /* sRGB. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_SRGB); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R)); jas_image_setcmpttype(jp2_image,1, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G)); jas_image_setcmpttype(jp2_image,2, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); } /* Convert to JPEG 2000 pixels. */ for (i=0; i < (long) number_components; i++) { pixels[i]=jas_matrix_create(1,(int) image->columns); if (pixels[i] == (jas_matrix_t *) NULL) { for (x=0; x < i; x++) jas_matrix_destroy(pixels[x]); jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); } } range=GetQuantumRange((unsigned long) component_info[0].prec); map=(unsigned short *) AcquireQuantumMemory(MaxMap+1,sizeof(*map)); for (i=0; i <= (long) MaxMap; i++) map[i]=(unsigned short) ScaleQuantumToMap((Quantum) ScaleQuantumToAny((Quantum) i,range)); if (map == (unsigned short *) NULL) { for (i=0; i < (long) number_components; i++) jas_matrix_destroy(pixels[i]); jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); } for (y=0; y < (long) image->rows; y++) { p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { if (number_components == 1) jas_matrix_setv(pixels[0],x,map[ScaleQuantumToMap( PixelIntensityToQuantum(p))]); else { jas_matrix_setv(pixels[0],x,map[ScaleQuantumToMap(p->red)]); jas_matrix_setv(pixels[1],x,map[ScaleQuantumToMap(p->green)]); jas_matrix_setv(pixels[2],x,map[ScaleQuantumToMap(p->blue)]); if (number_components > 3) jas_matrix_setv(pixels[3],x,map[ScaleQuantumToMap((Quantum) (QuantumRange-p->opacity))]); } p++; } for (i=0; i < (long) number_components; i++) (void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y, (unsigned int) image->columns,1,pixels[i]); status=SetImageProgress(image,SaveImageTag,y,image->rows); if (status == MagickFalse) break; } map=(unsigned short *) RelinquishMagickMemory(map); (void) CopyMagickString(magick,image_info->magick,MaxTextExtent); LocaleLower(magick); format=jas_image_strtofmt(magick); options=(char *) NULL; ResetImageOptionIterator(image_info); key=GetNextImageOption(image_info); while (key != (char *) NULL) { option=GetImageOption(image_info,key); if (option != (const char *) NULL) { if (LocaleNCompare(key,"jp2:",4) == 0) { (void) ConcatenateString(&options,key+4); if (*option != '\0') { (void) ConcatenateString(&options,"="); (void) ConcatenateString(&options,option); } (void) ConcatenateString(&options," "); } } key=GetNextImageOption(image_info); } option=GetImageOption(image_info,"jp2:rate"); if ((option == (const char *) NULL) && (image_info->compression != LosslessJPEGCompression) && (image->quality != UndefinedCompressionQuality) && ((double) image->quality <= 99.5) && ((image->rows*image->columns) > 2500)) { char option[MaxTextExtent]; double alpha, header_size, number_pixels, rate, target_size; alpha=115.0-image->quality; rate=100.0/(alpha*alpha); header_size=550.0; header_size+=(number_components-1)*142; number_pixels=(double) image->rows*image->columns*number_components* (GetImageQuantumDepth(image,MagickTrue)/8); target_size=(number_pixels*rate)+header_size; rate=target_size/number_pixels; (void) FormatMagickString(option,MaxTextExtent,"rate=%g",rate); (void) ConcatenateString(&options,option); } status=jas_image_encode(jp2_image,jp2_stream,format,options) != 0 ? MagickTrue : MagickFalse; (void) jas_stream_close(jp2_stream); for (i=0; i < (long) number_components; i++) jas_matrix_destroy(pixels[i]); jas_image_destroy(jp2_image); if (status != MagickFalse) ThrowWriterException(DelegateError,"UnableToEncodeImageFile"); return(MagickTrue); }
bool JP2KLoader::save(const QString& filePath, DImgLoaderObserver* observer)
{
FILE* file = fopen(QFile::encodeName(filePath), "wb");
if (!file)
{
return false;
}
fclose(file);
// -------------------------------------------------------------------
// Initialize JPEG 2000 API.
register long i, x, y;
unsigned long number_components;
jas_image_t* jp2_image = 0;
jas_stream_t* jp2_stream = 0;
jas_matrix_t* pixels[4];
jas_image_cmptparm_t component_info[4];
int init = jas_init();
if (init != 0)
{
kDebug() << "Unable to init JPEG2000 decoder";
return false;
}
jp2_stream = jas_stream_fopen(QFile::encodeName(filePath), "wb");
if (jp2_stream == 0)
{
kDebug() << "Unable to open JPEG2000 stream";
return false;
}
number_components = imageHasAlpha() ? 4 : 3;
for (i = 0 ; i < (long)number_components ; ++i)
{
component_info[i].tlx = 0;
component_info[i].tly = 0;
component_info[i].hstep = 1;
component_info[i].vstep = 1;
component_info[i].width = imageWidth();
component_info[i].height = imageHeight();
component_info[i].prec = imageBitsDepth();
component_info[i].sgnd = false;
}
jp2_image = jas_image_create(number_components, component_info, JAS_CLRSPC_UNKNOWN);
if (jp2_image == 0)
{
jas_stream_close(jp2_stream);
kDebug() << "Unable to create JPEG2000 image";
return false;
}
if (observer)
{
observer->progressInfo(m_image, 0.1F);
}
// -------------------------------------------------------------------
// Check color space.
if (number_components >= 3 ) // RGB & RGBA
{
// Alpha Channel
if (number_components == 4 )
{
jas_image_setcmpttype(jp2_image, 3, JAS_IMAGE_CT_OPACITY);
}
jas_image_setclrspc(jp2_image, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(jp2_image, 0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
jas_image_setcmpttype(jp2_image, 1, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
jas_image_setcmpttype(jp2_image, 2, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
}
// -------------------------------------------------------------------
// Set ICC color profile.
// FIXME : doesn't work yet!
jas_cmprof_t* cm_profile = 0;
jas_iccprof_t* icc_profile = 0;
QByteArray profile_rawdata = m_image->getIccProfile().data();
icc_profile = jas_iccprof_createfrombuf((uchar*)profile_rawdata.data(), profile_rawdata.size());
if (icc_profile != 0)
{
cm_profile = jas_cmprof_createfromiccprof(icc_profile);
if (cm_profile != 0)
{
jas_image_setcmprof(jp2_image, cm_profile);
}
}
// -------------------------------------------------------------------
// Convert to JPEG 2000 pixels.
for (i = 0 ; i < (long)number_components ; ++i)
{
pixels[i] = jas_matrix_create(1, (unsigned int)imageWidth());
if (pixels[i] == 0)
{
for (x = 0 ; x < i ; ++x)
{
jas_matrix_destroy(pixels[x]);
}
jas_image_destroy(jp2_image);
kDebug() << "Error encoding JPEG2000 image data : Memory Allocation Failed";
return false;
}
}
unsigned char* data = imageData();
unsigned char* pixel;
unsigned short r, g, b, a=0;
uint checkpoint = 0;
for (y = 0 ; y < (long)imageHeight() ; ++y)
{
if (observer && y == (long)checkpoint)
{
checkpoint += granularity(observer, imageHeight(), 0.8F);
if (!observer->continueQuery(m_image))
{
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
return false;
}
observer->progressInfo(m_image, 0.1 + (0.8 * ( ((float)y)/((float)imageHeight()) )));
}
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
pixel = &data[((y * imageWidth()) + x) * imageBytesDepth()];
if ( imageSixteenBit() ) // 16 bits image.
{
b = (unsigned short)(pixel[0]+256*pixel[1]);
g = (unsigned short)(pixel[2]+256*pixel[3]);
r = (unsigned short)(pixel[4]+256*pixel[5]);
if (imageHasAlpha())
{
a = (unsigned short)(pixel[6]+256*pixel[7]);
}
}
else // 8 bits image.
{
b = (unsigned short)pixel[0];
g = (unsigned short)pixel[1];
r = (unsigned short)pixel[2];
if (imageHasAlpha())
{
a = (unsigned short)(pixel[3]);
}
}
jas_matrix_setv(pixels[0], x, r);
jas_matrix_setv(pixels[1], x, g);
jas_matrix_setv(pixels[2], x, b);
if (number_components > 3)
{
jas_matrix_setv(pixels[3], x, a);
}
}
for (i = 0 ; i < (long)number_components ; ++i)
{
int ret = jas_image_writecmpt(jp2_image, (short) i, 0, (unsigned int)y,
(unsigned int)imageWidth(), 1, pixels[i]);
if (ret != 0)
{
kDebug() << "Error encoding JPEG2000 image data";
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
return false;
}
}
}
QVariant qualityAttr = imageGetAttribute("quality");
int quality = qualityAttr.isValid() ? qualityAttr.toInt() : 90;
if (quality < 0)
{
quality = 90;
}
if (quality > 100)
{
quality = 100;
}
QString rate;
QTextStream ts( &rate, QIODevice::WriteOnly );
// NOTE: to have a lossless compression use quality=100.
// jp2_encode()::optstr:
// - rate=#B => the resulting file size is about # bytes
// - rate=0.0 .. 1.0 => the resulting file size is about the factor times
// the uncompressed size
ts << "rate=" << ( quality / 100.0F );
kDebug() << "JPEG2000 quality: " << quality;
kDebug() << "JPEG2000 " << rate;
int ret = jp2_encode(jp2_image, jp2_stream, rate.toUtf8().data());
if (ret != 0)
{
kDebug() << "Unable to encode JPEG2000 image";
jas_image_destroy(jp2_image);
jas_stream_close(jp2_stream);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
return false;
}
if (observer)
{
observer->progressInfo(m_image, 1.0);
}
imageSetAttribute("savedformat", "JP2K");
saveMetadata(filePath);
jas_image_destroy(jp2_image);
jas_stream_close(jp2_stream);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
return true;
}
int jp2_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
jp2_cdef_t *cdef;
int i;
uint_fast32_t typeasoc;
box = 0;
tmpstream = 0;
/* Output the signature box. */
if (!(box = jp2_box_create(JP2_BOX_JP))) {
goto error;
}
box->data.jp.magic = JP2_JP_MAGIC;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Output the file type box. */
if (!(box = jp2_box_create(JP2_BOX_FTYP))) {
goto error;
}
ftyp = &box->data.ftyp;
ftyp->majver = JP2_FTYP_MAJVER;
ftyp->minver = JP2_FTYP_MINVER;
ftyp->numcompatcodes = 1;
ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/*
* Generate the data portion of the JP2 header box.
* We cannot simply output the header for this box
* since we do not yet know the correct value for the length
* field.
*/
if (!(tmpstream = jas_stream_memopen(0, 0))) {
goto error;
}
/* Generate image header box. */
if (!(box = jp2_box_create(JP2_BOX_IHDR))) {
goto error;
}
ihdr = &box->data.ihdr;
ihdr->width = jas_image_width(image);
ihdr->height = jas_image_height(image);
ihdr->numcmpts = jas_image_numcmpts(image);
allcmptssame = 0;
ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0),
jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL;
ihdr->comptype = JP2_IHDR_COMPTYPE;
ihdr->csunk = 0;
ihdr->ipr = 0;
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Generate bits per component box. */
if (!allcmptssame) {
if (!(box = jp2_box_create(JP2_BOX_BPCC))) {
goto error;
}
bpcc = &box->data.bpcc;
bpcc->numcmpts = jas_image_numcmpts(image);
if (!(bpcc->bpcs = jas_malloc(bpcc->numcmpts *
sizeof(uint_fast8_t)))) {
goto error;
}
for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) {
bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image,
cmptno), jas_image_cmptprec(image, cmptno));
}
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
}
/* Generate color specification box. */
if (!(box = jp2_box_create(JP2_BOX_COLR))) {
goto error;
}
colr = &box->data.colr;
colr->method = JP2_COLR_ENUM;
colr->pri = JP2_COLR_PRI;
colr->approx = 0;
colr->csid = (jas_image_colorspace(image) == JAS_IMAGE_CS_RGB) ? JP2_COLR_SRGB :
JP2_COLR_SGRAY;
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
if (!(jas_image_colorspace(image) == JAS_IMAGE_CS_RGB &&
jas_image_numcmpts(image) == 3 &&
jas_image_getcmptbytype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R) &&
jas_image_getcmptbytype(image, 1) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G) &&
jas_image_getcmptbytype(image, 2) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B)) &&
!(jas_image_colorspace(image) == JAS_IMAGE_CS_YCBCR &&
jas_image_numcmpts(image) != 3 &&
jas_image_getcmptbytype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_Y) &&
jas_image_getcmptbytype(image, 1) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CB) &&
jas_image_getcmptbytype(image, 2) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CR)) &&
!(jas_image_colorspace(image) == JAS_IMAGE_CS_GRAY &&
jas_image_numcmpts(image) == 1 &&
jas_image_getcmptbytype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))) {
if (!(box = jp2_box_create(JP2_BOX_CDEF))) {
goto error;
}
cdef = &box->data.cdef;
cdef->numchans = jas_image_numcmpts(image);
cdef->ents = jas_malloc(cdef->numchans * sizeof(jp2_cdefchan_t));
for (i = 0; i < jas_image_numcmpts(image); ++i) {
cdefchanent = &cdef->ents[i];
cdefchanent->channo = i;
typeasoc = jp2_gettypeasoc(jas_image_colorspace(image), jas_image_cmpttype(image, i));
cdefchanent->type = typeasoc >> 16;
cdefchanent->assoc = typeasoc & 0x7fff;
}
jp2_box_destroy(box);
box = 0;
}
/* Determine the total length of the JP2 header box. */
len = jas_stream_tell(tmpstream);
jas_stream_rewind(tmpstream);
/*
* Output the JP2 header box and all of the boxes which it contains.
*/
if (!(box = jp2_box_create(JP2_BOX_JP2H))) {
goto error;
}
box->len = len + JP2_BOX_HDRLEN;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
if (jas_stream_copy(out, tmpstream, len)) {
goto error;
}
jas_stream_close(tmpstream);
tmpstream = 0;
/*
* Output the contiguous code stream box.
*/
if (!(box = jp2_box_create(JP2_BOX_JP2C))) {
goto error;
}
box->len = 0;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Output the JPEG-2000 code stream. */
overhead = jas_stream_getrwcount(out);
sprintf(buf, "%s\n_jp2overhead=%lu\n", (optstr ? optstr : ""),
(unsigned long) overhead);
if (jpc_encode(image, out, buf)) {
goto error;
}
return 0;
abort();
error:
if (box) {
jp2_box_destroy(box);
}
if (tmpstream) {
jas_stream_close(tmpstream);
}
return -1;
}
static int jas_image_render(jas_image_t *image, float vtlx, float vtly,
float vsx, float vsy, int vw, int vh, GLshort *vdata)
{
int i;
int j;
int k;
int x;
int y;
int v[3];
GLshort *vdatap;
int cmptlut[3];
int width;
int height;
int hs;
int vs;
int tlx;
int tly;
if ((cmptlut[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
(cmptlut[1] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
(cmptlut[2] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0)
goto error;
width = jas_image_cmptwidth(image, cmptlut[0]);
height = jas_image_cmptheight(image, cmptlut[0]);
tlx = jas_image_cmpttlx(image, cmptlut[0]);
tly = jas_image_cmpttly(image, cmptlut[0]);
vs = jas_image_cmptvstep(image, cmptlut[0]);
hs = jas_image_cmpthstep(image, cmptlut[0]);
for (i = 1; i < 3; ++i) {
if (jas_image_cmptwidth(image, cmptlut[i]) != width ||
jas_image_cmptheight(image, cmptlut[i]) != height)
goto error;
}
for (i = 0; i < vh; ++i) {
vdatap = &vdata[(vh - 1 - i) * (4 * vw)];
for (j = 0; j < vw; ++j) {
x = vctocc(j, tlx, hs, vtlx, vsx);
y = vctocc(i, tly, vs, vtly, vsy);
if (x >= 0 && x < width && y >= 0 && y < height) {
for (k = 0; k < 3; ++k) {
v[k] = jas_image_readcmptsample(image, cmptlut[k], x, y);
v[k] <<= 16 - jas_image_cmptprec(image, cmptlut[k]);
if (v[k] < 0) {
v[k] = 0;
} else if (v[k] > 65535) {
v[k] = 65535;
}
}
} else {
v[0] = 0;
v[1] = 0;
v[2] = 0;
}
*vdatap++ = v[0];
*vdatap++ = v[1];
*vdatap++ = v[2];
*vdatap++ = 0;
}
}
return 0;
error:
return -1;
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e J P 2 I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % WriteJP2Image() writes an image in the JPEG 2000 image format. % % JP2 support originally written by Nathan Brown, [email protected] % % The format of the WriteJP2Image method is: % % MagickBooleanType WriteJP2Image(const ImageInfo *image_info, % Image *image,ExceptionInfo *exception) % % A description of each parameter follows. % % o image_info: the image info. % % o image: The image. % % o exception: return any errors or warnings in this structure. % */ static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image, ExceptionInfo *exception) { char *key, magick[MaxTextExtent], *options; const char *option; jas_image_cmptparm_t component_info[4]; jas_image_t *jp2_image; jas_matrix_t *pixels[4]; jas_stream_t *jp2_stream; MagickBooleanType status; QuantumAny range; register const Quantum *p; register ssize_t i, x; size_t number_components; ssize_t format, y; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception); if (status == MagickFalse) return(status); /* Initialize JPEG 2000 API. */ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse) (void) TransformImageColorspace(image,sRGBColorspace,exception); jp2_stream=JP2StreamManager(image); if (jp2_stream == (jas_stream_t *) NULL) ThrowWriterException(DelegateError,"UnableToManageJP2Stream"); number_components=image->alpha_trait ? 4UL : 3UL; if (IsGrayColorspace(image->colorspace) != MagickFalse) number_components=1; if ((image->columns != (unsigned int) image->columns) || (image->rows != (unsigned int) image->rows)) ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit"); (void) ResetMagickMemory(&component_info,0,sizeof(component_info)); for (i=0; i < (ssize_t) number_components; i++) { component_info[i].tlx=0; component_info[i].tly=0; component_info[i].hstep=1; component_info[i].vstep=1; component_info[i].width=(unsigned int) image->columns; component_info[i].height=(unsigned int) image->rows; component_info[i].prec=(int) MagickMax(MagickMin(image->depth,16),2); component_info[i].sgnd=MagickFalse; } jp2_image=jas_image_create((int) number_components,component_info, JAS_CLRSPC_UNKNOWN); if (jp2_image == (jas_image_t *) NULL) ThrowWriterException(DelegateError,"UnableToCreateImage"); switch (image->colorspace) { case RGBColorspace: case sRGBColorspace: { /* RGB colorspace. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_SRGB); jas_image_setcmpttype(jp2_image,0, (jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R)); jas_image_setcmpttype(jp2_image,1, (jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G)); jas_image_setcmpttype(jp2_image,2, (jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); break; } case GRAYColorspace: { /* Grayscale colorspace. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_SGRAY); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y)); break; } case YCbCrColorspace: { /* YCbCr colorspace. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_SYCBCR); jas_image_setcmpttype(jp2_image,0,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(0)); jas_image_setcmpttype(jp2_image,1,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(1)); jas_image_setcmpttype(jp2_image,2,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(2)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); break; } case XYZColorspace: { /* XYZ colorspace. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_CIEXYZ); jas_image_setcmpttype(jp2_image,0,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(0)); jas_image_setcmpttype(jp2_image,1,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(1)); jas_image_setcmpttype(jp2_image,2,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(2)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); break; } case LabColorspace: { /* Lab colorspace. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_CIELAB); jas_image_setcmpttype(jp2_image,0,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(0)); jas_image_setcmpttype(jp2_image,1,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(1)); jas_image_setcmpttype(jp2_image,2,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(2)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); break; } default: { /* Unknow. */ jas_image_setclrspc(jp2_image,JAS_CLRSPC_UNKNOWN); jas_image_setcmpttype(jp2_image,0,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(0)); jas_image_setcmpttype(jp2_image,1,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(1)); jas_image_setcmpttype(jp2_image,2,(jas_image_cmpttype_t) JAS_IMAGE_CT_COLOR(2)); if (number_components == 4) jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY); break; } } /* Convert to JPEG 2000 pixels. */ for (i=0; i < (ssize_t) number_components; i++) { pixels[i]=jas_matrix_create(1,(int) image->columns); if (pixels[i] == (jas_matrix_t *) NULL) { for (x=0; x < i; x++) jas_matrix_destroy(pixels[x]); jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); } } range=GetQuantumRange((size_t) component_info[0].prec); for (y=0; y < (ssize_t) image->rows; y++) { p=GetVirtualPixels(image,0,y,image->columns,1,exception); if (p == (const Quantum *) NULL) break; for (x=0; x < (ssize_t) image->columns; x++) { if (number_components == 1) jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny( GetPixelIntensity(image,p),range)); else { jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny( GetPixelRed(image,p),range)); jas_matrix_setv(pixels[1],x,(jas_seqent_t) ScaleQuantumToAny( GetPixelGreen(image,p),range)); jas_matrix_setv(pixels[2],x,(jas_seqent_t) ScaleQuantumToAny( GetPixelBlue(image,p),range)); if (number_components > 3) jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny( GetPixelAlpha(image,p),range)); } p+=GetPixelChannels(image); } for (i=0; i < (ssize_t) number_components; i++) (void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y, (unsigned int) image->columns,1,pixels[i]); status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y, image->rows); if (status == MagickFalse) break; } (void) CopyMagickString(magick,image_info->magick,MaxTextExtent); if (LocaleCompare(magick,"J2C") == 0) (void) CopyMagickString(magick,"JPC",MaxTextExtent); LocaleLower(magick); format=jas_image_strtofmt(magick); options=(char *) NULL; ResetImageOptionIterator(image_info); key=GetNextImageOption(image_info); for ( ; key != (char *) NULL; key=GetNextImageOption(image_info)) { option=GetImageOption(image_info,key); if (option == (const char *) NULL) continue; if (LocaleNCompare(key,"jp2:",4) == 0) { (void) ConcatenateString(&options,key+4); if (*option != '\0') { (void) ConcatenateString(&options,"="); (void) ConcatenateString(&options,option); } (void) ConcatenateString(&options," "); } } option=GetImageOption(image_info,"jp2:rate"); if ((option == (const char *) NULL) && (image_info->compression != LosslessJPEGCompression) && (image->quality != UndefinedCompressionQuality) && ((double) image->quality <= 99.5) && ((image->rows*image->columns) > 2500)) { char option[MaxTextExtent]; double alpha, header_size, number_pixels, rate, target_size; alpha=115.0-image->quality; rate=100.0/(alpha*alpha); header_size=550.0; header_size+=(number_components-1)*142; number_pixels=(double) image->rows*image->columns*number_components* (GetImageQuantumDepth(image,MagickTrue)/8); target_size=(number_pixels*rate)+header_size; rate=target_size/number_pixels; (void) FormatLocaleString(option,MaxTextExtent,"rate=%g",rate); (void) ConcatenateString(&options,option); } status=jas_image_encode(jp2_image,jp2_stream,format,options) != 0 ? MagickTrue : MagickFalse; if (options != (char *) NULL) options=DestroyString(options); (void) jas_stream_close(jp2_stream); for (i=0; i < (ssize_t) number_components; i++) jas_matrix_destroy(pixels[i]); jas_image_destroy(jp2_image); if (status != MagickFalse) ThrowWriterException(DelegateError,"UnableToEncodeImageFile"); return(MagickTrue); }
int enc_jpeg2000(unsigned char *cin,g2int width,g2int height,g2int nbits,
g2int ltype, g2int ratio, g2int retry, char *outjpc,
g2int jpclen)
/*$$$ SUBPROGRAM DOCUMENTATION BLOCK
* . . . .
* SUBPROGRAM: enc_jpeg2000 Encodes JPEG2000 code stream
* PRGMMR: Gilbert ORG: W/NP11 DATE: 2002-12-02
*
* ABSTRACT: This Function encodes a grayscale image into a JPEG2000 code stream
* specified in the JPEG2000 Part-1 standard (i.e., ISO/IEC 15444-1)
* using JasPer Software version 1.500.4 (or 1.700.2 ) written by the
* University of British Columbia, Image Power Inc, and others.
* JasPer is available at http://www.ece.uvic.ca/~mdadams/jasper/.
*
* PROGRAM HISTORY LOG:
* 2002-12-02 Gilbert
* 2004-12-16 Gilbert - Added retry argument/option to allow option of
* increasing the maximum number of guard bits to the
* JPEG2000 algorithm.
*
* USAGE: int enc_jpeg2000(unsigned char *cin,g2int width,g2int height,
* g2int nbits, g2int ltype, g2int ratio,
* g2int retry, char *outjpc, g2int jpclen)
*
* INPUT ARGUMENTS:
* cin - Packed matrix of Grayscale image values to encode.
* width - width of image
* height - height of image
* nbits - depth (in bits) of image. i.e number of bits
* used to hold each data value
* ltype - indicator of lossless or lossy compression
* = 1, for lossy compression
* != 1, for lossless compression
* ratio - target compression ratio. (ratio:1)
* Used only when ltype == 1.
* retry - Pointer to option type.
* 1 = try increasing number of guard bits
* otherwise, no additional options
* jpclen - Number of bytes allocated for new JPEG2000 code stream in
* outjpc.
*
* INPUT ARGUMENTS:
* outjpc - Output encoded JPEG2000 code stream
*
* RETURN VALUES :
* > 0 = Length in bytes of encoded JPEG2000 code stream
* -3 = Error decode jpeg2000 code stream.
* -5 = decoded image had multiple color components.
* Only grayscale is expected.
*
* REMARKS:
*
* Requires JasPer Software version 1.500.4 or 1.700.2
*
* ATTRIBUTES:
* LANGUAGE: C
* MACHINE: IBM SP
*
*$$$*/
{
int ier,rwcnt;
jas_image_t image;
jas_stream_t *jpcstream,*istream;
jas_image_cmpt_t cmpt,*pcmpt;
#define MAXOPTSSIZE 1024
char opts[MAXOPTSSIZE];
/*
printf(" enc_jpeg2000:width %ld\n",width);
printf(" enc_jpeg2000:height %ld\n",height);
printf(" enc_jpeg2000:nbits %ld\n",nbits);
printf(" enc_jpeg2000:jpclen %ld\n",jpclen);
*/
// jas_init();
//
// Set lossy compression options, if requested.
//
if ( ltype != 1 ) {
opts[0]=(char)0;
}
else {
#ifdef _SAGA_MSW
sprintf(opts,"mode=real\nrate=%f",1.0/(float)ratio);
#else
snprintf(opts,MAXOPTSSIZE,"mode=real\nrate=%f",1.0/(float)ratio);
#endif // _SAGA_MSW
}
if ( retry == 1 ) { // option to increase number of guard bits
strcat(opts,"\nnumgbits=4");
}
//printf("SAGopts: %s\n",opts);
//
// Initialize the JasPer image structure describing the grayscale
// image to encode into the JPEG2000 code stream.
//
image.tlx_=0;
image.tly_=0;
#ifdef JAS_1_500_4
image.brx_=(uint_fast32_t)width;
image.bry_=(uint_fast32_t)height;
#endif
#ifdef JAS_1_700_2
image.brx_=(jas_image_coord_t)width;
image.bry_=(jas_image_coord_t)height;
#endif
image.numcmpts_=1;
image.maxcmpts_=1;
#ifdef JAS_1_500_4
image.colormodel_=JAS_IMAGE_CM_GRAY; /* grayscale Image */
#endif
#ifdef JAS_1_700_2
image.clrspc_=JAS_CLRSPC_SGRAY; /* grayscale Image */
image.cmprof_=0;
#endif
image.inmem_=1;
cmpt.tlx_=0;
cmpt.tly_=0;
cmpt.hstep_=1;
cmpt.vstep_=1;
#ifdef JAS_1_500_4
cmpt.width_=(uint_fast32_t)width;
cmpt.height_=(uint_fast32_t)height;
#endif
#ifdef JAS_1_700_2
cmpt.width_=(jas_image_coord_t)width;
cmpt.height_=(jas_image_coord_t)height;
cmpt.type_=JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
#endif
cmpt.prec_=nbits;
cmpt.sgnd_=0;
cmpt.cps_=(nbits+7)/8;
pcmpt=&cmpt;
image.cmpts_=&pcmpt;
//
// Open a JasPer stream containing the input grayscale values
//
istream=jas_stream_memopen((char *)cin,height*width*cmpt.cps_);
cmpt.stream_=istream;
//
// Open an output stream that will contain the encoded jpeg2000
// code stream.
//
jpcstream=jas_stream_memopen(outjpc,(int)jpclen);
//
// Encode image.
//
ier=jpc_encode(&image,jpcstream,opts);
if ( ier != 0 ) {
printf(" jpc_encode return = %d \n",ier);
return -3;
}
//
// Clean up JasPer work structures.
//
rwcnt=jpcstream->rwcnt_;
ier=jas_stream_close(istream);
ier=jas_stream_close(jpcstream);
//
// Return size of jpeg2000 code stream
//
return (rwcnt);
}
jas_image_t *pnm_decode(jas_stream_t *in, const char *optstr)
{
pnm_hdr_t hdr;
jas_image_t *image;
jas_image_cmptparm_t cmptparms[3];
jas_image_cmptparm_t *cmptparm;
int i;
pnm_dec_importopts_t opts;
size_t num_samples;
image = 0;
JAS_DBGLOG(10, ("pnm_decode(%p, \"%s\")\n", in, optstr ? optstr : ""));
if (pnm_dec_parseopts(optstr, &opts)) {
goto error;
}
/* Read the file header. */
if (pnm_gethdr(in, &hdr)) {
goto error;
}
JAS_DBGLOG(10, (
"magic %lx; width %lu; height %ld; numcmpts %d; maxval %ld; sgnd %d\n",
JAS_CAST(unsigned long, hdr.magic), JAS_CAST(long, hdr.width),
JAS_CAST(long, hdr.height), hdr.numcmpts, JAS_CAST(long, hdr.maxval),
hdr.sgnd)
);
if (!jas_safe_size_mul3(hdr.width, hdr.height, hdr.numcmpts,
&num_samples)) {
jas_eprintf("image too large\n");
goto error;
}
if (opts.max_samples > 0 && num_samples > opts.max_samples) {
jas_eprintf(
"maximum number of samples would be exceeded (%zu > %zu)\n",
num_samples, opts.max_samples);
goto error;
}
/* Create an image of the correct size. */
for (i = 0, cmptparm = cmptparms; i < hdr.numcmpts; ++i, ++cmptparm) {
cmptparm->tlx = 0;
cmptparm->tly = 0;
cmptparm->hstep = 1;
cmptparm->vstep = 1;
cmptparm->width = hdr.width;
cmptparm->height = hdr.height;
cmptparm->prec = pnm_maxvaltodepth(hdr.maxval);
cmptparm->sgnd = hdr.sgnd;
}
if (!(image = jas_image_create(hdr.numcmpts, cmptparms,
JAS_CLRSPC_UNKNOWN))) {
goto error;
}
if (hdr.numcmpts == 3) {
jas_image_setclrspc(image, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
jas_image_setcmpttype(image, 1,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
jas_image_setcmpttype(image, 2,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
} else {
jas_image_setclrspc(image, JAS_CLRSPC_SGRAY);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
}
/* Read image data from stream into image. */
if (pnm_getdata(in, &hdr, image, opts.allow_trunc)) {
goto error;
}
return image;
error:
if (image) {
jas_image_destroy(image);
}
return 0;
}
int pgx_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
{
pgx_hdr_t hdr;
uint_fast32_t width;
uint_fast32_t height;
jas_bool sgnd;
int prec;
pgx_enc_t encbuf;
pgx_enc_t *enc = &encbuf;
/* Avoid compiler warnings about unused parameters. */
optstr = 0;
switch (jas_clrspc_fam(jas_image_clrspc(image))) {
case JAS_CLRSPC_FAM_GRAY:
if ((enc->cmpt = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0) {
jas_eprintf("error: missing color component\n");
return -1;
}
break;
default:
jas_eprintf("error: BMP format does not support color space\n");
return -1;
break;
}
width = jas_image_cmptwidth(image, enc->cmpt);
height = jas_image_cmptheight(image, enc->cmpt);
prec = jas_image_cmptprec(image, enc->cmpt);
sgnd = jas_image_cmptsgnd(image, enc->cmpt);
/* The PGX format is quite limited in the set of image geometries
that it can handle. Here, we check to ensure that the image to
be saved can actually be represented reasonably accurately using the
PGX format. */
/* There must be exactly one component. */
if (jas_image_numcmpts(image) > 1 || prec > 16) {
jas_eprintf("The PNM format cannot be used to represent an image with this geometry.\n");
return -1;
}
hdr.magic = PGX_MAGIC;
hdr.bigendian = jas_true;
hdr.sgnd = sgnd;
hdr.prec = prec;
hdr.width = width;
hdr.height = height;
#ifdef PGX_DEBUG
pgx_dumphdr(&hdr);
#endif
if (pgx_puthdr(out, &hdr)) {
return -1;
}
if (pgx_putdata(out, &hdr, image, enc->cmpt)) {
return -1;
}
return 0;
}
void JPCInstance::CreateImage( const ImageInfo& info )
{
CheckOpenStream( !m_path.IsEmpty(), "CreateImage" );
InitJasPer();
if ( !info.IsValid() )
JP2KERROR( "Invalid image parameters in JPEG2000 file creation" );
if ( info.colorSpace != ColorSpace::RGB && info.colorSpace != ColorSpace::Gray )
JP2KERROR( "Unsupported color space in JPEG2000 file creation" );
if ( m_options.bitsPerSample != 8 )
if ( m_jp2Options.lossyCompression || m_options.bitsPerSample < 8 )
m_options.bitsPerSample = 8;
else if ( m_options.bitsPerSample != 16 )
m_options.bitsPerSample = 16;
if ( m_jp2CMProfile == nullptr )
m_options.embedICCProfile = false;
m_options.ieeefpSampleFormat = m_options.complexSample = false;
IsoString path8 =
#ifdef __PCL_WINDOWS
File::UnixPathToWindows( m_path ).ToMBS();
#else
m_path.ToUTF8();
#endif
m_jp2Stream = jas_stream_fopen( path8.c_str(), "wb" );
if ( m_jp2Stream == nullptr )
JP2KERROR( "Unable to create JPEG2000 file" );
m_jp2Image = jas_image_create0();
if ( m_jp2Image == nullptr )
JP2KERROR( "Unable to create JPEG2000 image" );
for ( int c = 0; c < info.numberOfChannels; ++c )
{
jas_image_cmptparm_t p;
::memset( &p, 0, sizeof( jas_image_cmptparm_t ) );
p.tlx = p.tly = 0; // top-left corner position
p.hstep = p.vstep = 1; // coordinate grid step sizes
p.width = info.width; // width in pixels
p.height = info.height; // height in pixels
p.prec = m_options.bitsPerSample; // bit depth: 8 or 16 bits
p.sgnd = m_jp2Options.signedSample; // signed or unsigned samples
if ( jas_image_addcmpt( m_jp2Image, c, &p ) != 0 )
JP2KERROR( "Unable to create JPEG2000 image component" );
}
if ( info.colorSpace == ColorSpace::Gray )
{
jas_image_setclrspc( m_jp2Image, m_options.embedICCProfile ? JAS_CLRSPC_GENGRAY : JAS_CLRSPC_SGRAY );
jas_image_setcmpttype( m_jp2Image, 0, JAS_IMAGE_CT_COLOR( JAS_CLRSPC_CHANIND_GRAY_Y ) );
if ( info.numberOfChannels > 1 )
jas_image_setcmpttype( m_jp2Image, 1, JAS_IMAGE_CT_COLOR( JAS_IMAGE_CT_OPACITY ) );
}
else
{
jas_image_setclrspc( m_jp2Image, m_options.embedICCProfile ? JAS_CLRSPC_GENRGB : JAS_CLRSPC_SRGB );
jas_image_setcmpttype( m_jp2Image, 0, JAS_IMAGE_CT_COLOR( JAS_CLRSPC_CHANIND_RGB_R ) );
jas_image_setcmpttype( m_jp2Image, 1, JAS_IMAGE_CT_COLOR( JAS_CLRSPC_CHANIND_RGB_G ) );
jas_image_setcmpttype( m_jp2Image, 2, JAS_IMAGE_CT_COLOR( JAS_CLRSPC_CHANIND_RGB_B ) );
if ( info.numberOfChannels > 3 )
jas_image_setcmpttype( m_jp2Image, 3, JAS_IMAGE_CT_COLOR( JAS_IMAGE_CT_OPACITY ) );
}
if ( m_options.embedICCProfile )
jas_image_setcmprof( m_jp2Image, m_jp2CMProfile );
if ( m_jp2Options.resolutionData )
{
m_jp2Image->rescm_ = m_options.metricResolution;
m_jp2Image->hdispres_ = RoundI( m_options.xResolution );
m_jp2Image->vdispres_ = RoundI( m_options.yResolution );
}
}
int jp2_write_header(jas_image_t *image, jas_stream_t *out)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
jp2_cdefchan_t *cdefchanent;
jp2_cdef_t *cdef;
int i;
uint_fast32_t typeasoc;
jas_iccprof_t *iccprof;
jas_stream_t *iccstream;
int pos;
int needcdef;
int prec;
int sgnd;
box = 0;
tmpstream = 0;
allcmptssame = 1;
sgnd = jas_image_cmptsgnd(image, 0);
prec = jas_image_cmptprec(image, 0);
for (i = 1; i < jas_image_numcmpts(image); ++i) {
if (jas_image_cmptsgnd(image, i) != sgnd ||
jas_image_cmptprec(image, i) != prec) {
allcmptssame = 0;
break;
}
}
/* Output the signature box. */
if (!(box = jp2_box_create(JP2_BOX_JP))) {
goto error;
}
box->data.jp.magic = JP2_JP_MAGIC;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Output the file type box. */
if (!(box = jp2_box_create(JP2_BOX_FTYP))) {
goto error;
}
ftyp = &box->data.ftyp;
ftyp->majver = JP2_FTYP_MAJVER;
ftyp->minver = JP2_FTYP_MINVER;
ftyp->numcompatcodes = 1;
ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/*
* Generate the data portion of the JP2 header box.
* We cannot simply output the header for this box
* since we do not yet know the correct value for the length
* field.
*/
if (!(tmpstream = jas_stream_memopen(0, 0))) {
goto error;
}
/* Generate image header box. */
if (!(box = jp2_box_create(JP2_BOX_IHDR))) {
goto error;
}
ihdr = &box->data.ihdr;
ihdr->width = jas_image_width(image);
ihdr->height = jas_image_height(image);
ihdr->numcmpts = jas_image_numcmpts(image);
ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0),
jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL;
ihdr->comptype = JP2_IHDR_COMPTYPE;
ihdr->csunk = 0;
ihdr->ipr = 0;
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Generate bits per component box. */
if (!allcmptssame) {
if (!(box = jp2_box_create(JP2_BOX_BPCC))) {
goto error;
}
bpcc = &box->data.bpcc;
bpcc->numcmpts = jas_image_numcmpts(image);
if (!(bpcc->bpcs = jas_malloc(bpcc->numcmpts *
sizeof(uint_fast8_t)))) {
goto error;
}
for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) {
bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image,
cmptno), jas_image_cmptprec(image, cmptno));
}
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
}
/* Generate color specification box. */
if (!(box = jp2_box_create(JP2_BOX_COLR))) {
goto error;
}
colr = &box->data.colr;
switch (jas_image_clrspc(image)) {
case JAS_CLRSPC_SRGB:
case JAS_CLRSPC_SYCBCR:
case JAS_CLRSPC_SGRAY:
colr->method = JP2_COLR_ENUM;
colr->csid = clrspctojp2(jas_image_clrspc(image));
colr->pri = JP2_COLR_PRI;
colr->approx = 0;
break;
default:
colr->method = JP2_COLR_ICC;
colr->pri = JP2_COLR_PRI;
colr->approx = 0;
iccprof = jas_iccprof_createfromcmprof(jas_image_cmprof(image));
assert(iccprof);
iccstream = jas_stream_memopen(0, 0);
assert(iccstream);
if (jas_iccprof_save(iccprof, iccstream))
abort();
if ((pos = jas_stream_tell(iccstream)) < 0)
abort();
colr->iccplen = pos;
colr->iccp = jas_malloc(pos);
assert(colr->iccp);
jas_stream_rewind(iccstream);
if (jas_stream_read(iccstream, colr->iccp, colr->iccplen) != colr->iccplen)
abort();
jas_stream_close(iccstream);
jas_iccprof_destroy(iccprof);
break;
}
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
needcdef = 1;
switch (jas_clrspc_fam(jas_image_clrspc(image))) {
case JAS_CLRSPC_FAM_RGB:
if (jas_image_cmpttype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R) &&
jas_image_cmpttype(image, 1) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G) &&
jas_image_cmpttype(image, 2) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))
needcdef = 0;
break;
case JAS_CLRSPC_FAM_YCBCR:
if (jas_image_cmpttype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y) &&
jas_image_cmpttype(image, 1) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB) &&
jas_image_cmpttype(image, 2) ==
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR))
needcdef = 0;
break;
case JAS_CLRSPC_FAM_GRAY:
if (jas_image_cmpttype(image, 0) ==
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))
needcdef = 0;
break;
default:
abort();
break;
}
if (needcdef) {
if (!(box = jp2_box_create(JP2_BOX_CDEF))) {
goto error;
}
cdef = &box->data.cdef;
cdef->numchans = jas_image_numcmpts(image);
cdef->ents = jas_malloc(cdef->numchans * sizeof(jp2_cdefchan_t));
for (i = 0; i < jas_image_numcmpts(image); ++i) {
cdefchanent = &cdef->ents[i];
cdefchanent->channo = i;
typeasoc = jp2_gettypeasoc(jas_image_clrspc(image), jas_image_cmpttype(image, i));
cdefchanent->type = typeasoc >> 16;
cdefchanent->assoc = typeasoc & 0x7fff;
}
if (jp2_box_put(box, tmpstream)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
}
/* Determine the total length of the JP2 header box. */
len = jas_stream_tell(tmpstream);
jas_stream_rewind(tmpstream);
/*
* Output the JP2 header box and all of the boxes which it contains.
*/
if (!(box = jp2_box_create(JP2_BOX_JP2H))) {
goto error;
}
box->len = len + JP2_BOX_HDRLEN;
if (jp2_box_put(box, out)) {
goto error;
}
jp2_box_destroy(box);
box = 0;
if (jas_stream_copy(out, tmpstream, len)) {
goto error;
}
jas_stream_close(tmpstream);
tmpstream = 0;
return 0;
abort();
error:
if (box) {
jp2_box_destroy(box);
}
if (tmpstream) {
jas_stream_close(tmpstream);
}
return -1;
}
static GstFlowReturn
gst_jasper_dec_negotiate (GstJasperDec * dec, jas_image_t * image)
{
GstFlowReturn flow_ret = GST_FLOW_OK;
gint width, height, channels;
gint i, j;
gboolean negotiate = FALSE;
jas_clrspc_t clrspc;
GstCaps *allowed_caps, *caps;
width = jas_image_width (image);
height = jas_image_height (image);
channels = jas_image_numcmpts (image);
GST_LOG_OBJECT (dec, "%d x %d, %d components", width, height, channels);
/* jp2c bitstream has no real colour space info (kept in container),
* so decoder may only pretend to know, where it really does not */
if (!jas_clrspc_isunknown (dec->clrspc)) {
clrspc = dec->clrspc;
GST_DEBUG_OBJECT (dec, "forcing container supplied colour space %d",
clrspc);
jas_image_setclrspc (image, clrspc);
} else
clrspc = jas_image_clrspc (image);
if (!width || !height || !channels || jas_clrspc_isunknown (clrspc))
goto fail_image;
if (dec->width != width || dec->height != height ||
dec->channels != channels || dec->clrspc != clrspc)
negotiate = TRUE;
if (channels != 3)
goto not_supported;
for (i = 0; i < channels; i++) {
gint cheight, cwidth, depth, sgnd;
cheight = jas_image_cmptheight (image, i);
cwidth = jas_image_cmptwidth (image, i);
depth = jas_image_cmptprec (image, i);
sgnd = jas_image_cmptsgnd (image, i);
GST_LOG_OBJECT (dec, "image component %d, %dx%d, depth %d, sgnd %d", i,
cwidth, cheight, depth, sgnd);
if (depth != 8 || sgnd)
goto not_supported;
if (dec->cheight[i] != cheight || dec->cwidth[i] != cwidth) {
dec->cheight[i] = cheight;
dec->cwidth[i] = cwidth;
negotiate = TRUE;
}
}
if (!negotiate && dec->format != GST_VIDEO_FORMAT_UNKNOWN)
goto done;
/* clear and refresh to new state */
flow_ret = GST_FLOW_NOT_NEGOTIATED;
dec->format = GST_VIDEO_FORMAT_UNKNOWN;
dec->width = width;
dec->height = height;
dec->channels = channels;
/* retrieve allowed caps, and find the first one that reasonably maps
* to the parameters of the colourspace */
caps = gst_pad_get_allowed_caps (dec->srcpad);
if (!caps) {
GST_DEBUG_OBJECT (dec, "... but no peer, using template caps");
/* need to copy because get_allowed_caps returns a ref,
and get_pad_template_caps doesn't */
caps = gst_caps_copy (gst_pad_get_pad_template_caps (dec->srcpad));
}
/* avoid lists of fourcc, etc */
allowed_caps = gst_caps_normalize (caps);
caps = NULL;
GST_LOG_OBJECT (dec, "allowed source caps %" GST_PTR_FORMAT, allowed_caps);
for (i = 0; i < gst_caps_get_size (allowed_caps); i++) {
GstVideoFormat format;
gboolean ok;
if (caps)
gst_caps_unref (caps);
caps = gst_caps_copy_nth (allowed_caps, i);
/* sigh, ds and _parse_caps need fixed caps for parsing, fixate */
gst_pad_fixate_caps (dec->srcpad, caps);
GST_LOG_OBJECT (dec, "checking caps %" GST_PTR_FORMAT, caps);
if (!gst_video_format_parse_caps (caps, &format, NULL, NULL))
continue;
if (gst_video_format_is_rgb (format) &&
jas_clrspc_fam (clrspc) == JAS_CLRSPC_FAM_RGB) {
GST_DEBUG_OBJECT (dec, "trying RGB");
if ((dec->cmpt[0] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
(dec->cmpt[1] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
(dec->cmpt[2] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_RGB_B))) < 0) {
GST_DEBUG_OBJECT (dec, "missing RGB color component");
continue;
}
} else if (gst_video_format_is_yuv (format) &&
jas_clrspc_fam (clrspc) == JAS_CLRSPC_FAM_YCBCR) {
GST_DEBUG_OBJECT (dec, "trying YUV");
if ((dec->cmpt[0] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_YCBCR_Y))) < 0 ||
(dec->cmpt[1] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_YCBCR_CB))) < 0 ||
(dec->cmpt[2] = jas_image_getcmptbytype (image,
JAS_IMAGE_CT_COLOR (JAS_CLRSPC_CHANIND_YCBCR_CR))) < 0) {
GST_DEBUG_OBJECT (dec, "missing YUV color component");
continue;
}
} else
continue;
/* match format with validity checks */
ok = TRUE;
for (j = 0; j < channels; j++) {
gint cmpt;
cmpt = dec->cmpt[j];
if (dec->cwidth[cmpt] != gst_video_format_get_component_width (format, j,
width) ||
dec->cheight[cmpt] != gst_video_format_get_component_height (format,
j, height))
ok = FALSE;
}
/* commit to this format */
if (ok) {
dec->format = format;
break;
}
}
if (caps)
gst_caps_unref (caps);
gst_caps_unref (allowed_caps);
if (dec->format != GST_VIDEO_FORMAT_UNKNOWN) {
/* cache some video format properties */
for (j = 0; j < channels; ++j) {
dec->offset[j] = gst_video_format_get_component_offset (dec->format, j,
dec->width, dec->height);
dec->inc[j] = gst_video_format_get_pixel_stride (dec->format, j);
dec->stride[j] = gst_video_format_get_row_stride (dec->format, j,
dec->width);
}
dec->image_size = gst_video_format_get_size (dec->format, width, height);
dec->alpha = gst_video_format_has_alpha (dec->format);
if (dec->buf)
g_free (dec->buf);
dec->buf = g_new0 (glong, dec->width);
caps = gst_video_format_new_caps (dec->format, dec->width, dec->height,
dec->framerate_numerator, dec->framerate_denominator, 1, 1);
GST_DEBUG_OBJECT (dec, "Set format to %d, size to %dx%d", dec->format,
dec->width, dec->height);
if (!gst_pad_set_caps (dec->srcpad, caps))
flow_ret = GST_FLOW_NOT_NEGOTIATED;
else
flow_ret = GST_FLOW_OK;
gst_caps_unref (caps);
}
done:
return flow_ret;
/* ERRORS */
fail_image:
{
GST_DEBUG_OBJECT (dec, "Failed to process decoded image.");
flow_ret = GST_FLOW_NOT_NEGOTIATED;
goto done;
}
not_supported:
{
GST_DEBUG_OBJECT (dec, "Decoded image has unsupported colour space.");
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("Unsupported colorspace"));
flow_ret = GST_FLOW_ERROR;
goto done;
}
}
