openjpeg/src/lib/openjpip/jpip_parser.c

/*
 * $Id$
 *
 * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
 * Copyright (c) 2002-2014, Professor Benoit Macq
 * Copyright (c) 2010-2011, Kaori Hagihara
 * Copyright (c) 2011,      Lucian Corlaciu, GSoC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "jpip_parser.h"
#include "channel_manager.h"
#include "imgreg_manager.h"

#ifdef SERVER
#include "fcgi_stdio.h"
#define logstream FCGI_stdout
#else
#define FCGI_stdout stdout
#define FCGI_stderr stderr
#define logstream stderr
#endif /*SERVER*/


OPJ_BOOL identify_target(query_param_t query_param,
                         targetlist_param_t *targetlist, target_param_t **target)
{
    if (query_param.tid) {
        if (strcmp(query_param.tid, "0") != 0) {
            if (query_param.cid[0] != '\0') {
                fprintf(FCGI_stdout,
                        "Reason: Target can not be specified both through tid and cid\r\n");
                fprintf(FCGI_stdout, "Status: 400\r\n");
                return OPJ_FALSE;
            }
            if ((*target = search_targetBytid(query_param.tid, targetlist))) {
                return OPJ_TRUE;
            }
        }
    }

    if (query_param.target)
        if (!(*target = search_target(query_param.target, targetlist)))
            if (!(*target = gene_target(targetlist, query_param.target))) {
                return OPJ_FALSE;
            }

    if (*target) {
        fprintf(FCGI_stdout, "JPIP-tid: %s\r\n", (*target)->tid);
        return OPJ_TRUE;
    } else {
        fprintf(FCGI_stdout, "Reason: target not found\r\n");
        fprintf(FCGI_stdout, "Status: 400\r\n");
        return OPJ_FALSE;
    }
}

OPJ_BOOL associate_channel(query_param_t    query_param,
                           sessionlist_param_t *sessionlist,
                           session_param_t **cursession,
                           channel_param_t **curchannel)
{
    if (search_session_and_channel(query_param.cid, sessionlist, cursession,
                                   curchannel)) {

        if (!query_param.cnew) {
            set_channel_variable_param(query_param, *curchannel);
        }
    } else {
        fprintf(FCGI_stderr, "Error: process canceled\n");
        return OPJ_FALSE;
    }
    return OPJ_TRUE;
}

OPJ_BOOL open_channel(query_param_t query_param,
                      sessionlist_param_t *sessionlist,
                      auxtrans_param_t auxtrans,
                      target_param_t *target,
                      session_param_t **cursession,
                      channel_param_t **curchannel)
{
    cachemodel_param_t *cachemodel = NULL;

    if (target) {
        if (!(*cursession)) {
            *cursession = gene_session(sessionlist);
        }
        if (!(cachemodel = search_cachemodel(target, (*cursession)->cachemodellist)))
            if (!(cachemodel = gene_cachemodel((*cursession)->cachemodellist, target,
                                               query_param.return_type == JPPstream))) {
                return OPJ_FALSE;
            }
    } else if (*curchannel) {
        cachemodel = (*curchannel)->cachemodel;
    }

    *curchannel = gene_channel(query_param, auxtrans, cachemodel,
                               (*cursession)->channellist);
    if (*curchannel == NULL) {
        return OPJ_FALSE;
    }

    return OPJ_TRUE;
}

