kdu_show.h

该源码是JPEG2000的c++源代码,希望对研究JPEG2000标准以及编解码的朋友们有用.

/******************************************************************************/
// File: kdu_show.h [scope = APPS/SHOW]
// Version: Kakadu, V2.2
// Author: David Taubman
// Last Revised: 20 June, 2001
/******************************************************************************/
// Copyright 2001, David Taubman, The University of New South Wales (UNSW)
// The copyright owner is Unisearch Ltd, Australia (commercial arm of UNSW)
// Neither this copyright statement, nor the licensing details below
// may be removed from this file or dissociated from its contents.
/******************************************************************************/
// Licensee: Book Owner
// License number: 99999
// The Licensee has been granted a NON-COMMERCIAL license to the contents of
// this source file, said Licensee being the owner of a copy of the book,
// "JPEG2000: Image Compression Fundamentals, Standards and Practice," by
// Taubman and Marcellin (Kluwer Academic Publishers, 2001).  A brief summary
// of the license appears below.  This summary is not to be relied upon in
// preference to the full text of the license agreement, which was accepted
// upon breaking the seal of the compact disc accompanying the above-mentioned
// book.
// 1. The Licensee has the right to Non-Commercial Use of the Kakadu software,
//    Version 2.2, including distribution of one or more Applications built
//    using the software, provided such distribution is not for financial
//    return.
// 2. The Licensee has the right to personal use of the Kakadu software,
//    Version 2.2.
// 3. The Licensee has the right to distribute Reusable Code (including
//    source code and dynamically or statically linked libraries) to a Third
//    Party, provided the Third Party possesses a license to use the Kakadu
//    software, Version 2.2, and provided such distribution is not for
//    financial return.
/*******************************************************************************
Description:
   Defines the main application object for the interactive JPEG2000 viewer,
"kdu_show".
*******************************************************************************/

#if !defined(AFX_KDU_SHOW_H__1AD132BD_D9F5_4FC6_8A43_3A7628C2BC92__INCLUDED_)
#define AFX_KDU_SHOW_H__1AD132BD_D9F5_4FC6_8A43_3A7628C2BC92__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"       // main symbols
#include "kdu_messaging.h"
#include "kdu_compressed.h"
#include "kdu_file_io.h"
#include "region_decompressor.h"
#include "MainFrm.h"

/////////////////////////////////////////////////////////////////////////////
// CKdu_showApp:
// See kdu_show.cpp for the implementation of this class
//

class CKdu_showApp : public CWinApp
{
public:
  CKdu_showApp();
  ~CKdu_showApp();

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CKdu_showApp)
	public:
	virtual BOOL InitInstance();
	virtual BOOL OnIdle(LONG lCount);
	//}}AFX_VIRTUAL

// Implementation

