This release is strongly focussed on mobile applications, providing just about all the enhancements one could wish for to build high quality mobile applications based on Kakadu. While not included with this release, we have developed an IOS application that does pretty much everything that kdu_macshow/kdu_winshow does, plus quite a bit more. This application is highly responsive even on older low-end iPhone/iPad devices and even when working with huge source images, animations, etc.
Here is a brief list of the enabling tools, which are part of the release:
1. ARM/NEON vector processing accelerators have now been extended to all aspects of Kakadu for which x86-based accelerations exist. This includes wavelet transforms, multi-component transforms, quantization, resampling, blending, compositing and a wide range of sample precision/range/clipping operations - while not specific to mobile applications, the x86-based accelerators have also received upgrades to AVX2 for most of these operations as well, including super-fast and highly disciplined resampling operations.
2. Interactive media communications via JPIP is especially important for mobile applications. With this in mind, this release provides a complete overhaul of the underlying `kdu_cache’ that stores incrementally communicated content from a JPIP server. Most significantly, the cache can now manage its total memory footprint, providing all the necessary machinery to support both explicit deletions of content and automatic evictions, while keeping a remote JPIP server informed of all changes that should affect its
cache model, in a just-in-time manner (i.e., the server only learns about changes relevant to the content that is actually being requested). The new cache handles long videos and animations much better and the automatic eviction procedure works seemlessly. The cache’s multi-threaded implementation is substantially more efficient than before, adopting a lockless model for the most common operations so that multiple readers/writers can interact with the cache while only occasionally needing to acquire exclusive
access to critical sections.
3. There are also a huge number of enhancements to the `kdu_client’ that sits on top of `kdu_cache’ to deliver JPIP interactivity. The client supports more functional cache files that can be opened directly and tranferred between applications or users in order to augment an experience outside the loop of a JPIP client-server connection. Cache files can now easily be endowed with a small preamble that is ideal for generating thumbnails or summary views for image-pickers and that allows rapid opening of a cache file, with background loading of the extra content running as if there were a server involved. The client supports various strategies for managing cache files so that private and recorded browsing modes can be easily swapped in and out. The client provides reconnection capability now, so that a previously lost connection can be re-established from any point.
Finally, the client provides much better handling for sources with a massive number of codestreams, such as video and complex animations.
4. The Kakadu core system provides a new `kdu_quality_limiter’ tool that provides a disciplined strategy for discarding coded data that will not impact the visual appearance of rendered content at a given scale. This tool uses disciplined visual optimization principles, automatically folding in all relevant features of the spatial and multi-component transforms, estimating opponent properties of colour spaces and exploiting knowledge of the current viewing resolution. It should work across all possible JPEG2000 transforms (spatial and multi-component) and it is easy to drive from an application — one needs only to provide an overall quality number (that is related to visually weighted error) and an estimate of the display resolution that is being driven. The tool can provide very substantial acceleration when rendering high resolution or lossless content at reduced resolutions. The tool is especially well adapted to retina displays, whose extreme resolution further reduces the visibility of much of the data that might have been encoded. Of course, as one zooms into the content, the quality limiter’s effect disappears but that is exactly the right behaviour. The tool’s default behaviour is to leave
reversibly compressed (usually lossless) content alone when rendered at full scale, but at other scales it can provide substantial acceleration. This new quality-limiting feature is made available through a convenient interface within each major rendering API offered by Kakadu, from the low-level `kdu_codestream’ interface, all the way up to the `kdu_region_decompressor’ and `kdu_region_compositor’ interfaces, where all aspect of the current resampling and re-orientation operations implemented by
these interfaces are taken into account.
5. The `kdu_region_compositor’ object has been endowed with an expanded concept of “scale”. The `set_scale’ funtion now takes both a “notional scale”, and an optional adjustment to this notional scale that represents a current “renderng scale”. This makes it extremely easy to render content at a reduced resolution, while all aspects of the rendered content, its dimensions and interaction with metadata, animations and JPIP services, reflect the notional scale. Composited buffers now carry around these two scales and their associated dimensions so that components of an application that present content to a display (or upload to texture units) can readily rescale the rendered content back to its notional scale. The intent, of course, is to support the common image rendering modality found on mobile devices, where content is immediately presented at a coarse scale to maximize responsiveness, after which a detailed version overwrites the coarse one. Unlike JPEG-based image rendering, with JPEG2000 any pair of scales can be used
and this can be optimized for the device (e.g., standard resolution first, overwritten by retina resolution a short while later). The changes to `kdu_region_compositor’ are entirely transparent to those who do not need this feature, while there are very few changes indeed required to take full advantage of it in an application.
6. In addition to the above, this release contains quite a few bug fixes and minor enhancements in many areas. A few of the bug fixes are very signficant. For example, there was a significant flaw discovered in the resampling code within `kdu_region_decompressor’ and used by `kdu_region_compositor’ that is likely to have reduced the visual quality of a wide range of rendering applications. We strongly recommend all licensees to upgrade to this new release.