OPJ_BOOL close_channel(query_param_t query_param,
                       sessionlist_param_t *sessionlist,
                       session_param_t **cursession,
                       channel_param_t **curchannel)
{
    char *cclose;
    int i;

    if (query_param.cclose[0] == '*') {
#ifndef SERVER
        fprintf(logstream, "local log: close all\n");
#endif
        /* all channels associatd with the session will be closed */
        if (!delete_session(cursession, sessionlist)) {
            return OPJ_FALSE;
        }
    } else {
        /* check if all entry belonging to the same session */

        for (i = 0, cclose = query_param.cclose; i < query_param.numOfcclose;
                i++, cclose += (strlen(cclose) + 1)) {

            /* In case of the first entry of close cid */
            if (*cursession == NULL) {
                if (!search_session_and_channel(cclose, sessionlist, cursession, curchannel)) {
                    return OPJ_FALSE;
                }
            } else /* second or more entry of close cid */
                if (!(*curchannel = search_channel(cclose, (*cursession)->channellist))) {
                    fprintf(FCGI_stdout, "Reason: Cclose id %s is from another session\r\n",
                            cclose);
                    return OPJ_FALSE;
                }
        }

        /* delete channels */
        for (i = 0, cclose = query_param.cclose; i < query_param.numOfcclose;
                i++, cclose += (strlen(cclose) + 1)) {
            *curchannel = search_channel(cclose, (*cursession)->channellist);
            delete_channel(curchannel, (*cursession)->channellist);
        }

        if ((*cursession)->channellist->first == NULL ||
                (*cursession)->channellist->last == NULL)
            /* In case of empty session */
        {
            delete_session(cursession, sessionlist);
        }
    }
    return OPJ_TRUE;
}


/**
 * enqueue tiles or precincts into the message queue
 *
 * @param[in] query_param structured query
 * @param[in] msgqueue    message queue pointer
 */
void enqueue_imagedata(query_param_t query_param, msgqueue_param_t *msgqueue);

/**
 * enqueue metadata bins into the message queue
 *
 * @param[in]     query_param  structured query
 * @param[in]     metadatalist pointer to metadata bin list
 * @param[in,out] msgqueue     message queue pointer
 * @return                     if succeeded (true) or failed (false)
 */
OPJ_BOOL enqueue_metabins(query_param_t query_param,
                          metadatalist_param_t *metadatalist, msgqueue_param_t *msgqueue);


OPJ_BOOL gene_JPIPstream(query_param_t query_param,
                         target_param_t *target,
                         session_param_t *cursession,
                         channel_param_t *curchannel,
                         msgqueue_param_t **msgqueue)
{
    index_param_t *codeidx;
    cachemodel_param_t *cachemodel;

    if (!cursession || !curchannel) { /* stateless */
        if (!target) {
            return OPJ_FALSE;
        }
        if (!(cachemodel = gene_cachemodel(NULL, target,
                                           query_param.return_type == JPPstream))) {
            return OPJ_FALSE;
        }
        *msgqueue = gene_msgqueue(OPJ_TRUE, cachemodel);
    } else { /* session */
        cachemodel  = curchannel->cachemodel;
        target = cachemodel->target;
        *msgqueue = gene_msgqueue(OPJ_FALSE, cachemodel);
    }

    codeidx = target->codeidx;

    if (cachemodel->jppstream) {
        fprintf(FCGI_stdout, "Content-type: image/jpp-stream\r\n");
    } else {
        fprintf(FCGI_stdout, "Content-type: image/jpt-stream\r\n");
    }

    if (query_param.layers != -1) {
        if (query_param.layers  > codeidx->COD.numOflayers) {
            fprintf(FCGI_stdout, "JPIP-layers: %d\r\n", codeidx->COD.numOflayers);
            query_param.layers = codeidx->COD.numOflayers;
        }
    }

    /*meta*/
    if (query_param.box_type[0][0] != 0  && query_param.len != 0)
        if (!enqueue_metabins(query_param, codeidx->metadatalist, *msgqueue)) {
            return OPJ_FALSE;
        }

    if (query_param.metadata_only) {
        return OPJ_TRUE;
    }

    /* main header */
    if (!cachemodel->mhead_model && query_param.len != 0) {
        enqueue_mainheader(*msgqueue);
    }

    /* image codestream */
    if ((query_param.fx > 0 && query_param.fy > 0)) {
        enqueue_imagedata(query_param, *msgqueue);
    }

    return OPJ_TRUE;
}


/**
 * enqueue precinct data-bins into the queue
 *
 * @param[in] xmin      min x coordinate in the tile at the decomposition level
 * @param[in] xmax      max x coordinate in the tile at the decomposition level
 * @param[in] ymin      min y coordinate in the tile at the decomposition level
 * @param[in] ymax      max y coordinate in the tile at the decomposition level
 * @param[in] tile_id   tile index
 * @param[in] level     decomposition level
 * @param[in] lastcomp  last component number
 * @param[in] comps     pointer to the array that stores the requested components
 * @param[in] layers    number of quality layers
 * @param[in] msgqueue  message queue
 * @return
 */