public:
	//{{AFX_MSG(CKdu_showApp)
	afx_msg void OnAppAbout();
	afx_msg void OnFileClose();
	afx_msg void OnUpdateFileClose(CCmdUI* pCmdUI);
	afx_msg void OnFileOpen();
	afx_msg void OnViewHflip();
	afx_msg void OnUpdateViewHflip(CCmdUI* pCmdUI);
	afx_msg void OnViewVflip();
	afx_msg void OnUpdateViewVflip(CCmdUI* pCmdUI);
	afx_msg void OnViewRotate();
	afx_msg void OnUpdateViewRotate(CCmdUI* pCmdUI);
	afx_msg void OnViewCounterRotate();
	afx_msg void OnUpdateViewCounterRotate(CCmdUI* pCmdUI);
	afx_msg void OnViewZoomOut();
	afx_msg void OnUpdateViewZoomOut(CCmdUI* pCmdUI);
	afx_msg void OnViewZoomIn();
	afx_msg void OnUpdateViewZoomIn(CCmdUI* pCmdUI);
	afx_msg void OnViewRestore();
	afx_msg void OnUpdateViewRestore(CCmdUI* pCmdUI);
	afx_msg void OnModeFast();
	afx_msg void OnUpdateModeFast(CCmdUI* pCmdUI);
	afx_msg void OnModeFussy();
	afx_msg void OnUpdateModeFussy(CCmdUI* pCmdUI);
	afx_msg void OnModeResilient();
	afx_msg void OnUpdateModeResilient(CCmdUI* pCmdUI);
	afx_msg void OnViewWiden();
	afx_msg void OnUpdateViewWiden(CCmdUI* pCmdUI);
	afx_msg void OnViewShrink();
	afx_msg void OnUpdateViewShrink(CCmdUI* pCmdUI);
	afx_msg void OnFileProperties();
	afx_msg void OnUpdateFileProperties(CCmdUI* pCmdUI);
	afx_msg void OnComponent1();
	afx_msg void OnUpdateComponent1(CCmdUI* pCmdUI);
	afx_msg void OnComponent2();
	afx_msg void OnUpdateComponent2(CCmdUI* pCmdUI);
	afx_msg void OnComponent3();
	afx_msg void OnUpdateComponent3(CCmdUI* pCmdUI);
	afx_msg void OnComponent4();
	afx_msg void OnUpdateComponent4(CCmdUI* pCmdUI);
	afx_msg void OnMultiComponent();
	afx_msg void OnUpdateMultiComponent(CCmdUI* pCmdUI);
	afx_msg void OnLayersLess();
	afx_msg void OnUpdateLayersLess(CCmdUI* pCmdUI);
	afx_msg void OnLayersMore();
	afx_msg void OnUpdateLayersMore(CCmdUI* pCmdUI);
	afx_msg void OnModeResilientSop();
	afx_msg void OnUpdateModeResilientSop(CCmdUI* pCmdUI);
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
// ----------------------------------------------------------------------------
public: // Access methods for use by the window objects
  void set_view_size(kdu_coords size);
    /* This function should be called whenever the client view window's
       dimensions may have changed.  The function should be called at least
       whenever the WM_SIZE message is received by the client view window.
       The current object expects to receive this message before it can begin
       processing a newly opened image.  If `size' defines a larger region
       than the currently loaded image, the actual `view_dims' region used
       for rendering purposes will be smaller than the client view window's
       dimensions. */
  void set_hscroll_pos(int pos, bool relative_to_last=false);
    /* Identifies a new left hand boundary position for the current view.
       If `relative_to_last' is true, the new position is expressed relative
       to the existing left hand view boundary.  Otherwise, the new position
       is expressed relative to the image origin. */
  void set_vscroll_pos(int rel_pos, bool relative_to_last=false);
    /* Same as `set_hscroll_pos', but for vertical scrolling. */
  void paint_region(CDC *dc, kdu_dims region);
    /* Paints a portion of the viewable region to the supplied device
       context.  The location identified by `region.loc' is expressed
       relative to the upper left hand corner of the current view region
       (stored in the private `view_dims' structure).  If the region is
       not completely contained inside the current view region, or no file
       has yet been loaded, the background white colour is painted into the
       entire region first, and then the portion which intersects with the
       current view region is painted.  This allows for the possibility that
       the client view region might be larger than the rendering view region
       (e.g., because the image is too small to occupy the minimum window
       size). */
  void open_file(char *filename);
private: // Private implementation functions
  void find_channel_mapping();
    /* Executed from within `open_file' to build the most appropriate
       association between colour channels and image components, depending
       on the file format and the component sub-sampling factors. */
  void configure_reference();
    /* Determines the reference component (the single image component if there
       is one, or else the component used to build the first colour channel).
       Also sets  the `min_expansion' factors to the minimum acceptable
       expansion factors for the reference component which will allow the
       expansion factors for all components to be integers.  The caller may
       need to modify the current `expansion' factors according to the
       `min_expansion' factors set here.
          You should call this function whenever the channel construction rules
       change -- e.g., opening a new file, or setting or resetting the
       `single_component' mode to display only one component. */
  void close_file();
  void initialize_regions();
    /* Called by `open_file' after successfully opening a new compressed
       image to prepare the image regions for subsequent interaction with
       `set_view_size' and other member functions. */
  void calculate_view_centre();
    /* Call this function to determine the centre of the current view relative
       to the entire image.  The function sets `view_centre_known' to true.
       The view centre coordinates are used by the next `set_view_size'
       call to position the image relative to the view.  The most common use
       of this function is to preserve (or modify) the view centre prior to a
       call to `initialize_regions'.  The `view_centre_known'
       flag is reset whenever the view changes in any way. */
  void update_buffer_pos(kdu_coords new_pos);
    /* Called on occasions when the image region represented by the
       memory buffer is shifted in some direction.  Since the buffer is
       somewhat larger than the viewable region, quite a bit of scrolling
       and window resizing can occur without the need to update the buffer
       position. */
  void update_valid_region();
    /* Call this whenever you do something which changes the `buffer_dims'
       region, to reflect the changes into the `valid_dims' region, which
       must always be a subset of the buffered region. */
  void calculate_max_discard_levels();
    /* Called when the user first tries to reduce the resolution of an
       image.  The function will do nothing if the code-stream is being
       used by a decompression engine. */
  void  display_quality_layer_status();
    /* Displays the number of quality layers used to generate the
       image in the status bar. */
