int pnm_validate(jas_stream_t *in)
{
uchar buf[2];
int i;
int n;
assert(JAS_STREAM_MAXPUTBACK >= 2);
/* Read the first two characters that constitute the signature. */
if ((n = jas_stream_read(in, buf, 2)) < 0) {
return -1;
}
/* Put these characters back to the stream. */
for (i = n - 1; i >= 0; --i) {
if (jas_stream_ungetc(in, buf[i]) == EOF) {
return -1;
}
}
/* Did we read enough data? */
if (n < 2) {
return -1;
}
/* Is this the correct signature for a PNM file? */
if (buf[0] == 'P' && isdigit(buf[1])) {
return 0;
}
return -1;
}
ICCProfile JP2Instance::ReadICCProfile()
{
CheckOpenStream( !m_path.IsEmpty() && s_jasperInitialized, "ReadICCProfile" );
if ( jas_image_cmprof( m_jp2Image ) == nullptr )
return ICCProfile();
jas_stream_t* iccStream = nullptr;
try
{
// Create a growable memory stream for output
iccStream = jas_stream_memopen( 0, 0 );
if ( iccStream == nullptr )
JP2KERROR( "Extracting ICC profile from JPEG2000 image: Unable to create JasPer stream" );
if ( jas_iccprof_save( jas_image_cmprof( m_jp2Image )->iccprof, iccStream ) < 0 )
JP2KERROR( "Extracting ICC profile from JPEG2000 image: Error saving profile to JasPer stream" );
long iccSize = jas_stream_tell( iccStream );
if ( iccSize <= 0 )
JP2KERROR( "Extracting ICC profile from JPEG2000 image: Invalid JasPer stream position" );
ByteArray iccData( iccSize );
jas_stream_rewind( iccStream );
if ( jas_stream_read( iccStream, iccData.Begin(), iccSize ) != iccSize )
JP2KERROR( "Extracting ICC profile from JPEG2000 image: Error reading JasPer stream" );
jas_stream_close( iccStream ), iccStream = nullptr;
ICCProfile icc( iccData );
if ( icc.IsProfile() )
Console().WriteLn( "<end><cbr>ICC profile extracted: \'" + icc.Description() + "\', " + String( icc.ProfileSize() ) + " bytes." );
return icc;
}
catch ( ... )
{
if ( iccStream != nullptr )
jas_stream_close( iccStream );
Close();
throw;
}
}
int jp2_validate(jas_stream_t *in)
{
char buf[JP2_VALIDATELEN];
int i;
int n;
#if 0
jas_stream_t *tmpstream;
jp2_box_t *box;
#endif
assert(JAS_STREAM_MAXPUTBACK >= JP2_VALIDATELEN);
/* Read the validation data (i.e., the data used for detecting
the format). */
if ((n = jas_stream_read(in, buf, JP2_VALIDATELEN)) < 0) {
return -1;
}
/* Put the validation data back onto the stream, so that the
stream position will not be changed. */
for (i = n - 1; i >= 0; --i) {
if (jas_stream_ungetc(in, buf[i]) == EOF) {
return -1;
}
}
/* Did we read enough data? */
if (n < JP2_VALIDATELEN) {
return -1;
}
/* Is the box type correct? */
if (((buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7]) !=
JP2_BOX_JP)
{
return -1;
}
return 0;
}
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_enc_get_data (GstJasperEnc * enc, guint8 * data, GstBuffer ** outbuf)
{
GstFlowReturn ret = GST_FLOW_OK;
jas_stream_t *stream = NULL;
gint i;
guint size, boxsize;
g_return_val_if_fail (outbuf != NULL, GST_FLOW_ERROR);
*outbuf = NULL;
boxsize = (enc->mode == GST_JP2ENC_MODE_J2C) ? 8 : 0;
if (!(stream = jas_stream_memopen (NULL, 0)))
goto fail_stream;
for (i = 0; i < enc->channels; ++i) {
gint x, y, cwidth, cheight, inc, stride, cmpt;
guint8 *row_pix, *in_pix;
glong *tb;
cmpt = i;
inc = enc->inc[i];
stride = enc->stride[i];
cheight = enc->cheight[cmpt];
cwidth = enc->cwidth[cmpt];
GST_LOG_OBJECT (enc,
"write component %d<=%d, size %dx%d, offset %d, inc %d, stride %d",
i, cmpt, cwidth, cheight, enc->offset[i], inc, stride);
row_pix = data + enc->offset[i];
for (y = 0; y < cheight; y++) {
in_pix = row_pix;
tb = enc->buf;
for (x = 0; x < cwidth; x++) {
*tb = *in_pix;
in_pix += inc;
tb++;
}
if (jas_image_writecmpt2 (enc->image, cmpt, 0, y, cwidth, 1, enc->buf))
goto fail_image;
row_pix += stride;
}
}
GST_LOG_OBJECT (enc, "all components written");
if (jas_image_encode (enc->image, stream, enc->fmt, (char *) "sop"))
goto fail_encode;
GST_LOG_OBJECT (enc, "image encoded");
size = jas_stream_length (stream);
ret = gst_pad_alloc_buffer_and_set_caps (enc->srcpad,
GST_BUFFER_OFFSET_NONE, size + boxsize, GST_PAD_CAPS (enc->srcpad),
outbuf);
if (ret != GST_FLOW_OK)
goto no_buffer;
data = GST_BUFFER_DATA (*outbuf);
if (jas_stream_flush (stream) ||
jas_stream_rewind (stream) < 0 ||
jas_stream_read (stream, data + boxsize, size) < size)
goto fail_image_out;
if (boxsize) {
/* write atom prefix */
GST_WRITE_UINT32_BE (data, size + 8);
GST_WRITE_UINT32_LE (data + 4, GST_MAKE_FOURCC ('j', 'p', '2', 'c'));
}
done:
if (stream)
jas_stream_close (stream);
return ret;
/* ERRORS */
fail_stream:
{
GST_DEBUG_OBJECT (enc, "Failed to create inputstream.");
goto fail;
}
fail_encode:
{
GST_DEBUG_OBJECT (enc, "Failed to encode image.");
goto fail;
}
fail_image:
{
GST_DEBUG_OBJECT (enc, "Failed to process input image.");
goto fail;
}
fail_image_out:
{
GST_DEBUG_OBJECT (enc, "Failed to process encoded image.");
goto fail;
}
fail:
{
if (*outbuf)
gst_buffer_unref (*outbuf);
*outbuf = NULL;
GST_ELEMENT_ERROR (enc, STREAM, ENCODE, (NULL), (NULL));
ret = GST_FLOW_ERROR;
goto done;
}
no_buffer:
{
GST_DEBUG_OBJECT (enc, "Failed to create outbuffer - %s",
gst_flow_get_name (ret));
goto done;
}
}
int img_dat_generate(IMG_DAT **oimg_dat, jas_image_t *image)
{
IMG_DAT *img_dat;
int i;
int cmptscnt;
int rwcnt;
int max_hor, max_vrt;
/* Allocate memory for image data structure. */
img_dat = (IMG_DAT *)calloc(1, sizeof(IMG_DAT));
if(img_dat == NULL){
fprintf(stderr, "ERROR : img_dat_generate : "
"calloc : img_dat (%lu bytes)\n", (unsigned long)sizeof(IMG_DAT));
return(-2);
}
/* Get component count. */
cmptscnt = jas_image_numcmpts(image);
/* Initialize img_dat info */
img_dat->max_width = jas_image_brx(image);
img_dat->max_height = jas_image_bry(image);
img_dat->ppi = -1;
img_dat->intrlv = 0;
img_dat->n_cmpnts = cmptscnt;
img_dat->cmpnt_depth = jas_image_cmptprec(image, 0);
max_hor = -1;
max_vrt = -1;
img_dat->pix_depth = 0;
for(i = 0; i < cmptscnt; i++){
int cdepth;
img_dat->hor_sampfctr[i] = 1;
img_dat->vrt_sampfctr[i] = 1;
cdepth = jas_image_cmptprec(image, i);
img_dat->pix_depth += cdepth;
if (cdepth != img_dat->cmpnt_depth) {
fprintf(stderr, "WARNING : img_dat_generate: "
"unequal component depths, 0: %d and %d: %d\n",
i, cdepth, jas_image_cmptprec(image, i));
}
if(max_hor < img_dat->hor_sampfctr[i])
max_hor = img_dat->hor_sampfctr[i];
if(max_vrt < img_dat->vrt_sampfctr[i])
max_vrt = img_dat->vrt_sampfctr[i];
}
for(i = 0; i < img_dat->n_cmpnts; i++){
img_dat->samp_width[i] = (int)ceil(img_dat->max_width *
(img_dat->hor_sampfctr[i]/(double)max_hor));
img_dat->samp_height[i] = (int)ceil(img_dat->max_height *
(img_dat->vrt_sampfctr[i]/(double)max_vrt));
}
/* Put the image raw pixels to image data sturcture component plains. */
cmptscnt = jas_image_numcmpts(image);
for (i = 0; i < cmptscnt; i++){
jas_stream_rewind(image->cmpts_[i]->stream_);
rwcnt = jas_stream_getrwcount(image->cmpts_[i]->stream_) - 1;
img_dat->image[i] = (unsigned char *)malloc(rwcnt * sizeof(unsigned char));
if(img_dat->image[i] == NULL){
fprintf(stderr, "ERROR : get_raw_image: "
"calloc : img_dat->image[%d] (%lu bytes)\n",
i, (unsigned long)(rwcnt * sizeof(unsigned char)));
return(-3);
}
jas_stream_read(image->cmpts_[i]->stream_, img_dat->image[i], rwcnt);
}
*oimg_dat = img_dat;
return(0);
}