path: root/src/lib/openjpwl/jpwl.h

/*
 * The copyright in this software is being made available under the 2-clauses
 * BSD License, included below. This software may be subject to other third
 * party and contributor rights, including patent rights, and no such rights
 * are granted under this license.
 *
 * Copyright (c) 2001-2003, David Janssens
 * Copyright (c) 2002-2003, Yannick Verschueren
 * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
 * Copyright (c) 2005, Herve Drolon, FreeImage Team
 * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
 * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
 * 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.
 */
#ifndef __JPWL_H
#define __JPWL_H

#ifdef USE_JPWL

#include "crc.h"
#include "rs.h"

/**
@file jpwl.h
@brief The JPEG-2000 Part11 (JPWL) marker segments manager

The functions in JPWL.C have for goal to read/write the markers added by JPWL.
*/

/** @defgroup JPWL JPWL - JPEG-2000 Part11 (JPWL) codestream manager */
/*@{*/

/**
Assume a basic codestream structure, so you can resort better from uncorrected errors
*/
#define JPWL_ASSUME OPJ_TRUE

/**
EPB (Error Protection Block) Marker segment
*/
typedef struct jpwl_epb_ms {
    /**@name Private fields set by epb_create */
    /*@{*/
    /** is the latest in header? */
    opj_bool latest;
    /** is it in packed mode? */
    opj_bool packed;
    /** TH where this marker has been placed (-1 means MH) */
    int tileno;
    /** index in current header (0-63) */
    unsigned char index;
    /** error protection method	[-1=absent 0=none 1=predefined 16=CRC-16 32=CRC-32 37-128=RS] */
    int hprot;
    /** message word length of pre-data */
    int k_pre;
    /** code word length of pre-data */
    int n_pre;
    /** length of pre-data */
    int pre_len;
    /** message word length of post-data */
    int k_post;
    /** code word length of post-data */
    int n_post;
    /** length of post-data */
    int post_len;
    /*@}*/
    /**@name Marker segment fields */
    /*@{*/
    /** two bytes for the length of EPB MS, exluding the marker itself (11 to 65535 bytes) */
    unsigned short int Lepb;
    /** single byte for the style */
    unsigned char Depb;
    /** four bytes, from 0 to 2^31-1 */
    unsigned long int LDPepb;
    /** four bytes, next error management method */
    unsigned long int Pepb;
    /** EPB data, variable size */
    unsigned char *data;
    /*@}*/
}	jpwl_epb_ms_t;

/**
EPC (Error Protection Capability) Marker segment
*/
typedef struct jpwl_epc_ms {
    /** is ESD active? */
    opj_bool esd_on;
    /** is RED active? */
    opj_bool red_on;
    /** is EPB active? */
    opj_bool epb_on;
    /** are informative techniques active? */
    opj_bool info_on;
    /**@name Marker segment fields */
    /*@{*/
    /** two bytes for the length of EPC MS, exluding the marker itself (9 to 65535 bytes) */
    unsigned short int Lepc;
    /** two bytes, CRC for the EPC, excluding Pcrc itself */
    unsigned short int Pcrc;
    /** four bytes, the codestream length from SOC to EOC */
    unsigned long int DL;
    /** one byte, signals JPWL techniques adoption */
    unsigned char Pepc;
    /** EPC data, variable length */
    unsigned char *data;
    /*@}*/
}	jpwl_epc_ms_t;

/**
ESD (Error Sensitivity Descriptor) Marker segment
*/
typedef struct jpwl_esd_ms {
    /** codestream addressing mode [0=packet, 1=byte range, 2=packet range, 3=reserved] */
    unsigned char addrm;
    /** size of codestream addresses [2/4 bytes] */
    unsigned char ad_size;
    /** type of sensitivity
    [0=relative error, 1=MSE, 2=MSE reduction, 3=PSNR, 4=PSNR increment,
    5=MAXERR (absolute peak error), 6=TSE (total squared error), 7=reserved */
    unsigned char senst;
    /** size of sensitivity data (1/2 bytes) */
    unsigned char se_size;
    /**@name Marker segment fields */
    /*@{*/
    /** two bytes for the length of ESD MS, exluding the marker itself (4 to 65535 bytes) */
    unsigned short int Lesd;
    /** two bytes, component of error sensitivity */
    unsigned short int Cesd;
    /** one byte, signals JPWL techniques adoption */
    unsigned char Pesd;
    /** ESD data, variable length */
    unsigned char *data;
    /*@}*/
    /**@name Fields set by esd_create (only internal use) */
    /*@{*/
    /** number of components in the image */
    int numcomps;
    /** tile where this marker has been placed (-1 means MH) */
    int tileno;
    /** number of sensitivity values */
    unsigned long int svalnum;
    /** size of a single sensitivity pair (address+value) */
    size_t sensval_size;
    /*@}*/
}	jpwl_esd_ms_t;

