JP2_Encoder.hh

Go to the documentation of this file.

/*  JP2_Encoder
 
HiROC CVS ID: JP2_Encoder.hh,v 1.28 2019/03/26 20:51:11 guym Exp
 
Copyright (C) 2006-2007  Arizona Board of Regents on behalf of the
Planetary Image Research Laboratory, Lunar and Planetary Laboratory at
the University of Arizona.
 
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License, version 2.1,
as published by the Free Software Foundation.
 
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
*/
 
#ifndef _JP2_Encoder_
#define _JP2_Encoder_
 
#include    "Dimensions.hh"
#include    "JP2_Box.hh"
 
//  Kakadu
#include    "jp2.h"
using namespace kdu_supp;
 
#include    <string>
#include    <iosfwd>
#include    <vector>
 
namespace UA
{
namespace HiRISE
{
//  Forward reference.
class JP2_Encoder_Error;

class JP2_Encoder
{
public:
/*==============================================================================
    Constants:
*/
static const char* const
    ID;

static const unsigned int
    DEFAULT_RESOLUTION_LEVELS;
static const unsigned int
    MAX_RESOLUTION_LEVELS;
static const unsigned int
    MAX_QUALITY_LAYERS;

static const char* const
    UUID_INFO_BOX_NAME;
static const char* const
    UUID_BOX_NAME;
static const int
    UUID_SIZE;
static const char* const
    URL_BOX_NAME;

static const int
    MIN_STRIPE_HEIGHT,
    MAX_STRIPE_HEIGHT;

static const int
    NEEDS_SOURCE,
    NEEDS_DESTINATION,
    NEEDS_IMAGE;

static const int
    ENCODER_EXCEPTION;
 
/*==============================================================================
    Constructors:
*/
JP2_Encoder ();
 
//  Destructor.
~JP2_Encoder (); 
 
/*==============================================================================
    Accessors:
*/
std::string source () const
    {return Image_Source;}

JP2_Encoder& source (const std::string& pathname);

std::string destination () const
    {return JP2_Pathname;}

JP2_Encoder& destination (const std::string& pathname)
    {JP2_Pathname = pathname; return *this;}

std::string PDS_label_pathname () const
    {return PDS_Label_Pathname;}

JP2_Encoder& PDS_label_pathname (const std::string& pathname)
    {PDS_Label_Pathname = pathname; return *this;}

std::streamoff image_data_location () const
    {return Image_Offset;}

JP2_Encoder& image_data_location (std::streamoff file_offset)
    {Image_Offset = file_offset; return *this;}

unsigned int image_bands () const
    {return Image_Bands;}

JP2_Encoder& image_bands (unsigned int bands)
    {Image_Bands = bands; return *this;}

const Size_2D image_size () const
    {return Image_Size;}

JP2_Encoder& image_size (const Size_2D& size);

unsigned int pixel_bytes () const
    {return Pixel_Bytes;}

JP2_Encoder& pixel_bytes (unsigned int bytes_per_pixel);

unsigned int pixel_bits () const
    {return Pixel_Bits;}

JP2_Encoder& pixel_bits (unsigned int bits_per_pixel);

bool signed_data () const
    {return Signed_Data;}

JP2_Encoder& signed_data (bool data_is_signed);

bool MSB_data () const;

JP2_Encoder& MSB_data (bool data_is_MSB);

bool swap_pixel_bytes () const
    {return Swap_Pixel_Bytes;}

JP2_Encoder& swap_pixel_bytes (bool swap_data)
    {Swap_Pixel_Bytes = swap_data; return *this;}

unsigned int line_prefix_bytes () const
    {return Line_Prefix_Bytes;}

JP2_Encoder& line_prefix_bytes (unsigned int prefix_bytes)
    {Line_Prefix_Bytes = prefix_bytes; return *this;}

unsigned int line_suffix_bytes () const
    {return Line_Suffix_Bytes;}

JP2_Encoder& line_suffix_bytes (unsigned int suffix_bytes)
    {Line_Suffix_Bytes = suffix_bytes; return *this;}

const Size_2D tile_size () const
    {return Tile_Size;}

JP2_Encoder& tile_size (const Size_2D& size)
    {Tile_Size = size; return *this;}

unsigned int resolution_levels () const
    {return Resolution_Levels;}

JP2_Encoder& resolution_levels (unsigned int resolution_levels);

unsigned int quality_layers () const
    {return Quality_Layers;}

JP2_Encoder& quality_layers (unsigned int quality_layers);

double bit_rate () const
    {return Bit_Rate;}

JP2_Encoder& bit_rate (double rate);

std::string progression_order () const
    {return Progression_Order;}

JP2_Encoder& progression_order (const std::string& progression);

const std::vector<Size_2D> precinct_sizes () const
{return Precinct_Sizes;}

const Size_2D precinct_size
    (unsigned int resolution_level = 0) const;

JP2_Encoder& precinct_sizes
    (const std::vector<Size_2D>& sizes);

JP2_Encoder& precinct_size
    (const Size_2D& size, unsigned int resolution_level = 0);

const Size_2D code_block_size () const
    {return Code_Block_Size;}

JP2_Encoder& code_block_size (const Size_2D& size);

JP2_Box::JP2_Box_List& added_boxes ()
    {return Added_Boxes;}

JP2_Encoder& add_box (JP2_Box* box);

bool remove_box (JP2_Box* box);

const unsigned char* producer_UUID () const
    {return Producer_UUID;}

JP2_Encoder& producer_UUID (const unsigned char* id);

std::string comment () const
    {return Comment;}

JP2_Encoder& comment (const std::string& text)
    {Comment = text; return *this;}

bool ready () const;

std::string reasons () const;

int needs () const;

JP2_Encoder_Error* encoder_error () const;
 
/*==============================================================================
    Encoder
*/
long long encode ();

void open ();

long long write_header ();

long long write_user_boxes ();

long long write_codestream ();

JP2_Encoder& incremental_flush_bytes (long long bytes)
    {Incremental_Flush_Bytes = ((bytes < 0) ? 0 : bytes); return *this;}

long long incremental_flush_bytes () const
    {return Incremental_Flush_Bytes;}

JP2_Encoder& incremental_flush_lines (unsigned int lines);

int incremental_flush_lines () const;
 
long long close ();
 
/*============================================================================
    Helpers:
*/
int
invalid_precinct_size (const std::vector<Size_2D>& sizes);
 
protected:

void read_stripe
    (std::istream& source, int band, int line, int lines, kdu_int16* buffer);

void read_stripe
    (std::istream& source, int band, int line, int lines, kdu_int32* buffer);
 
/*==============================================================================
    Data Members:
*/
protected:
//------------------------------------------------------------------------------
//  Input:

std::string
    Image_Source;

std::string
    JP2_Pathname;

std::streamoff
    Image_Offset;

unsigned int
    Image_Bands;
 
//  Dimensions of the image.
Size_2D
    Image_Size;

unsigned int
    Line_Prefix_Bytes,
    Line_Suffix_Bytes;

unsigned int
    Pixel_Bytes;

unsigned int
    Pixel_Bits;

bool
    Signed_Data;
 
//  JP2 boxes beyond the minimum required.
JP2_Box::JP2_Box_List
    Added_Boxes;
 
//------------------------------------------------------------------------------
//  Output:

std::string
    PDS_Label_Pathname;

unsigned char
    *Producer_UUID;

std::string
    Comment;

bool
    Swap_Pixel_Bytes;

unsigned int
    Resolution_Levels;
 
unsigned int
    Quality_Layers;
 
double
    Bit_Rate;

std::string
    Progression_Order;

Size_2D
    Tile_Size;

std::vector<Size_2D>
    Precinct_Sizes;

Size_2D
    Code_Block_Size;
 
long long
    Incremental_Flush_Bytes;
 
private:
//------------------------------------------------------------------------------
//  Kakadu classes used during JP2 file generation.

jp2_family_tgt
    *JP2_Stream;

jp2_target
    *JP2_Boxes;

kdu_codestream
    *JPEG2000_Codestream;

JP2_Encoder_Error
    *Encoder_Error;
 
};  //  Class JP2_Encoder
 
 
#ifndef DOXYGEN_PROCESSING
/*=*****************************************************************************
    JP2_Encoder_Error
*/
class JP2_Encoder_Error
:   public kdu_thread_safe_message
{
public:
 
void put_text (const char* message);
void add_text (const std::string& message);
void flush (bool end_of_message = false);
 
std::string
    Message;
};
#endif  //  DOXYGEN_PROCESSING
 
 
/*=*****************************************************************************
    Functions
*/
bool power_of_2 (unsigned int value);
 
 
}   //  namespace HiRISE
}   //  namespace UA
#endif