void enqueue_precincts(int xmin, int xmax, int ymin, int ymax, int tile_id,
                       int level, int lastcomp, OPJ_BOOL *comps, int layers,
                       msgqueue_param_t *msgqueue);

/**
 * enqueue all precincts inside a tile into the queue
 *
 * @param[in] tile_id   tile index
 * @param[in] level     decomposition level
 * @param[in] lastcomp  last component number
 * @param[in] comps     pointer to the array that stores the requested components
 * @param[in] layers    number of quality layers
 * @param[in] msgqueue  message queue
 * @return
 */
void enqueue_allprecincts(int tile_id, int level, int lastcomp, OPJ_BOOL *comps,
                          int layers, msgqueue_param_t *msgqueue);

void enqueue_imagedata(query_param_t query_param, msgqueue_param_t *msgqueue)
{
    index_param_t *codeidx;
    imgreg_param_t imgreg;
    range_param_t tile_Xrange, tile_Yrange;
    Byte4_t u, v, tile_id;
    int xmin, xmax, ymin, ymax;
    int numOfreslev;

    codeidx = msgqueue->cachemodel->target->codeidx;

    if (!(msgqueue->cachemodel->jppstream)  &&
            get_nmax(codeidx->tilepart) == 1) { /* normally not the case */
        numOfreslev = 1;
    } else {
        numOfreslev = codeidx->COD.numOfdecomp + 1;
    }

    imgreg  = map_viewin2imgreg(query_param.fx, query_param.fy,
                                query_param.rx, query_param.ry, query_param.rw, query_param.rh,
                                (int)codeidx->SIZ.XOsiz, (int)codeidx->SIZ.YOsiz, (int)codeidx->SIZ.Xsiz,
                                (int)codeidx->SIZ.Ysiz,
                                numOfreslev);

    if (query_param.len == 0) {
        return;
    }

    for (u = 0, tile_id = 0; u < codeidx->SIZ.YTnum; u++) {
        tile_Yrange = get_tile_Yrange(codeidx->SIZ, tile_id, imgreg.level);

        for (v = 0; v < codeidx->SIZ.XTnum; v++, tile_id++) {
            tile_Xrange = get_tile_Xrange(codeidx->SIZ, tile_id, imgreg.level);

            if (tile_Xrange.minvalue < tile_Xrange.maxvalue &&
                    tile_Yrange.minvalue < tile_Yrange.maxvalue) {
                if (tile_Xrange.maxvalue <= (Byte4_t)(imgreg.xosiz + imgreg.ox) ||
                        tile_Xrange.minvalue >= (Byte4_t)(imgreg.xosiz + imgreg.ox + imgreg.sx) ||
                        tile_Yrange.maxvalue <= (Byte4_t)(imgreg.yosiz + imgreg.oy) ||
                        tile_Yrange.minvalue >= (Byte4_t)(imgreg.yosiz + imgreg.oy + imgreg.sy)) {
                    /*printf("Tile completely excluded from view-window %d\n", tile_id);*/
                    /* Tile completely excluded from view-window */
                } else if (tile_Xrange.minvalue >= (Byte4_t)(imgreg.xosiz + imgreg.ox) &&
                           tile_Xrange.maxvalue <= (Byte4_t)(imgreg.xosiz + imgreg.ox + imgreg.sx) &&
                           tile_Yrange.minvalue >= (Byte4_t)(imgreg.yosiz + imgreg.oy) &&
                           tile_Yrange.maxvalue <= (Byte4_t)(imgreg.yosiz + imgreg.oy + imgreg.sy)) {
                    /* Tile completely contained within view-window */
                    /* high priority */
                    /*printf("Tile completely contained within view-window %d\n", tile_id);*/
                    if (msgqueue->cachemodel->jppstream) {
                        enqueue_tileheader((int)tile_id, msgqueue);
                        enqueue_allprecincts((int)tile_id, imgreg.level, query_param.lastcomp,
                                             query_param.comps, query_param.layers, msgqueue);
                    } else {
                        enqueue_tile(tile_id, imgreg.level, msgqueue);
                    }
                } else {
                    /* Tile partially overlaps view-window */
                    /* low priority */
                    /*printf("Tile partially overlaps view-window %d\n", tile_id);*/
                    if (msgqueue->cachemodel->jppstream) {
                        enqueue_tileheader((int)tile_id, msgqueue);

                        /* FIXME: The following code is suspicious it implicitely cast an unsigned int to int, which truncates values */
                        xmin = tile_Xrange.minvalue >= (Byte4_t)(imgreg.xosiz + imgreg.ox) ? 0 :
                               imgreg.xosiz + imgreg.ox - (int)tile_Xrange.minvalue;
                        xmax = tile_Xrange.maxvalue <= (Byte4_t)(imgreg.xosiz + imgreg.ox + imgreg.sx)
                               ? (int)(tile_Xrange.maxvalue - tile_Xrange.minvalue - 1) : (int)(
                                   imgreg.xosiz + imgreg.ox + imgreg.sx - (int)tile_Xrange.minvalue - 1);
                        ymin = tile_Yrange.minvalue >= (Byte4_t)(imgreg.yosiz + imgreg.oy) ? 0 :
                               imgreg.yosiz + imgreg.oy - (int)tile_Yrange.minvalue;
                        ymax = tile_Yrange.maxvalue <= (Byte4_t)(imgreg.yosiz + imgreg.oy + imgreg.sy)
                               ? (int)(tile_Yrange.maxvalue - tile_Yrange.minvalue - 1) : (int)(
                                   imgreg.yosiz + imgreg.oy + imgreg.sy - (int)tile_Yrange.minvalue - 1);
                        enqueue_precincts(xmin, xmax, ymin, ymax, (int)tile_id, imgreg.level,
                                          query_param.lastcomp, query_param.comps, query_param.layers, msgqueue);
                    } else {
                        enqueue_tile(tile_id, imgreg.level, msgqueue);
                    }
                }
            }
        }
    }
}


