upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/tcd.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) 2002-2014, Universite catholique de Louvain (UCL), Belgium
  * Copyright (c) 2002-2014, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
@@ skipping 244 matching lines @@
 OPJ_BOOL opj_tcd_init(  opj_tcd_t *p_tcd,
                                                 opj_image_t * p_image,
                                                 opj_cp_t * p_cp );
 
 /**
  * Allocates memory for decoding a specific tile.
  *
  * @param       p_tcd           the tile decoder.
  * @param       p_tile_no       the index of the tile received in sequence. This not necessarily lead to the
  * tile at index p_tile_no.
+ * @param p_manager the event manager.
  *
  * @return      true if the remaining data is sufficient.
  */
-OPJ_BOOL opj_tcd_init_decode_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no);
+OPJ_BOOL opj_tcd_init_decode_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager);
 
 void opj_tcd_makelayer_fixed(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_UINT32 final);
 
 void opj_tcd_rateallocate_fixed(opj_tcd_t *tcd);
 
 void opj_tcd_makelayer( opj_tcd_t *tcd,
                                                 OPJ_UINT32 layno,
                                                 OPJ_FLOAT64 thresh,
                                                 OPJ_UINT32 final);
 
 OPJ_BOOL opj_tcd_rateallocate(  opj_tcd_t *tcd,
                                                                 OPJ_BYTE *dest,
                                                                 OPJ_UINT32 * p_data_written,
                                                                 OPJ_UINT32 len,
                                                                 opj_codestream_info_t *cstr_info);
 
 /**
  * Gets the maximum tile size that will be taken by the tile once decoded.
  */
 OPJ_UINT32 opj_tcd_get_decoded_tile_size (opj_tcd_t *p_tcd );
 
 /**
  * Encodes a tile from the raw image into the given buffer.
  * @param       p_tcd                   Tile Coder handle
  * @param       p_tile_no               Index of the tile to encode.
  * @param       p_dest                  Destination buffer
  * @param       p_data_written  pointer to an int that is incremented by the number of bytes really written on p_dest
  * @param       p_len                   Maximum length of the destination buffer
  * @param       p_cstr_info             Codestream information structure
- * @return  true if the coding is successfull.
+ * @return  true if the coding is successful.
 */
 OPJ_BOOL opj_tcd_encode_tile(   opj_tcd_t *p_tcd,
                                                             OPJ_UINT32 p_tile_no,
                                                             OPJ_BYTE *p_dest,
                                                             OPJ_UINT32 * p_data_written,
                                                             OPJ_UINT32 p_len,
                                                             struct opj_codestream_info *p_cstr_info);
 
 
 /**
 Decode a tile from a buffer into a raw image
 @param tcd TCD handle
 @param src Source buffer
 @param len Length of source buffer
 @param tileno Number that identifies one of the tiles to be decoded
 @param cstr_info  FIXME DOC
+@param manager the event manager.
 */
 OPJ_BOOL opj_tcd_decode_tile(   opj_tcd_t *tcd,
                                                             OPJ_BYTE *src,
                                                             OPJ_UINT32 len,
                                                             OPJ_UINT32 tileno,
-                                                            opj_codestream_index_t *cstr_info);
+                                                            opj_codestream_index_t *cstr_info,
+                                                            opj_event_mgr_t *manager);
 
 
 /**
  * Copies tile data from the system onto the given memory block.
  */
 OPJ_BOOL opj_tcd_update_tile_data (     opj_tcd_t *p_tcd,
                                                                     OPJ_BYTE * p_dest,
                                                                     OPJ_UINT32 p_dest_length );
 
 /**
  *
  */
 OPJ_UINT32 opj_tcd_get_encoded_tile_size ( opj_tcd_t *p_tcd );
 
 /**
  * Initialize the tile coder and may reuse some meory.
  *
  * @param       p_tcd           TCD handle.
  * @param       p_tile_no       current tile index to encode.
+ * @param p_manager the event manager.
  *
  * @return true if the encoding values could be set (false otherwise).
 */
 OPJ_BOOL opj_tcd_init_encode_tile (     opj_tcd_t *p_tcd,
-                                                                    OPJ_UINT32 p_tile_no );
+                                                                    OPJ_UINT32 p_tile_no, opj_event_mgr_t* p_manager );
 
 /**
  * Copies tile data from the given memory block onto the system.
  */
 OPJ_BOOL opj_tcd_copy_tile_data (opj_tcd_t *p_tcd,
                                  OPJ_BYTE * p_src,
                                  OPJ_UINT32 p_src_length );
 
 /**
  * Allocates tile component data
  *
  *
  */
 OPJ_BOOL opj_alloc_tile_component_data(opj_tcd_tilecomp_t *l_tilec);
 
 /* ----------------------------------------------------------------------- */
 /*@}*/
 
 /*@}*/
 
 #endif /* __TCD_H */