/**
RED (Residual Error Descriptor) Marker segment
*/
typedef struct jpwl_red_ms {
    /** two bytes for the length of RED MS, exluding the marker itself (3 to 65535 bytes) */
    unsigned short int Lred;
    /** one byte, signals JPWL techniques adoption */
    unsigned char Pred;
    /** RED data, variable length */
    unsigned char *data;
}	jpwl_red_ms_t;

/**
Structure used to store JPWL markers temporary position and readyness
*/
typedef struct jpwl_marker {
    /** marker value (J2K_MS_EPC, etc.) */
    int id;
    /** union keeping the pointer to the real marker struct */
    union jpwl_marks {
        /** pointer to EPB marker */
        jpwl_epb_ms_t *epbmark;
        /** pointer to EPC marker */
        jpwl_epc_ms_t *epcmark;
        /** pointer to ESD marker */
        jpwl_esd_ms_t *esdmark;
        /** pointer to RED marker */
        jpwl_red_ms_t *redmark;
    } m;
    /** position where the marker should go, in the pre-JPWL codestream */
    unsigned long int pos;
    /** same as before, only written as a double, so we can sort it better */
    double dpos;
    /** length of the marker segment (marker excluded) */
    unsigned short int len;
    /** the marker length is ready or not? */
    opj_bool len_ready;
    /** the marker position is ready or not? */
    opj_bool pos_ready;
    /** the marker parameters are ready or not? */
    opj_bool parms_ready;
    /** are the written data ready or not */
    opj_bool data_ready;
}	jpwl_marker_t;

/**
Encode according to JPWL specs
@param j2k J2K handle
@param cio codestream handle
@param image image handle
*/
void jpwl_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);

/**
Prepare the list of JPWL markers, after the Part 1 codestream
has been finalized (index struct is full)
@param j2k J2K handle
@param cio codestream handle
@param image image handle
*/
void jpwl_prepare_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);

/**
Dump the list of JPWL markers, after it has been prepared
@param j2k J2K handle
@param cio codestream handle
@param image image handle
*/
void jpwl_dump_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);

/**
Read the EPC marker (Error Protection Capability)
@param j2k J2K handle
*/
void j2k_read_epc(opj_j2k_t *j2k);

/**
Write the EPC marker (Error Protection Capability), BUT the DL field is always set to 0
(this simplifies the management of EPBs and it is openly stated in the standard
as a possible value, mening that the information is not available) and the informative techniques
are not yet implemented
@param j2k J2K handle
*/
#if 0
void j2k_write_epc(opj_j2k_t *j2k);
#endif

/**
Read the EPB marker (Error Protection Block)
@param j2k J2K handle
*/
void j2k_read_epb(opj_j2k_t *j2k);

/**
Write the EPB marker (Error Protection Block)
@param j2k J2K handle
*/
void j2k_write_epb(opj_j2k_t *j2k);

/**
Read the ESD marker (Error Sensitivity Descriptor)
@param j2k J2K handle
*/
void j2k_read_esd(opj_j2k_t *j2k);

/**
Read the RED marker (Residual Error Descriptor)
@param j2k J2K handle
*/
void j2k_read_red(opj_j2k_t *j2k);

/** create an EPB marker segment
@param j2k J2K compressor handle
@param latest it is the latest EPB in the header
@param packed EPB is in packed style
@param tileno tile number where the marker has been placed (-1 means MH)
@param idx current EPB running index
@param hprot applied protection type (-1/0,1,16,32,37-128)
@param pre_len length of pre-protected data
@param post_len length of post-protected data
@return returns the freshly created EPB
*/
jpwl_epb_ms_t *jpwl_epb_create(opj_j2k_t *j2k, opj_bool latest, opj_bool packed, int tileno, int idx, int hprot,
                               unsigned long int pre_len, unsigned long int post_len);

/** add a number of EPB marker segments
@param j2k J2K compressor handle
@param jwmarker pointer to the JPWL markers list
@param jwmarker_num pointer to the number of JPWL markers (gets updated)
@param latest it is the latest group of EPBs in the header
@param packed EPBs are in packed style
@param insideMH it is in the MH
@param idx pointer to the starting EPB running index (gets updated)
@param hprot applied protection type (-1/0,1,16,32,37-128)
@param place_pos place in original codestream where EPBs should go
@param tileno tile number of these EPBs
@param pre_len length of pre-protected data
@param post_len length of post-protected data
@return returns the length of all added markers
*/
int jpwl_epbs_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
                  opj_bool latest, opj_bool packed, opj_bool insideMH, int *idx, int hprot,
                  double place_pos, int tileno,
                  unsigned long int pre_len, unsigned long int post_len);