void enqueue_precincts(int xmin, int xmax, int ymin, int ymax, int tile_id,
                       int level, int lastcomp, OPJ_BOOL *comps, int layers,
                       msgqueue_param_t *msgqueue)
{
    index_param_t *codeidx;
    int c, u, v, res_lev, dec_lev;
    int seq_id;
    Byte4_t XTsiz, YTsiz;
    Byte4_t XPsiz, YPsiz;
    Byte4_t xminP, xmaxP, yminP, ymaxP;

    codeidx  = msgqueue->cachemodel->target->codeidx;
    /* MM: shouldn't xmin/xmax be Byte4_t instead ? */
    if (xmin < 0 || xmax < 0 || ymin < 0 || ymax < 0) {
        return;
    }
    /* MM: I think the API should not really be int should it ? */
    if (tile_id < 0) {
        return;
    }

    for (c = 0; c < codeidx->SIZ.Csiz; c++)
        if (lastcomp == -1 /*all*/ || (c <= lastcomp && comps[c])) {
            seq_id = 0;
            for (res_lev = 0, dec_lev = codeidx->COD.numOfdecomp; dec_lev >= level;
                    res_lev++, dec_lev--) {

                XTsiz = get_tile_XSiz(codeidx->SIZ, (Byte4_t)tile_id, dec_lev);
                YTsiz = get_tile_YSiz(codeidx->SIZ, (Byte4_t)tile_id, dec_lev);

                XPsiz = (codeidx->COD.Scod & 0x01) ? codeidx->COD.XPsiz[ res_lev] : XTsiz;
                YPsiz = (codeidx->COD.Scod & 0x01) ? codeidx->COD.YPsiz[ res_lev] : YTsiz;

                for (u = 0; u < ceil((double)YTsiz / (double)YPsiz); u++) {
                    yminP = (Byte4_t)u * YPsiz;
                    ymaxP = (Byte4_t)(u + 1) * YPsiz - 1;
                    if (YTsiz <= ymaxP) {
                        ymaxP = YTsiz - 1;
                    }

                    for (v = 0; v < ceil((double)XTsiz / (double)XPsiz); v++, seq_id++) {
                        xminP = (Byte4_t)v * XPsiz;
                        xmaxP = (Byte4_t)(v + 1) * XPsiz - 1;
                        if (XTsiz <= xmaxP) {
                            xmaxP = XTsiz - 1;
                        }

                        if (xmaxP < (Byte4_t)xmin || xminP > (Byte4_t)xmax || ymaxP < (Byte4_t)ymin ||
                                yminP > (Byte4_t)ymax) {
                            /* Precinct completely excluded from view-window */
                        } else if (xminP >= (Byte4_t)xmin && xmaxP <= (Byte4_t)xmax &&
                                   yminP >= (Byte4_t)ymin && ymaxP <= (Byte4_t)ymax) {
                            /* Precinct completely contained within view-window
                             high priority */
                            enqueue_precinct(seq_id, tile_id, c, (dec_lev > level) ? -1 : layers, msgqueue);
                        } else {
                            /* Precinct partially overlaps view-window
                             low priority */
                            enqueue_precinct(seq_id, tile_id, c, (dec_lev > level) ? -1 : layers, msgqueue);
                        }
                    }
                }
            }
        }
}

