Selected Features Ver 5.2.5:
Implemented in C++; all interaction between the core system and the application is conducted over well-defined interfaces.
Core system and most application-specific objects are entirely platform independent. Platform dependencies appear only in demo applications which require networking or graphical user interfaces.
Implements:-
- all aspects of the JPEG2000 standard, Part 1, including the optional JP2 file format, the current corrigendum items and all ammendments.
- virtually all aspects of the JPX file format from Part 2 of the standard, including fragmented and externally linked codestreams.
- the MJ2 file format, corresponding to Part 3 of the standard.
- many coding technology features from Part 2 of the standard, including multi-component transforms and arbitrary wavelet kernels.
Provides:-
- a commercially deployable implementation of Part 9 of the standard (JPIP) for client/server applications.
- applications with an abstract view of the image represented by the underlying code-stream, transparently managing geometric transformations, as well as the resolution and spatial region of interest to the application.
Features:
Particularly efficient memory structures for frequently used state information. Memory resources are always created as late as possible and cleaned up as early as possible.
Consumes compressed input on demand, utilizing all available random access information.
Able to generate compressed output incrementally, with incremental rate control applied as necessary.
Particularly efficient implementation of the embedded block coding algorithm and wavelet transform yields higher processing throughput than existing implementations of which we are aware.
Implements heuristics for reducing the amount of compressed data which is generated and stored prior to rate allocation, based upon a known target bit-rate and incrementally computed statistics.
The heuristic algorithm is highly unlikely to produce any significant quality degradations, as of Version 4.0. able to perform a large number of compressed domain manipulations.
Automatic documentation and managed interface builder creates extensive hyperlinked documentation, plus a full set of Java interfaces to the public API classes and functions, and a corresponding set of interface bindings for C# and Visual Basic programmers.
Automatic platform independent language resource builder, which may be easily used to fully internationalize all text messages generated by the Kakadu core system and any of its higher level supporting APIs.
Extensive support for interactive client-server applications, implementing almost all features of the JPIP protocol, current with the Final Committee Draft (FCD) released after the December 2003 meeting of the JPIP (Jpeg2000 Internet Protocols) working group within ISO/IEC JTC1/SC29/WG1 (i.e., the JPEG group).
Extensive support for multi-threaded processing, to leverage available parallel processing resources (multiple CPUs, multi-core CPUs or hyperthreading CPUs) with next to no impact on the application programming model.
There is also a focus on providing powerful high level objects, which dramatically simplify the interfacing of Kakadu to existing applications, as well as assisting with the development of entirely new applications.
New to Kakadu Version 5.2
- The "kdu_hyperdoc" tool now builds a richer set of Java native interface bindings and now also builds a corresponding set of C# and Visual Basic language bindings.? There are now two Java example applications and two corresponding C# example applications.? Moreover, "kdu_hyperdoc" can be instructed (via the new "-bind") argument to limit its bindings to specific classes, global functions or even class member functions, for minimally sized interfaces.
- There is new set of MMX/SSE/SSE2 implementations which use processor intrinsics.? These can be compiled from both GCC and .NET and can target both 32-bit and 64-bit builds on all X86 platforms.? The older hand optimized versions of the SIMD processor speedups for X86 platforms and other platforms (Sparc and PowerPC) still exist and are used where appropriate by the compilation logic.? However, the presence of the new more-generic implementations allows more speedups across all platforms.? This also overcomes a previous limitation where there were no speedups available for Win64 builds under .NET, even though the speedups were available for 64-bit Linux builds.? The "Compilation_Instructions.txt" file has been updated to provide a more accessible and complete description of the various build environments and compilation options.
- Support for TIFF file reading and writing by the demo applications, "kdu_compress" and "kdu_expand", has been enhanced to include the following: 1) Reading of just about any TIFF format, including tiled and planar organizations, arbitrary bit-depths (including floating point samples); 2) Reading and appropriate usage of colour space and alpha component information embedded in TIFF files (including CMYK spaces); 3) More comprehensive support for writing of TIFF colour spaces (including CMYK) and alpha channels.? As in the last release, Kakadu provides its own native TIFF structure parsing/editing object, so you only need to include the public domain LIBTIFF package when building ?kdu_compress? if you need to read compressed TIFF files ? you do this by defining KDU_INCLUDE_TIFF, as always.
- The `kdu_region_decompressor' and `kdu_region_compositor' objects, which are used for most rendering applications, have been upgraded to properly handle pre-multiplied opacity (associated alpha), where previously only the more generic opacity (unassociated alpha) was handled.? This means that practically any reasonable (or unreasonable) JPX composition or animation will be correctly rendered.
- Quite a number of minor bugs have been fixed, virtually all of which were accidentally introduced by the sweeping changes that have been witnessed in the last few releases to enable increased efficiency, multi-threading and Part 2 coding features.? Due to the large base of Kakadu users, it is likely that we are now near the end of the bug discovery phase, making this the cleanest and most functional Kakadu release yet.
New to Kakadu Version 5.1
- By far the most important new feature in v5.1 is the provision of extensive support for multi-threading, so as to fully leverage the processing resources available on platforms with multiple CPU's, multi-core CPU's and/or hyperthreading CPU's.? All of the high level sample processing objects provide simple mechanisms to include the processing resources offered by a `kdu_thread_env' object, which you are free to create and augment with working threads, using.? Kakadu also provides you with assistance in determining the optimum number of threads to create.? For many applications, upgrading from the original single-threaded processing model to multi-threaded processing requires only a few lines of code.? This is demonstrated by most of the demo applications, which can be run in either single-threaded or multi-threaded modes.? Kakadu?s multi-threading framework involves a carefully engineered thread scheduler to extract as much as possible from the available processing resources.? If necessary, the amount of double buffering employed at the code-block level and at the tile-component level can be adjusted so as to trade memory for parallelism.
- Added new `push_stripe' and `pull_stripe' interface functions to the `kdu_stripe_compressor' and `kdu_stripe_decompressor' objects, espectively, to support 32-bit integer and floating point image sample values, in addition to the existing 8- and 16-bit precision interfaces.? These additional interfaces ensure that the high level stripe-oriented objects support all of the data precisions that are supported by the underlying core Kakadu system.
- Added the Digital Cinema profiles (CINEMA2K and CINEMA4K) to the list of profiles recognized in the codestream SIZ marker segment.? These profiles were added about a year ago as an ammendment to Part 1 of the JPEG2000 standard.
- Added significant support for TIFF and GeoTIFF image I/O to "kdu_compress" and "kdu_expand".? Even though image I/O is not really part of the scope of Kakadu, it is required for demonstration purposes and lack of comprehensive TIFF support has been a source of concern for some new users.? This has been complicated by the fact that GeoJP2 files include a JP2 box which is really an encapsulated TIFF file.? To solve both problems in one go, this new release of Kakadu comes with a simple yet general native TIFF parser/creater, which is not based on any external libraries and integrates well with the other abstract I/O services endemic to Kakadu.?? As a result, TIFF files can now be read and written by the "kdu_compress" and "kdu_exand" demo applications without the need to link against LIBTIFF (as before).? GeoTIFF tags are also extracted by "kdu_compress" and used to create a GeoJP2 box if appropriate.? GeoJP2 boxes may be unpacked (if required) and/or written back to GeoTIFF files by "kdu_expand".? The new `kdu_tiffdir' object may be used to create/unpack TIFF directories in any file or embedded within any JP2 box.? This is useful both for GeoTIFF applications and also for handling JP2-family files which might contain embedded raw imagery.
- Quite a number of minor bugs have been fixed (all reported bugs, to the best of my knowledge).? The most significant bug fix is probably a minor error in the Altivec speedup code for PowerPC platforms, which sometimes caused erroneous decoding of the first few columns when decompressing a restricted region inside the image.? For a more comprehensive list of bug fixes and added features, see the usual "Updates.txt" document which ships with Kakadu licenses.
New to Kakadu Version 5.0
This is a very major upgrade.? The most significant changes relate to support for features of Part-2 of the JPEG2000 standard.? At the same time, considerable effort has been devoted to improving the efficiency and memory utilization in critical portions of the core system.? This new version contains something for just about every user of Kakadu, from significantly more efficient video rendering (through `kdu_region_compositor') to efficient interactive inspection of medical volumes compressed using multi-component transforms.? A variety of minor bugs and quirks have also been fixed.? Here is a brief list of the main new features:
- Four new dead-easy demo code fragments are implemented inside the "kdu_render" demo app, to get you up and running as quickly as possible, or give you one-line solutions to decompression/rendering problems for any raw codestream, JP2 file, JPX file, MJ2 frame or JPX animation frame.? These serve as a good entry point to the much richer set of features offered by Kakadu rendering tools.
- Fully supports Part-2 arbitrary transform kernels, allowing user defined DWT kernels.
- Fully supports Part-2 arbitrary decomposition styles, including wavelet packet decomposition structures, and unbalanced sub-sampling structures in which successive resolution levels might have identical horizontal dimensions or identical vertical dimensions.
- Fully supports Part-2 multi-component transforms, including arbitrary combinations of matrix-based decorrelation transforms, dependency transforms and multi-component DWT transforms, with arbitrary transform kernels.? Both reversible and irreversible transform operators are fully supported.? Apart from constraints which were most likely accidentally omitted from the standard, Kakadu imposes no unreasonable constraints on the full generality of multi-component transform structures supported by Part 2.? However, the possibilities are so rich that it may take considerable time to fully utilize these features.
- Now uses correct Part-2 syntax to write codestreams which use the alternate code-block alignment required for compressed-domain rotation (as performed by "kdu_transcode" for example) ? previous versions included this only as an experimental feature, without correct Part-2 marker segment syntax.
- Improvements to platform-dependent speedups allow throughput increases of around 20% at low to moderate bit-rates on Pentium-4 platforms.? The Altivec implementation (Power PC vector processor) now also works correctly under all conditions, including region-of-interest decompression.? Speedups have been extended to arbitrary wavelet transform kernels and also to inter-component wavelet transforms, as they may appear in a Part-2 multi-component transform.
- Included fixes supplied by a 3'rd part to the way in which "kdu_hyperdoc" generates Java (JNI) interfaces to Kakadu.? These fixes avoid some rare race conditions which could previously occur in multi-threaded Java applications using Kakadu.
New to Kakadu Version 4.5
- Support for rendering, scaling, rotating and compositing Motion JPEG2000 video tracks has been added to the platform independent `kdu_region_compositor' object, from which you can build common rendering services for a huge range of JPEG2000-based sources (RAW, JP2, JPX, MJ2, JPIP).
- Video playback of Motion JPEG2000 tracks and JPX animations has been added to the ?kdu_show? demo application.
- The ?kdu_merge? demo application has been extended to allow creation of single or multi-track MJ2 files by merging still images (JP2/JPX) and/or existing MJ2 video tracks.? This also provides a back route to creating your own VIX files for testing ?kdu_v_compress? ? you can merge some still images into an MJ2 track and then decompress it into a VIX file.
- Replaced nearest-neighbour interpolation with an efficient bilinear interpolation for the case where `kdu_region_decompressor' is required to use non-integer rational expansion factors.? This improves the viewing experience in "kdu_show" (or more generally any application built on `kdu_region_compositor') when working with complex composited imagery, where all composition layers cannot simultaneously be rendered at a native size.
- Kakadu now provides everything needed to internationalize or otherwise customize all of the text printed by error or warning messages.? This is done in a manner which is platform independent and fully compatible with earlier usage of the `kdu_error' and `kdu_warning' services.? All original text is kept in the source files in essentially the same way as before, but may optionally be compiled out so as to rely upon a text registry.? A new tool, "kdu_text_extractor" is provided to automatically generate separate source files which can be included in the target application to register all the original text which is compiled out in this way.? You can then create new versions of these generated files with translated (partially or fully) or otherwise customized versions of the text.? Translations can use UTF-8 or UTF-16 (Unicode) character sets, or any mixture of the two.? The textual aspects of all re-usable components (i.e., everything except demo code) has been prepared for extraction and translation using these tools.
New to Kakadu Version 4.4
- Support for arbitrary scaling factors has been introduced into `kdu_region_decompressor' and `kdu_region_compositor'.? This means that you can compose, colour transform and alpha blend codestream image components which have arbitrarily related sizes.? This is specifically required to fully support the JPX file format.
- New facilities to derive region-based progress information for JPIP remote browsing applications -- demonstrated by a new progress indicator in "kdu_show" when used for JPIP browsing.
- Full support for fragmented and linked codestreams, represented by JPX fragment table boxes.? Amongst other things, this allows codestream data to be stored in a different file to that which describes a JPX composition or animation.? Useful for creating presentations, albums, etc. while keeping original content separately from the presentation file.? Such files are correctly handled by all Kakadu demo applications and the changes required to bring this support into existing applications are either nil or minuscule (at most one changed function call and renaming one class in the worst case).? Presentations with externally linked codestreams are correctly distributed by the "kdu_server" tool using efficient JPIP streaming equivalents.
- MMX speedups for Linux are now implemented via GCC inline code rather than external assembly files.? This should solve compilation difficulties which were encountered with some combinations of GCC and GAS versions.? It also makes things much more readable.
New to Kakadu Version 4.3
- The most significant innovations in v4.3 relate to the handling of massive tiled images, both for compression and decompression.? The improvements extend Kakadu's ability to handle large images well beyond the Tera-pixel boundary.
Extends the automatic internal cache management system to automatically swap whole tiles in and out of memory, based on cache thresholds set by the application.? This prevents memory growth in applications which require persistent codestream access (to render the stream from multiple points of view), even when there is no PLT (packet-length) pointer information, subject to the presence of tiling.? This means that codestreams with contain either multiple tiles or addressable precincts, or both, can now be efficiently manipulated.? Applications can obtain the advantages of the new more efficient cache management without any changes at all.
?Typical? tile structures are now recycled internally to the codestream management system, so that the cost of tile instantiation within the codestream management system is substantially reduced, for applications which need to render a massive number of tiles at very low resolution (where the effective tile size can become very small).
The core codestream generation machinery can now generate TLM (tile-part-length) marker segments itself, obviating the need for a separate post-processing of the generated codestream with "kdu_maketlm".? Most importantly, this functionality even works when codestreams are generated in fragments (see next point).
The core codestream generation machinery can now compress tiled images in fragments, where each fragment is compressed independently and can consist of any subset of the tiles from the full codestream.?? Fragments are automatically stitched together and a correct set of TLM marker segments can be generated for the entire codestream, by selectively rewriting segments of the main header.? These features are demonstrated by the new `-frag' argument to the "kdu_compress" demo utility (see "Usage_Examples.txt"), but they have more general application; for example, by clever construction of an appropriate `kdu_compressed_target' object, you can arrange to compress fragments concurrently (e.g., to leverage a multi-CPU architecture) rather than sequentially, as is done by "kdu_compress".
- The `kdu_region_decompressor::process' functions now provide a great deal more flexibility in the way the dynamic range and signed/unsigned attributes of the rendered sample values can be configured.
- The JPX file format reader can now read JPX files which were mistakenly written without a reader requirements box (earlier Algovision writers did this).
- Modified the JPIP client/server implementation to allow more extensive re-use of TCP transport channels; the channel no longer needs to be closed down at the end of a JPIP session, so it can be re-used in an immediately following session ? this allows more efficient disconnect/reconnect cycling and avoids creating the appearance of a denial of service attach in such cases.
- Fixed a number of bugs in Kakadu's JPIP server implementation, in ROI generation (bug was created accidentally in v4.2) and in the conversion of more exotic JPX colour spaces, such as CIE-Lab.
New to Kakadu Version 4.2.1
- This is primarily a bug-fix version.? Bugs have been fixed in the TIFF code contributed by a third party, in the client and server implementations, and in a number of other reasonably obscure places.? This version corrects a typo in the box signature used for MJ2 files, but still reads MJ2 files which use the old invalid signature as well.
New to Kakadu Version 4.2
- JPIP client-server components extended to fully support JPX:
Efficient interactive remote browsing of complex JPX images with any number of compositing layers, codestreams and animation frames, with different scale factors, cropping and placement.
Efficient delivery of all metadata (text labels, XML, etc.) which is relevant to the current view window, while avoiding the delivery of any metadata which is not relevant.? Employs a useful sequencing heuristic to interleave the delivery of spatially sensitive metadata with imagery, in a manner which depends on the apparent size of the region to which the metadata applies, at the current viewing resolution.
- Dramatic speedups for heavily tiled images:
This is achieved by changing the internal implementation of `kdu_params' to avoid linear list searching and allocation of storage for redundant parameters.? Images with a very large number of tiles can now be compressed and decompressed much faster, with speedup factors of more than 10 in some cases.? In this way, the compression and decompression times for tiled images are now substantially the same as for untiled images, except for very small tile sizes (e.g., smaller than 256x256).
- SIMD speed-ups for the UltraSparc (VIS instruction set) and the PowerPC (Altivec instruction set), to mirror the wavelet and colour transform speedups previously only available for Intel processors (MMX instruction set).? The Altivec code was originally contributed by Monroe Williams.
New to Kakadu Version 4.1
- A fist full of new features, mostly focused on the introduction of extensive support for the JPX file format.? JPX is an extended file format which allows multiple codestreams, composited images, animation, rich colour descriptions and rich metadata associations.? As an extension of JP2, Kakadu?s JPX reader is able to read both JP2 and JPX files.? It is also designed from the ground up with interactive remote image browsing in mind. This means that the JPX features integrate almost seamlessly with the JPIP client-server architecture.? The only respect in which this integration is not yet seamless is that efficient delivery of certain advanced JPX image compositions requires a JPX aware JPIP server and we have not yet gotten around to making the server specifically JPX aware.? This is in part due to the unanticipated need for some small changes to the JPIP standard which are being proposed at the December 2003 JPEG meeting in Hawaii.
- Kakadu is able to read and write all aspects of virtually all interesting JPX files, excepting fragment tables and cross reference boxes, for which support will be added next time around).? Full support is provided for:
multiple codestreams;
multiple compositing layers;
complex compositions and animations;
all the JPX enumerated colour spaces;
unrestricted ICC profiles;
complex colour conversion with application-controllable quality/complexity/gamut tradeoffs; and
extensive and efficient metadata management facilities through a scale-space hierarchy.
- A new, very powerful high level object, `kdu_region_compositor'.? This object absorbs virtually all of the non-GUI related machinery of "kdu_show" into a platform-independent component, while adding a great deal more functionality.? The object provides:
image composition;
animations;
efficient alpha blending;
interactive roaming within the image, with minimal recourse to decompression of new content as it enters the picture;
scaling, rotation, zooming, etc.;
metadata overlays (customizable by the application); and
efficient context-dependent metadata searches
- A new tool, "kdu_merge", for creating rich JPX content by merging, recombining and referencing contents from existing JP2, JPX or MJ2 files.? The tool allows:
insertion of one or more video clips together with static images;
compositing (e.g., by alpha blending) of imagery (or video) over backgrounds (any number of composited layers);
creation of custom compositing layers involving up to two codestreams each ? e.g., alpha may be taken from a different codestream to the colour channels.
- Many new features for "kdu_show", building upon the capabilities of the new `kdu_region_compositor' object.? New features include:
navigation through complex JPX files;
metadata editing;
metadata overlays for region-sensitive metadata, including dynamic text labeling;
the ability to save both JP2 and JPX files.
- A number of minor bug fixes and interface enhancements (see the usual "Updates.txt" log which comes with the license).
New to Kakadu Version 4.0.3
- Mostly minor fixes and enhancements, including updates to the client-server implementation to reflect changes in the JPIP standard.
New to Kakadu Version 4.0.2
- Improved parsing logic for tiles and tile-parts, which can dramatically reduce the time and memory taken to decompress large tiled images at reduced resolutions or reduced quality.
New to Kakadu Version 4.0
- The most significant changes in Version 4.0 relate to support for the new JPIP standard (JPEG2000, Part 9), which is currently at CD (Committee Draft) status.
JPIP is JPEG2000's standard for interactive image dissemination over the internet, including the dissemination of files with multiple code-streams and complex meta-data.? A detailed public description of the JPIP standard is not yet available, but some pointers may be found here.
In order to offer a comprehensive services in support of JPIP, Kakadu's JP2 file format architecture as been completely revamped to provide a hierarchical family of objects which allow for JP2 family file format parsers to remain completely oblivious to whether a file is local or being served remotely by a dynamic JPIP server.
Although fully derived instances of this architecture are currently provided only for raw code-streams and the JP2 file format itself, almost all the effort required to fully support dynamic user-sensitive delivery and processing of other JP2 family file formats has already been made.? Version 4.1 is expected to provide a complete solution for JPX and a complete solution for interactive delivery of MJ2 (motion JPEG2000) content should also follow shortly.?
Meanwhile, there are many immediate benefits, including the ability to include, service and process arbitrary application-defined additional boxes within JP2 files.? The "kdu_show" utility comes with a meta-data viewer (use the `m' accelerator of the view menu to activate it) which demonstrates the incremental appearance of meta-data at the client in the midst of a JPIP interactive session.? There are various ways to control such delivery, e.g. by explicitly specifying a "metareq" request field in the URL used to access a remote image, but for the moment these features are mainly for testing JPIP support and the integrity of the underlying architecture.
- Version 4.0 now includes a collection of three powerful high level objects designed to dramatically simplify the development of applications based on Kakadu.
The first such object, `kdu_region_decompressor', is a revamped version of the old `kdr_region_decompressor' object which was used to implement "kdu_show" and was also a popular tool for application developers.? The new version supports the management of additional channels (including alpha channels) along with the imagery, along with a rich set of memory buffer organizations and data precisions, which should satisfy the needs of virtually all interactive imaging applications.
The other two support objects, `kdu_stripe_compressor' and `kdu_stripe_decompressor' dramatically simplify the implementation of memory-resident compression and decompression applications.? Again, they provide support for a rich set of memory buffer organizations and data precisions.? A single function call can compress an image residing in memory, or decompress an image into a memory buffer.? More usefully, however, the application can compress or decompress images incrementally in stripes, based on buffers which suit the application?s needs.? The objects even provide educated recommendations on the best stripe configurations to use, keeping application-specific code to a bare minimum.
These objects are now used to make the ?simple_example_c" and "simple_example_d" applications significantly simpler again.? They are also demonstrated by two new example applications, "kdu_buffered_compress" and "kdu_buffered_expand" which serve to bridge the gap between the very simple demonstrations and the much more complex "kdu_compress" and "kdu_expand" examples.
- Amongst other matters, the documentation has been updated, all bugs reported to date have been fixed, and the block truncation prediction algorithm has been made a great deal more robust than it was before, without sacrificing the speed improvements for which it has been responsible.
New to Kakadu Version 3.4
- The most significant change in v3.4 is support for incremental code-stream flushing.? This long overdue feature enables compressed data to be flushed periodically to the final code-stream so that it does not need to be stored in memory.? Previous versions required all compressed data to be stored in memory until the image was completely processed.? The kdu_codestream::flush function may now be called as frequently as required, while the image is being compressed.? Of course, for this to be of any benefit, you must select a code-stream progression order which is consistent with incremental flushing.? The new feature is extensively documented in the description of the kdu_codestream::flush function.
- GCC builds now offer the same support as MSVC builds for huge files, having compressed sizes ranging into the Terabytes.
New to Kakadu Version 3.3
- The most significant change in v3.3 is the introduction of a completely new set of client-server objects.
The new objects implement our proposal for the JPIP (JPeg2000 Internet Protocols) standardization effort, in a form which is compatible with the most recent working draft produced by ISO/IEC JTC1/SC29/WG1's JPIP standardization effort, destined to become Part 9 of the JPEG2000 family of standards. The new protocol shares many elements in common with the original JPIK protocol implemented by the earlier client-server files, but there are a large number of important differences. Most significantly, the new protocol supports pure HTTP transport, as well as a more efficient TCP variant, together with more flexible cache management.
The new client-server implementation offers file-based caching of data received by a client in a previous interactive session, as well as both session-oriented and session-less communications. The server implementation now also includes a rate-distortion optimization element which takes information generated during compression, together with the client's window of interest, and uses this information to sequence information in an order which will increase the quality of the received image, within the window of interest, as fast as possible. Preliminary experiments indicate that the R-D optimal sequencing algorithm improves image PSNR by up to 8dB, when compared to the non-optimal sequencing employed by the earlier "kdu_server" implementation, after receiving the same amount of data.
Read more about the Kakadu JPIP implementation
o Note that this document is current with Kakadu v3.3, not the latest release.
- All known bugs have been fixed (we have a very large user-base now to report bugs).
New to Kakadu Version 3.2
- Automatic tools for building a full set of Java native interfaces, granting efficient access to virtually every aspect of the Kakadu system from Java applications. Since Kakadu is designed to be platform independent in its implementation (of course, you still need to compile binaries for the platform of interest), the availability of Java interfaces allows inherently platorm dependent tasks such as GUI's and networking to be abstracted nicely. An example of this is given. To get the Java interfaces and the tools used to build compatible interfaces to your own objects based on Kakadu, you need to get a license, but you can read more about Java interfaces in Kakadu here.
- Fixed a couple of trivial, yet important bugs accidentally introduced with into Version 3.1.
New to Kakadu Version 3.1
- The principle enhancement in this version is significantly improved support for video compression applications. Compression is frame-by-frame, as dictated by the Motion JPEG2000 file format (this is now supported by Kakadu), so no motion or inter-frame redundancy is exploited. The new version incorporates a number of efficiency improvements for compression and decompression of image sequences.
- Three new demonstration applications are provided: two for image sequences; and one to demonstrate full rendering of JP2 files to correctly interpolated and colour corrected sRGB output, in a platform independent application. As with all of the demonstration applications, executables are available freely, but the principle intent is to provide developers a starting point for their own applications.
New to Kakadu Version 3.0.8
- Apart from a number of minor bug fixes, the main addition in V3.0.8 is a tightly integrated documentation system, which brings together the many scattered sources of Kakadu documentation into an extensively hyperlinked and indexed set of HTML documents (there are currently more than 500 HTML pages, accessed through a convenient frames-based front end). The documentation embedded in the publically includable header files has been reworked to ensure that it provides as much information as possible and adheres to a set of conventions used to create high quality HTML pages. Kakadu now incorporates so many rich features, that this documentation system should prove indispensible to the serious developer.
New to Kakadu Version 3.0
- This is a major new version, with many new features, achieving most of the original goals underlying the Kakadu architecture.
- Amongst numerous minor improvements, the following major new features stand out:
Support for very large images, including images whose compressed size is larger than 2^32 bytes! New features include the random access into the compressed code-stream, on-demand loading and unloading of compressed data from memory, based on a customizable caching strategy, and the selective introduction of 64-bit data types.
Core system support for client-server applications. Amongst the new features here are caching compressed data sources and the ability to directly assemble JPEG2000 code-stream packets in any order for delivery to clients on the basis of their region of interest.
A comprehensive demonstration of client-server capabilities. The new application, "kdu_server", implements a connection-oriented protocol, known as JPIK, enabling any valid JPEG2000 data source to be efficiently served to a remote client over the internet. Supports multiple clients and multiple sources with a TCP-friendly flow control policy. Delivers only the data which is relevant to the client's current region and resolution of interest, automatically transcoding the source code-stream on the fly into one with small precincts. The server offers remote administration and host delegation facilities to allow a very large number of clients to be served simultaneously. The "kdu_show" application is now also a fully fledged remote browsing client for the JPIK protocol.
Find out more about the JPIK protocol.
New to Kakadu Version 2.2
- Extensive support for ROI (Region of Interest) encoding, including both max-shift and distortion weighting methods and the ability to specify regions of interest using either a simple geometric description, or an auxiliary mask image. In the latter case, the mask image is thresholded and automatically scaled to match the dimensions of each image component undergoing region of interest encoding. Like the rest of the Kakadu package, all processing is performed incrementally to efficiently utilize memory resources. The mechanisms provided by Kakadu to support ROI encoding should be easily extended to accommodate interactive applications (e.g., a radiologist marking up medical images with regions deserving special attention).
- MMX optimizations implemented under both Microsoft Visual C++ and gcc -- Linux versions of the demo executables now incorporate these optimizations.
- Upgraded to the new ANSI C++ standard I/O package. This improves namespace protection and standardization across multiple platforms, but take note that versions of gcc prior to version 3.0 do not support the standard in this regard. The demo executables were all compiled under gcc version 3.0 without errors or warnings. Same is true of Microsoft Visual C++.
- Various minor bug fixes and incidental improvements.
New to Kakadu Version 2.1
- Full support for the optional JP2 file format, including all channel mapping, interpolation, registration and colour transformation operations required by conforming JP2 readers. You can now drag and drop JP2 files directly onto the "kdu_show" application. You can also create interesting embedded ICC profiles directly using "kdu_compress".
- Improved automatic layering during compression, including the ability to control quality layer construction directly through rate-distortion slope thresholds.
- Substantially improved documentation and additional examples to guide the developer in working with Kakadu.
- Optimal BIBO (Bounded-In-Bounded-Out) analysis used to maximize dynamic range utilization in fixed point wavelet transform processing path.
New to Kakadu Version 2.0
- Minor changes to the architecture to fully separate the functionality of the core Kakadu system from application-specific elements.
- Core Kakadu system wrapped up in a DLL (or any other form of static or dyanamically linked library) whose interfaces should remain stable as features are added in the future. All source code and build environments are still supplied with licenses.
- Demo applications now shipped with the core "kdu_v20R" DLL which fully supports both interactive and non-interactive types of applications.
New to Kakadu Version 1.2
- Up to 50% higher decompression throughput than version 1.1 (improvement largest for colour images). Version 1.1 itself had substantially higher throughput than the VM, Jasper and JJ2000.
- Data processing uses either 16- or 32-bit, fixed or floating-point representations, depending on the task at hand. Two different fixed-point processing strategies are demonstrated in the code.
- You can now extract, reconstruct or interactively select individual image components from a code-stream.
- You can now interactively select the number of quality layers used to reconstruct images within the "kdu_show" application.