/** add a number of ESD marker segments
@param j2k J2K compressor handle
@param jwmarker pointer to the JPWL markers list
@param jwmarker_num pointer to the number of JPWL markers (gets updated)
@param comps considered component (-1=average, 0/1/2/...=component no.)
@param addrm addressing mode (0=packet, 1=byte range, 2=packet range, 3=reserved)
@param ad_size size of addresses (2/4 bytes)
@param senst sensitivity type
@param se_size sensitivity values size (1/2 bytes)
@param place_pos place in original codestream where EPBs should go
@param tileno tile number of these EPBs
@return returns the length of all added markers
*/
int jpwl_esds_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
                  int comps, unsigned char addrm, unsigned char ad_size,
                  unsigned char senst, unsigned char se_size,
                  double place_pos, int tileno);

/** updates the information structure by modifying the positions and lengths
@param j2k J2K compressor handle
@param jwmarker pointer to JPWL markers list
@param jwmarker_num number of JPWL markers
@return returns true in case of success
*/
opj_bool jpwl_update_info(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int jwmarker_num);


opj_bool jpwl_esd_fill(opj_j2k_t *j2k, jpwl_esd_ms_t *esdmark, unsigned char *buf);

opj_bool jpwl_epb_fill(opj_j2k_t *j2k, jpwl_epb_ms_t *epbmark, unsigned char *buf, unsigned char *post_buf);

opj_bool j2k_add_marker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);

/** corrects the data in the JPWL codestream
@param j2k J2K compressor handle
@return true if correction is performed correctly
*/
opj_bool jpwl_correct(opj_j2k_t *j2k);

/** corrects the data protected by an EPB
@param j2k J2K compressor handle
@param buffer pointer to the EPB position
@param type type of EPB: 0=MH, 1=TPH, 2=other, 3=auto
@param pre_len length of pre-data
@param post_len length of post_data
@param conn is a pointer to the length of all connected (packed) EPBs
@param L4_bufp is a pointer to the buffer pointer of redundancy data
@return returns true if correction could be successfully performed
*/
opj_bool jpwl_epb_correct(opj_j2k_t *j2k, unsigned char *buffer, int type, int pre_len, int post_len, int *conn,
                          unsigned char **L4_bufp);

/** check that a tile and its children have valid data
@param j2k J2K decompressor handle
@param tcd Tile decompressor handle
@param tileno number of the tile to check
*/
opj_bool jpwl_check_tile(opj_j2k_t *j2k, opj_tcd_t *tcd, int tileno);

/** Macro functions for CRC computation */

/**
Computes the CRC-16, as stated in JPWL specs
@param CRC two bytes containing the CRC value (must be initialized with 0x0000)
@param DATA byte for which the CRC is computed; call this on every byte of the sequence
and get the CRC at the end
*/
#define jpwl_updateCRC16(CRC, DATA) updateCRC16(CRC, DATA)

/**
Computes the CRC-32, as stated in JPWL specs
@param CRC four bytes containing the CRC value (must be initialized with 0x00000000)
@param DATA byte for which the CRC is computed; call this on every byte of the sequence
and get the CRC at the end
*/
#define jpwl_updateCRC32(CRC, DATA) updateCRC32(CRC, DATA)

/**
Computes the minimum between two integers
@param a first integer to compare
@param b second integer to compare
@return returns the minimum integer between a and b
*/
#ifndef min
#define min(a,b)    (((a) < (b)) ? (a) : (b))
#endif /* min */

/*@}*/

#endif /* USE_JPWL */

#ifdef USE_JPSEC

/** @defgroup JPSEC JPSEC - JPEG-2000 Part 8 (JPSEC) codestream manager */
/*@{*/

/**
Read the SEC marker (SEcured Codestream)
@param j2k J2K handle
*/
void j2k_read_sec(opj_j2k_t *j2k);

/**
Write the SEC marker (SEcured Codestream)
@param j2k J2K handle
*/
void j2k_write_sec(opj_j2k_t *j2k);

/**
Read the INSEC marker (SEcured Codestream)
@param j2k J2K handle
*/
void j2k_read_insec(opj_j2k_t *j2k);

/*@}*/

#endif /* USE_JPSEC */

#endif /* __JPWL_H */