void enqueue_allprecincts(int tile_id, int level, int lastcomp, OPJ_BOOL *comps,
                          int layers, msgqueue_param_t *msgqueue)
{
    index_param_t *codeidx;
    int c, i, res_lev, dec_lev;
    int seq_id;
    Byte4_t XTsiz, YTsiz;
    Byte4_t XPsiz, YPsiz;

    codeidx  = msgqueue->cachemodel->target->codeidx;
    if (tile_id < 0) {
        return;
    }

    for (c = 0; c < codeidx->SIZ.Csiz; c++)
        if (lastcomp == -1 /*all*/ || (c <= lastcomp && comps[c])) {
            seq_id = 0;
            for (res_lev = 0, dec_lev = codeidx->COD.numOfdecomp; dec_lev >= level;
                    res_lev++, dec_lev--) {

                XTsiz = get_tile_XSiz(codeidx->SIZ, (Byte4_t)tile_id, dec_lev);
                YTsiz = get_tile_YSiz(codeidx->SIZ, (Byte4_t)tile_id, dec_lev);

                XPsiz = (codeidx->COD.Scod & 0x01) ? codeidx->COD.XPsiz[ res_lev] : XTsiz;
                YPsiz = (codeidx->COD.Scod & 0x01) ? codeidx->COD.YPsiz[ res_lev] : YTsiz;

                for (i = 0;
                        i < ceil((double)YTsiz / (double)YPsiz)*ceil((double)XTsiz / (double)XPsiz);
                        i++, seq_id++) {
                    enqueue_precinct(seq_id, tile_id, c, (dec_lev > level) ? -1 : layers,
                                     msgqueue);
                }
            }
        }
}

OPJ_BOOL enqueue_metabins(query_param_t query_param,
                          metadatalist_param_t *metadatalist, msgqueue_param_t *msgqueue)
{
    int i;
    for (i = 0; i < MAX_NUMOFBOX && query_param.box_type[i][0] != 0; i++) {
        if (query_param.box_type[i][0] == '*') {
            fprintf(FCGI_stdout, "Status: 501\r\n");
            fprintf(FCGI_stdout,
                    "Reason: metareq with all box-property * not implemented\r\n");
            return OPJ_FALSE;
        } else {
            Byte8_t idx = search_metadataidx(query_param.box_type[i], metadatalist);

            if (idx != (Byte8_t) - 1) {
                enqueue_metadata(idx, msgqueue);
            } else {
                fprintf(FCGI_stdout, "Status: 400\r\n");
                fprintf(FCGI_stdout, "Reason: box-type %.4s not found\r\n",
                        query_param.box_type[i]);
                return OPJ_FALSE;
            }
        }
    }
    return OPJ_TRUE;
}