public:
  CMainFrame *frame;
private: // Private state
  bool fast, fussy, resilient, resilient_sop;
  CChildView *child; // Null until the frame is created.
  kdu_simple_file_source file_input; // Created by `open_file'.
  jp2_source jp2_input; // Created by `open_file'.
  kdu_codestream codestream; // Created by `open_file'.
  bool tiles_loaded; // True once we know that all tiles have been loaded.
  bool transpose, vflip, hflip; // Current geometry flags.
  int discard_levels;
  int max_discard_levels; // Negative if not yet known.
  int max_display_layers;
  int total_components; // Total number in code-stream
  int single_component; // Negative when performing a composite rendering.
  kdr_channel_mapping channels; // Composite rendering details.
  int reference_component; // Either the `single_component' or the first channel
  kdu_coords min_expansion; // Min expansion factors for reference component
  kdu_coords expansion; // Expansion factors for reference component
  kdu_dims image_dims;
  kdu_dims buffer_dims;
  kdu_dims view_dims;
  kdu_dims valid_dims;
  float view_centre_x, view_centre_y;
  bool view_centre_known;
  kdu_byte *buffer;
  kdu_coords buffer_extent;
  kdr_region_decompressor decompressor;
  bool in_idle;
  bool processing;
  kdu_dims region_in_process;
  kdu_dims incomplete_region;
};
  /* Notes:
        The `buffer' array alway contains interleaved RGB values, in the
     order BGR.  It is used to build top-down DIB's for painting the display.
     Each row is capable of holding `buffer_extent.x' 3-byte pixels, where
     `buffer_extent.x' is guaranteed to be a multiple of 4.  The buffer is
     capable of holding `buffer_extent.y' rows.  Note that `buffer_extent'
     may be larger than `buffer_dims.size' or even `image_dims.size'.
        The various `kdu_dims' structures all identify the location and
     dimensions of their respective regions, as they appear in the rendering
     coordinate system.  The rendering coordinate system is derived from the
     coordinate system of the `reference_component' as it appears on the
     code-stream canvas, after taking component sub-sampling factors and
     geometric manipulations into account.  In particular, the locations
     occupied by the reference component's samples on the rendering coordinate
     system are obtained by multiplying the code-stream sample coordinates
     by the sampling factors contained in `expansion'.  On the rendering
     grid, the image region, maintained by `image_dims' is obtained by
     multiplying the upper left and lower right hand coordinates of the
     reference component region by the sampling factors in `expansion' and
     subtracting half of `expansion.x' and `expansion.y' from the resulting
     coordinates.  The reason for the expansion, is that we think of each of the
     reference component's samples as occupying `expansion.y' by `expansion.x'
     grid points on the rendering grid.
        The `buffer_dims' structure identifies the location and dimensions of
     the upper left hand portion of the `buffer' which is currently active.
     This is necessarily a subset of the `image_dims' region.  The `view_dims'
     region identifies the location and dimensions of the region represented
     by the current display view (the region painted into the client view
     window).  It is necessarily a subset of the `buffer_dims' region.
     The `valid_dims' structure identifies the location and dimensions of
     currently valid buffered data.  It is necessarily a subset of the
     `buffer_dims' region.
        The `in_idle' flag is asserted whilst decompression is taking place
     in an OnIdle call.  It is used as a precaution to prevent re-entrant
     processing in a recursive call to the OnIdle function, if a message
     processing loop is incarnated indirectly inside the first call.
        If `processing' is true, the `decompressor' object has
     been started and is processing a region of the buffer.  While this is
     going on, `incomplete_region' identifies the portion of the
     `region_in_process' which has not yet been completed.  Although
     `region_in_process' and `incomplete_region' are initially both identical
     to the region supplied to `kdr_region_decompressor::start', they are
     both intersected with the `buffer_dims' region whenever it
     changes in response to user resizing or scrolling commands.  If either
     or both windows become empty in the process, the current region
     processing operation should be finished.  It may also be finished if
     the processing region becomes too small to be worth continuing.  In any
     event, a partially or entirely completed region may be used to update
     `valid_dims' once the processing is finished. */
     
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_KDU_SHOW_H__1AD132BD_D9F5_4FC6_8A43_3A7628C2BC92__INCLUDED_)