| 2026-04-06 Alex Tutubalin <lexa@lexa.ru> |
| LibRaw 0.22.1 Release |
| This is bugfix-only release with these commits included: |
| |
| * Limit strcat space in hassy model manipulation |
| * Version increment; shlib increment: internal ABI has changed |
| * check panasonic enc8 tile width against image width |
| * CR3 parser: zero all buffers before fread |
| * skip memory allocation checks for OWN_ALLOC decoders |
| * DNG SDK glue: check for memory limits |
| * raw2image()/dcraw_process() - check for int16 source data present |
| * Check for correct bayer pattern, pass incorect ones to vng_interpolate |
| * parse_rollei: zero input string before fgets |
| * Nikon padded/12bit: no need to calculate padded row size before final raw_width adjustment |
| * TALOS-2026-2364: Fix for data size calculation integer overflow in float/deflated DNG loader; Check for read results |
| * Fix for TALOS-2026-2363: avoid integer overflow in allocation size calculation. Also: check for EOF in read loop |
| * X3F decoder: implemented hard single allocation limit via LIBRAW_X3F_ALLOC_LIMIT_MB define; |
| allocation size calculation converted to 64 bit arithm; fix for TALOS-2026-2359 |
| * Fix for TALOS-2026-2358 |
| * Fix for TALOS-2026-2331 |
| * Fix for TALOS-2026-2330 |
| * Sony YCC decoder: check tile size; add +3 bytes to input buffer to avoid possible overrun in huffman decoder |
| * FP DNG data limit: perform calculations in 64 bit |
| * Add extra huff_coeff item to handle huff_index==17 with known (zero) value, not externally provided tag value |
| * use %lld format for timestamp parse/print where appropriate |
| * nikon coolscan loader: check for EOF |
| * Initialize olympus lensID bits |
| * CR3 parser: all file offsets are unsigned/64bit; check current offset against file size |
| * Add Canon EOS Kiss M2 to camera list |
| * Check real color count against filters; do not pass really 4-color images to fbdd or advanced demosaic |
| * Use LIBRAW_EXCEPTION instead of own internal in losslessjpeg.h |
| * zero input string to avoid compare random stack garbage with tag names |
| * Check for eof in Pentax tag search loop |
| * Fuji decoder: initialize allocated buffers |
| |
| 2025-12-25 Alex Tutubalin <lexa@lexa.ru> |
| |
| LibRaw 0.22 Release (Changelog relative to 0.21-release) |
| |
| == Raw format support == |
| |
| * Panasonic encoding 8 |
| |
| * Sony YCC (Medium/Small compression) pseudo-RAW support: |
| - normal processing (3-channel RGB output) |
| |
| - or YCbCr output if LIBRAW_RAWSPECIAL_SRAW_NO_RGB bit is set |
| in imgdata.rawparams.specials (one may specify the |
| LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE flag too avoid Cb/Cr interpolation) |
| Note: if YCbCr is selected, Cb/Cr neutral points are adjusted to 8192 |
| (to fit histogram/range area of the Y channel) |
| |
| - RAW (pseudo-RAW) data is already white balanced, so |
| imgdata.color.as_shot_wb_applied is set to |
| LIBRAW_ASWB_APPLIED | LIBRAW_ASWB_SONY |
| |
| * DNG 1.7 (including JPEG-XL compression) support via Adobe DNG SDK 1.7.x integration |
| |
| * Canon CRN files: embedded RAW extracted |
| |
| * New implementation for Samsung V3 decoder (NX1, NX500, etc) |
| |
| * OM System 14-bit high-resolution files. |
| Note: the new decoder supports old (12-bit) Olympus/OM-System files |
| too and slightly faster (about 5%), so the old one is removed. |
| |
| * Nikon NEFX (4/8/16/32 shots in PixelShift mode merged via Nikon software) |
| |
| == Camera support == |
| |
| * Canon EOS R1, EOS R5 Mark II, EOS R5 C, EOS R6 Mark II, EOS R8, EOS R50, EOS R100, EOS Ra |
| * Fujifilm X-T50, GFX 100S II, GFX100-II, X-T5, X-S20, X-H2 |
| X-H2S: support of files with wrong metadata (pre 1.03 fw) |
| * GoPro HERO11, HERO12 (via GoPro SDK) |
| * Hasselblad CFV-50c, CFV-100c, X2D-100c |
| * Leica Q3 43, D-Lux8, SL3, Q3, M11 Monochrom |
| * Nikon (standard compression only): Z6-III, Z f, Z30, Z8 |
| * Olympus/OM System OM-1 Mark II, TG-7, OM-5 |
| * Panasonic GH7, S9, DC-G9 II, DC-ZS200D / ZS220D, DC-TZ200D / TZ202D / TZ220D, DC-S5-II, DC-GH6 |
| * Pentax KF, K III Monochrome |
| * Sony ZV-E10M2, UMC-R10C, A9-III, ILX-LR1, A7C-II, A7CR, ILCE-6700, ZV-1M2, ZV-E1, ILCE-7RM5 (A7R-V), ILME-FX30 |
| A1: support for files damaged by exiftool |
| * Multiple DJI and Skydio drones |
| * Tested with multiple smartphones with DNG format recorded. |
| * As planned in LibRaw snapshot 202101 release notes, OLD_VIDEOCAMS |
| support is dropped. |
| These cameras are no longer supported: |
| - old RED Cine cameras |
| - Canon C500 |
| - ARRI video/digital cinema cameras |
| * Total supported camera count: 1284 (if compiled with all features) |
| |
| == Preview format support == |
| |
| * JPEG-XL previews (DNG 1.7) support: |
| - new bit for imgdata.rawparams.options: |
| LIBRAW_RAWOPTIONS_ALLOW_JPEGXL_PREVIEWS (not set by default) |
| - if the bit is set, LibRaw will perceive such previews in the same way as JPEG ones |
| (largest preview is selected by default, etc). |
| - tformat field for such preview is set to LIBRAW_THUMBNAIL_JPEGXL |
| - image metadata (width/height/channels count) is not parsed for JPEG-XL previews |
| * H265 (Canon) and JPEG-XL thumbnail support for dcraw_make_mem_thumb |
| Note: libraw_processed_image_t.type is set to LIBRAW_IMAGE_H265 or |
| LIBRAW_IMAGE_JPEGXL respectively |
| |
| * Jpeg XL preview file writer |
| |
| * Jpeg XL preview support in simple_dcraw -E/-e |
| |
| == API/ABI changes == |
| * New rawoptions/processing flag for DNG processing if compiled |
| with Adobe DNG SDK: |
| LIBRAW_RAWOPTIONS_DNG_STAGE23_IFPRESENT_JPGJXL |
| Similar to LIBRAW_RAWOPTIONS_DNG_STAGE2_IFPRESENT,LIBRAW_RAWOPTIONS_DNG_STAGE3_IFPRESENT |
| flags but applied to JPEG/JPEG-XL compressed images only: |
| If OpcodeList2/OpcodeList3 tags are present in the input DNG file, these tags will be |
| processed via Adobe DNG SDK, producing corrected (de-bayered) image. |
| |
| * DNG OpcodeList1/2/3: opcode list(s) are read (as is) into |
| imgdata.color.dng_levels.rawopcodes[3] |
| |
| * Exif callback is called from CR3 parser before calling parse_makernotes() |
| parameters are the same as usual, except tag parameter value. |
| tag values: |
| (0x70000 | 0x927c) - if called from CMT3 tag |
| (__type << 20) | 0x80000 | 0x927c - if called from CTMD record with type __type |
| |
| * Exif callback is called for Sony SR2 tag with tag parameter set to 0x60000 | tagID |
| |
| * Makernotes callback implemented for TIFF-like (IFD structure makernotes) |
| Callback is very similar to exif_callback. |
| To set callback use LibRaw::set_makernotes_handler(exif_parser_callback cb, void *data) |
| Callback is called (if set) with tag value set to (uptag << 16)|makernotes_tag |
| where uptag is |
| EXIF tag: if called from EXIF makernotes parser |
| 0: if called from CR3 metadata parser |
| tag-ID if parse_makernotes() is called from some specific tag context (see parse_makernotes calls in source code). |
| |
| * New metadata field makernotes.pentax.DynamicRangeExpansion[4] |
| if DynamicRangeExpansion[1] is non-zero, DynamicRangeExpansion[0] should be added |
| to BaselineExposure |
| |
| * New API call (static) int LibRaw::simplify_make_model(unsigned * mkindex, char *mkbuf, unsigned mkbuf_size, char *modelbuf, unsigned modelbuf_size): |
| This call can be used to simplify/standardize vendor name/model received |
| from external source (e.g. EXIF block in JPEG file). |
| mkindex: pointer to received maker index (LibRaw_CAMERAMAKER_...) |
| mkbuf, mkbuf_size: buffer with make string, buffer size |
| modelbuf, modelbuf_size: buffer with model string. |
| simplify_make_model(..) simplifies/re-writes vendor name/model in place, in provided buffers. |
| return values: |
| 0 - mkindex is set (if non-null pointer provided), data simplified; |
| 1 - mkindex is not set, while some data processing is done; |
| -1 - incorrect parameters; |
| |
| * All file offsets are 64-bit now; |
| Note: data callback signature has changed |
| |
| * New LibRaw_abstract_datastream (and derived classes) methods: |
| bool is_buffered() - returns current buffering mode (if implemented); |
| void buffering_on() - turns buffering on. |
| These methods complement the (existing) buffering_off() method. |
| |
| * New bits in imgdata.process_warnings: |
| LIBRAW_WARN_DNG_NOT_PROCESSED - RAW file was passed to DNG SDK, but not processed. |
| LIBRAW_WARN_DNG_NOT_PARSED - DNG parse error or non-valid DNG at valid_for_dngsdk() stage |
| |
| * New compile-time define: LIBRAW_MAX_CR3_RAW_FILE_SIZE |
| Default: value of LIBRAW_MAX_NONDNG_RAW_FILE_SIZE |
| CR3 file size is limited by 4GB (max MP4 container size), so it may be needed |
| to set the limit above non-DNG 2GB file size limit. |
| |
| * New imgdata.params.use_p1_correction parameter |
| If set to non-zero (default): PhaseOne compressed files will be corrected (linearization; defect mapping) |
| based on metadata contained in file. |
| |
| * New possible bit in imgdata.process_warnings: LIBRAW_WARN_VENDOR_CROP_SUGGESTED |
| If set: unknown/untested RAW image frame size passed to LibRaw, cropping may be incorrect. |
| It is suggested to use LibRaw::adjust_to_raw_inset_crop(1) for vendor specified crop. |
| |
| * LibRaw::adjust_to_raw_inset_crop exposed via C-API call: |
| libraw_adjust_to_raw_inset_crop(libraw_data_t *lr, unsigned mask, float maxcrop); |
| Note: default maxcrop value for C++ API is 0.55f |
| |
| * Added imgdata.makernotes.sony.AspectRatio field |
| - if parsed: contains aspect ratio (width to height) |
| - if not parsed: initialized to -999.f |
| |
| * Canon AutoRotate mode detection for several cameras. |
| If LIBRAW_RAWOPTIONS_CANON_CHECK_CAMERA_AUTO_ROTATION_MODE bit |
| is set in imgdata.rawparams: for shots with AutoRotate is Off |
| TIFF::Orientation tag wil be used for imgdata.sizes.flip |
| (and Makernotes rotation tag for other AutoRotate modes). |
| Note: AutoRotate is detected for limited set of Canon cameras, |
| namely: EOS 6D, 5D Mark IV, 5DS, 5DS R |
| To extend this list: we need specially shot samples to detect |
| AutoRotate field location in metadata. Contact us for details |
| if you need to add your camera to list and have such camera on hands |
| |
| * Most small buffer allocations: malloc changed to calloc to prevent |
| uninitialized heap data leaks |
| |
| * Large buffer allocation (RAW backing store, thumbnails store): |
| If LIBRAW_CALLOC_RAWSTORE is defined on build: large buffers will be |
| allocated via calloc |
| |
| == Minor Improvements == |
| |
| * Fixed issue 712: mistype in MIN/MAX that loosens camera WB preset checks |
| |
| * Updated libraw_types.h to fix calling C++ files in external C -- main |
| includes cannot be in extern C for the library to correctly compile |
| under Swift Modules. This small change lets the compiler |
| finish when compiling the library inside a module. |
| |
| * Read known parts of the X3F 4.X (Quattro) header |
| |
| * Rollei loader: more realistic limits |
| |
| * Additional metadata checks in PhaseOne files processing |
| |
| * Minor fixes to improve stability and special crafted files handling |
| |
| * Multiple minor fixes to better handling of specially crafted files |
| |
| * Fixed regression in Fujufilm S6000/S6500 support |
| |
| * Improved damaged/incorrect files handling |
| |
| * Support for 4-color lossy-compressed DNG files |
| |
| * Improved damaged/incorrect/modified CR3 files handling |
| |
| * Colordata updated for several Fujifilm cameras |
| |
| * Improved byte order detection for PowerPC |
| |
| * Minor fix: NOMINMAX defined before #include winsock2.h in |
| LibRaw public header to not provide min/max macros to the |
| code that includes libraw.h |
| |
| * RawSpeed1/3: do not pass files larger then 2GB |
| |
| * DNG 1.7 JpegXL DNG/GoPro DNG: do not refuse files at open_file() if LibRaw is not built with DNG SDK/GoPro SDK |
| Note: LibRaw::get_decoder_info() will return decoder flag bit set to LIBRAW_DECODER_UNSUPPORTED_FORMAT if |
| LibRaw is not built with corresponding SDK. |
| |
| * All implicit type conversion *excluding INT64<=>int/uint* conversions are made explicit |
| to remove C++ compiler type conversion warnings. |
| |
| * Sony DSC-HX95: improved metadata parsing |
| |
| * Better support for cropped images from latest Fujifilm cameras |
| (X-H2, X-H2S, X-T5) |
| |
| * New patch for RawSpeed3: 05.no-phase-one-correction.patch |
| this patch disables RawSpeed's PhaseOne flat field correction (not needed because |
| LibRaw uses own P1-metadata based correction) |
| |
| * RawSpeed3/PhaseOne compressed files: scale unpacked data to match camer black level data. |
| |
| * Better handling of DNG RAW Previews with Stage2 opcodes |
| |
| * Nikon Z8/HLG mode: do not add 10 bit/unknown format thumbnails to the thumb_list |
| |
| * Canon CR2 16-bit bitmap previes: do not convert from Kodak colorspace |
| |
| * New compile-defined limit LIBRAW_MAX_PROFILE_SIZE_MB: |
| limits allocation/read size for embedded color profile (default: 256Mb) |
| |
| * Embedded color profile allocation/read size: limited by input file size. |
| |
| * Check against corrupted LJPEG header in Canon sRAW decoder |
| |
| * Better support for Sony metadata |
| |
| * Better handling of memory allocation errors in unpack_thumb() |
| |
| * Support for 8bit/Monochrome DNG Previews |
| |
| * Placeholder for DNG/YCC preview decoding: such previews are recorded |
| by Samsung S21 Ultra smartfone, while all present samples contains |
| broken data; Right now 'no preview' returned for such files. |
| |
| * Support for BW bitmap previews in LibRaw::dcraw_thumb_writer |
| |
| * Phase One: explicitly switch to monochrome mode if firmware string |
| contains 'Achromatic' word |
| |
| * tiff parser: check for IFD offset before parsing it |
| |
| * LibRaw::thumbOK(): return 0 for YCbCr thumbnails (because |
| unpack_thumb() will always return error: no correct thumbnails |
| with this format found in the image samples yet) |
| |
| * Improved Sigma X3F files model recognition |
| |
| == Bug/problem fixes == |
| * Fix for PanasonicV8 decoder compile with OpenMP |
| * Fix for incorrect 32-bit shift in Pana8 decoder generated by gcc11+ |
| * DNG SDK Integration: clear imdata.color.linear_max[] if Stage3 opcodes are applied. |
| * Fixed possible buffer overrun in LibRaw::remove_trailing_spaces call |
| * CR3 decoder: workaround for possible incorrect generation of 64-bit code |
| * Improved Sony metadata processing |
| * fixed possible static table read overrun (if specially crafted image |
| data passed to LibRaw) |
| * Fix for monochrome DNG files compressed as 2-color component LJPEG |
| * Fixed integer overflow in largest DNG frame selection code |
| * Additional out-of range checks to better handle specially crafted files |
| * Prevent out-of-buffer access in phase_one_correct() |
| * Prevent one-off read in Fuji WB table parsing |
| * Prevent one-off read in phase_one_correct() |
| * Do not apply Canon metadata crop values to DNG files |
| * Adjust profile_length to allocated data size. |
| * libraw_dng_stream: underlying LibRaw_abstract_datastream buffering restored in |
| destructor call. |
| * Fixed possible buffer overrun in old panasonic decoder |
| |
| 2022-07-01 Alex Tutubalin <lexa@lexa.ru> |
| |
| LibRaw 0.21 |
| |
| == Camera format support == |
| * Phase One/Leaf IIQ-S v2 support |
| * Canon CR3 filmrolls |
| * Canon CRM (movie) files |
| * Tiled bit-packed (and 16-bit unpacked) DNGs |
| * (non-standard) Deflate-compressed integer DNG files are allowed |
| |
| == Camera support == |
| |
| * Canon EOS R3, R7 and R10 |
| * Fujifilm X-H2S, X-T30 II |
| * OM System OM-1 |
| * Leica M11 |
| * Sony A7-IV (ILCE-7M4) |
| * DJI Mavic 3 |
| * Nikon Z9: standard compression formats only |
| |
| == Multiple (resolution) thumbnails support == |
| |
| * New imgdata.thumbs_list data item with data fields: |
| |
| int thumbcount: thumbnail count |
| libraw_thumbnail_item_t thumblist[LIBRAW_THUMBNAIL_MAXCOUNT]: list of thumbnails |
| |
| libraw_thumbnail_item_t fields: |
| |
| enum LibRaw_internal_thumbnail_formats tformat: internal thumbnail format |
| (this is not PPM/JPEG, but internal type related to thumbnail reading/unpacking method) |
| |
| ushort twidth, theight: thumbnail image size. |
| |
| ushort tflip: image rotation (see notes below) |
| |
| unsigned tlength: on-disk data size (not uncompressed for compressed formats) |
| |
| unsigned tmisc: bit depth and channel count: (color << 5) | bitsperpixel |
| |
| INT64 toffset: Thumbnail data offset in file |
| |
| Notes: |
| - Only TIFF-based and CR3 files are parsed for thumbnail list, other formats will have |
| thumbcount = 1. |
| |
| - If no thumbnails are found in file: thumbcount will be set to 1 and |
| thumblist[0] will be initialized with data from thumbnail fields, |
| so LibRaw::unpack_thumb_ex(0) will do the same as LibRaw::unpack_thumb() |
| |
| - Thumbnail image size may be unknown (not recorded in metadata), in this case twidth and theight are zero. |
| Usually small(er) thumbnails will always have twidth/theight filled, while largest one may have these fields set to zero. |
| |
| - Thumbnail rotation (tflip) is filled only for TIFF-based RAWs (if Orientation tag is not present in IFD, default zero value is used) |
| For non-tiff images, tflip is initialized to 0xffff (not known...) |
| |
| - There is no code to select thumbnail based on some criteria (e.g. minimal resolution), it is left to user to implement such a criteria, if needed |
| (see unpack_thumb_ex() call below) |
| |
| - If you want to get largest possible thumbnail: just use old unpack_thumb() call to get it. |
| |
| * new API call: LibRaw::unpack_thumb_ex(int i): |
| Unpacks i-th thumbnail if it exists into imgdata.thumbnail structure |
| i should be non-zero and less then imgdata.thumbs_list.thumbcount. |
| |
| * samples/simple_dcraw.cpp: new -E command line switch to extract all thumbnails from input file(s) |
| |
| == (Experimental) RawSpeed "version 3" (develop branch) support. == |
| |
| Build with -DUSE_RAWSPEED3, see details in RawSpeed3/README.md |
| |
| LibRaw::capabilities will set bit LIBRAW_CAPS_RAWSPEED3 if compiled w/ |
| RawSpeed-v3 support |
| |
| If file was processed (or tried to process) via RawSpeed-v3, these bits |
| are raised in imgdata.process_warnings: |
| LIBRAW_WARN_RAWSPEED3_PROCESSED - processed via RawSpeed v3 |
| LIBRAW_WARN_RAWSPEED3_PROBLEM - not processed (due to exception in RawSpeed library) |
| LIBRAW_WARN_RAWSPEED3_UNSUPPORTED - unsupported file |
| LIBRAW_WARN_RAWSPEED3_NOTLISTED - file not listed in cameras.xml data |
| |
| RawSpeed-v3 support is controlled via libraw_decoder_info.t->flags |
| (LIBRAW_DECODER_TRYRAWSPEED3 bit). |
| The bit is set for: |
| - lossless jpeg decoder |
| - Canon sRAW decoder |
| - lossless compressed and packed-compressed DNG decoders |
| - Pentax decoder |
| - Nikon (compressed) decoder |
| - Phase One Compressed and Hasselblad/Compressed decoders |
| - bitpacked decoder |
| - Panasonic (old 12-bit compression) decoder |
| - Olympus decoder |
| - Sony ARW (v1 and v2) decoders |
| - Samsung (version 1) decoder |
| |
| * (Experimental) Fine control of RawSpeed version selection/use. |
| To enable, build LibRaw with -DUSE_RAWSPEED_BITS |
| LibRaw::capabilities will set bit LIBRAW_CAPS_RAWSPEED_BITS if compiled |
| with this flag. |
| If enabled: |
| imgdata.rawparams.use_rawspeed becomes bit-field (instead of 0/1 off/on) |
| with bits: |
| LIBRAW_RAWSPEEDV1_USE - use RawSpeed Version 1 (if compiled with) |
| LIBRAW_RAWSPEEDV1_FAILONUNKNOWN - do not process unknown files |
| (not listed in RawSpeed v1 camera definitions file) |
| LIBRAW_RAWSPEEDV1_IGNOREERRORS - ignore mirror decoding errors (out of range data,etc) |
| |
| LIBRAW_RAWSPEEDV3_USE - Use RawSpeed Version 3 (if compiled with) |
| LIBRAW_RAWSPEEDV3_FAILONUNKNOWN - do not process unknown files |
| LIBRAW_RAWSPEEDV3_IGNOREERRORS - ignore minor decoding errors |
| |
| == Misc changes/improvements == |
| * New compile time define LIBRAW_OWN_SWAB |
| to use on platforms without swab() in C/C++ runtime |
| |
| * New imgdata.rawparams.options bit: LIBRAW_RAWOPTIONS_CANON_IGNORE_MAKERNOTES_ROTATION |
| If set: image orientation is set based on TIFF/IFD0:Orientation tag, |
| makernotes orientation data is ignored |
| |
| * Nikon makernotes: read NEFCompression tag for HE/HE* files |
| |
| * Nikon orientation tag: more fixed offsets for known cameras |
| |
| * Adobe DNG SDK 1.6 support (meaning, just an additional patch for GPR SDK) |
| |
| * removed LibRaw::memerr(), memory allocation failures are already handled |
| in LibRaw_memmgr::*alloc w/ exception thrown |
| |
| * removed memory error callback, out-of-memory error should be handled via |
| returned error code check, all related parameters (e.g. LibRaw constructor |
| option to not set such callback) is also removed |
| |
| * imgdata.params.adjust_maximum_thr is settable via C-API libraw_set_adjust_maximum_thr(..) |
| |
| * New rawoptions/processing flags for DNG processing if compiled |
| with Adobe DNG SDK: |
| LIBRAW_RAWOPTIONS_DNG_STAGE2_IFPRESENT,LIBRAW_RAWOPTIONS_DNG_STAGE3_IFPRESENT |
| If these flag(s) are set: Stage2/Stage3 processing will be performed |
| only if OpcodeList2/OpcodeList3 tags are present in the input DNG file |
| Old (hard) flags (LIBRAW_RAWOPTIONS_DNG_STAGE2 and |
| LIBRAW_RAWOPTIONS_DNG_STAGE3) are not removed and will force Stage2/3 |
| processing if set (regardless of input file tags) |
| |
| * New imgdata.rawparams.options bit: LIBRAW_RAWOPTIONS_DNG_ADD_MASKS |
| If set: DNG Transparency Masks will be extracted (if selected via shot_select) |
| |
| * New decoder flag: LIBRAW_DECODER_UNSUPPORTED_FORMAT |
| |
| == Bugs fixed == |
| |
| * Fixed possible out-of-buffer read in Nikon orientation tag parser |
| |
| * Windows datastream: fixed logic errors (not showing up in real life) |
| |
| * Out-of-range read-only array access in postprocessing if output_color is set to 0 (raw color) |
| |
| * Minolta Z2 was not recognized correctly on 32-bit systems |
| |
| * Fixed possible buffer overflow in Kodak C330 decoder |
| |
| * dcraw_process(): check for buffer allocation results to avoid NULL deref |
| |
| 2021-10-11 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Apple iPhone 13 Pro |
| GoPro HERO10 (if compiled w/ USE_GPR_SDK) |
| Ricoh GR III |
| Sony Xperia 1 III |
| |
| * Fuji RAF files: XMP block extraction |
| |
| * Fixed a typo in LIBRAW_OPTIONS_* flag names |
| (was LIBRAW_OPIONS, old flags names not removed due to compatibility) |
| |
| * samples/raw-identify.cpp: -v flag documented in usage print. |
| |
| 2021-09-14 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Fujifilm GFX 50S II |
| Nikon Z fc |
| Sony A7R-IIIA (ILCE-7RM3A), A7R-IVA (ILCE-7RM4A) |
| |
| * API/datastruct Changes: |
| - imgdata.params.shot_select moved to imgdata.rawparams.shot_select |
| (because this is decode-time option, not postprocessing option) |
| |
| - libraw_open_bayer(...) added to C-API |
| |
| - imgdata.makernotes.canon: separate SensorLeftBorder,SensorTopBorder.... |
| (and many other datafields) are united in libraw_area_t (rectangle) |
| groups for crop areas and optical black areas. |
| |
| * src/libraw_cxx.cpp completely removed from source tree to not confuse users. |
| (also all mentions are removed from Makefiles) |
| |
| * Better Olympus makernotes parsing: LiveND mode, Panorama mode tags. |
| |
| * clang-cl compatibility: |
| - defines _MSC_VER, but _forceinline is not supported |
| - warnings eliminated in Windows buffered datastream |
| |
| * Canon/12-bit files: adjust color.linear_max and makernotes.canon values |
| to match data range. |
| |
| 2021-08-04 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Sony ZV-E10 |
| * DNG/Floating point: additional metadata check to refuse ambiguous/corrupted files. |
| * DNG/Floating point: correct handling of striped files (never seen in wild) |
| * Rawspeed support: disallow Nikon D6/Compressed processing |
| * Bug fixed: raw_inset_crops[] ctop/cheight was not adjusted right if vendor-specified |
| ctop equals to 1. |
| |
| 2021-07-20 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Olympus E-P7 |
| |
| 2021-07-08 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Panasonic GH5 Mark II |
| Pentax K3 Mark III |
| several phones w/ DNG files (checked) |
| |
| * Camera format support: Panasonic v6/12 bit |
| * Compile-time raw size limits implemented: |
| LIBRAW_MAX_NONDNG_RAW_FILE_SIZE - max file size for non-DNG files (default: 2GB - 1 byte) |
| LIBRAW_MAX_DNG_RAW_FILE_SIZE - max DNG file size limit (4GB-1 if compiled w/ DNG SDK, 2GB-1 otherwise) |
| |
| * ACES output: color conversion changed to provide D65 white point |
| |
| * Fix for Canon 5D Mark II/sRAW1 incorrect camera provided crop |
| |
| 2021-05-07 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Fujifilm GFX 100S, X-E4: improved color data |
| Canon EOS M50 Mark II was supported but not listed in camera list |
| DJI Mavic Air 2S |
| GOPRO Hero9 |
| * Support for RaspberryPi HQ camera (if compiled w/ USE_6BY9RPI) |
| * Improved support for RPi V1/V2 cameras: |
| - white balance data extraction |
| - color matrix extracted to imgdata.color.cmatrix to use with |
| use_camera_matrix. |
| - full-size thumbnail/preview support for JPEG+RAW files (raspistill -r) |
| * Fuji GFX100/GFX100S: PixelShift metadata extraction. |
| * RawSpeed (master): fixed bug in old Samsung/compressed decoder, |
| apply this patch to RawSpeed: RawSpeed/rawspeed.samsung-decoder.patch |
| * DCI-P3 and Rec 2020 output colorspaces |
| * Eliminated multiple signed/unsigned mismatch warnings (reported by gcc11) |
| * fixed possible 1-byte stack underrun while handling text tags with zero length |
| * XMP block size in CR3 files limited to 1MB |
| * Preview block size in CR3 files limited to 100MB |
| * Fixed wrong handling of linear DNG files created from Pentax out-of-camera |
| DNGs |
| |
| 2021-02-18 Alex Tutubalin <lexa@lexa.ru> |
| * Improved Phase One Compressed defects masking, thanks to Alexey Danilchenko |
| * Sony ILCE-1/Lossless compressed support |
| |
| 2021-02-16 Alex Tutubalin <lexa@lexa.ru> |
| * Additional fields in libraw_internal_data.unpacker_data: |
| - INT64: exif_offset: base offset of 1st EXIF IFD in file |
| - INT64: ifd0_offset: base offset of 1st TIFF IFD (IFD0) in file |
| - unsigned cr3_exif_length, cr3_ifd0_lenght : CR3-specific length of |
| exif and ifd0 sections. |
| |
| 2021-02-08 Alex Tutubalin <lexa@lexa.ru> |
| * CRX (CR3) decoder: fixed typo in constant; this does not affect any |
| known still photo (CR3) sample(s), but allows to use the decoder with |
| some video (CRM) files. |
| |
| * Imported user-contributed improvements to OpenMP postprocessing |
| (AHD and X-Trans demosaic) |
| |
| * Bugfix: overwrite (wrong) TIFF/Orientation tag value with Metadata/Camera Orientation |
| value for EOS 40D only. |
| |
| 2021-02-04 Alex Tutubalin <lexa@lexa.ru> |
| * imgdata.sizes.raw_inset_crop rearranged: |
| now it is imgdata.sizes.raw_inset_crops[2]: |
| - item at [0] is the same as imgdatra.sizes.raw_inset_crop in previous |
| versions |
| - item at [1] is 'user crop', in particular: |
| -- set by DNG DefaultUserCrop tag |
| -- or set via raw aspect ratio tags (e.g. 16:9 aspect on Fujifilm cameras) |
| raw_inset_crops[1] is filled only if aspect ratio tags provides different |
| aspect ratio compared to raw_inset_crops[0]. |
| |
| There are no flags to check if raw_inset_crops[Nth] is filled; to see if it is filled check |
| the values of: |
| ctop/cleft < 0xffff (0xffff => standard values if not initialized) |
| ctop+cheight <= sizes.raw_height |
| cleft+cwidth <= sizes.raw_width |
| |
| Note: raw_inset_crops may be fooled by metadata (makernotes), use some correctness check before use. |
| |
| * LIBRAW_RAWOPTIONS_USE_DNG_DEFAULT_CROP processing flag removed, |
| DNG DefaultCrop* tags are parsed into raw_inset_crops[0] |
| |
| * new LibRaw call LibRaw::adjust_to_raw_inset_crop(unsigned mask, float maxcrop = 0.55f) |
| Promotes imgdata.sizes.raw_inset_crops[] values to |
| imgdata.sizes.*margin and imgdata.sizes.width/height fields |
| |
| mask: if bit 1 is set: prefer raw_inset_crops[1] |
| if bit 0 is set: prefer raw_inset_crops[0] |
| |
| maxcrop: limits crop to not less than (original width/height)*maxcrop; if raw_inset_crops[i] |
| data results in tighter crop, than this item is ignored. |
| |
| return value: index in raw_inset_crops[] used increased by one, so |
| 0: no changes made |
| 1: [0]th data used |
| 2: [1]th data used |
| |
| Note: this call SHOULD be used after LibRaw::unpack(), otherwise black level |
| calculation from masked area may be fooled resulting in wrong black levels. |
| |
| 2021-01-21 Alex Tutubalin <lexa@lexa.ru> |
| |
| == LibRaw snapshot 202101 == |
| |
| = Camera format support: = |
| Lossy compressed CR3 files |
| Lossy compressed RAF files |
| Uncompressed floating point DNG files (16-24-32 bit) |
| Deflate compressed striped DNG files |
| XMP and HEIF-preview extraction from CR3 files |
| |
| = Camera support = |
| Apple iPhone 12 Max, iPhone 12 Max Pro |
| Canon EOS R5, EOS R6, EOS 850D, EOS-1D X Mark III (lossy compressed files) |
| FujiFilm X-S10 |
| Hasselblad CFV II 50C", |
| Leica M10-R, Q2 Monochrom, S3, SL2-S |
| Nikon Z 5, Z 6 II, Z 7 II |
| Olympus E-M10 Mark IV |
| Panasonic DC-G100 / G110, DC-S5 |
| Sony ILCE-7C (A7C), ILCE-7SM3 (A7S III) |
| Zeiss ZX1 |
| Plus multiple DNG-recording cameraphones/drones/etc. |
| |
| = Almost dropped camera support: = |
| Old/partially supported video/cinema cameras support is available only if |
| LibRaw is compiled with USE_OLD_VIDEOCAMS defined (this #define is |
| converted internally to LIBRAW_OLD_VIDEO_SUPPORT defined). |
| This affects: |
| Arri cameras |
| Canon C500 |
| RED Cine cameras |
| We plan to keep the support in LibRaw 0.21 (if compiled with define |
| mentioned above) and completely drop the support after 0.21. |
| If you're using LibRaw to decode RED Cine files, see LibRaw*datastreams |
| section below (in short: you'll need to use old fstream-based datastream |
| under Windows). |
| Cinema DNG files are not affected by this. |
| |
| = API/ABI changes = |
| |
| * Decoding parameters |
| imgdata.params is split into |
| imgdata.rawparams: parameters used for metadata/raw data decoding |
| imgdata.params: parameters used at postprocessing stage |
| |
| imgdata.params.raw_processing options are split into two sub-options sets |
| imgdata.rawparams.options: raw processing flags, useful for normal |
| operations |
| imgdata.rawparams.specials: special modes (e.g decoding only delta |
| pixels from Sony ARW) |
| |
| Old LIBRAW_PROCESSING_* flags are renamed to LIBRAW_RAWOPTIONS_* and |
| LIBRAW_RAWSPECIAL* |
| LIBRAW_PROCESSING_DP2Q_INTERPOLATE... flags are renamed to |
| LIBRAW_RAWSPECIAL_NODP2Q_INTERPOLATE with inverted meaning (with the |
| goal to have zero imgdata.rawparams.specials in normal use). |
| |
| * New processing flag LIBRAW_RAWOPTIONS_PROVIDE_NONSTANDARD_WB |
| If set (default is not), and when applicable, color.cam_mul[] and |
| color.WB_Coeffs/WBCT_Coeffs will contain WB settings for a |
| non-standard workflow. |
| Right now only Sony DSC-F828 is affected: camera-recorded white balance |
| can't be directly applied to raw data because WB is for RGB, while raw |
| data is RGBE. |
| |
| * New processing flag: LIBRAW_RAWOPTIONS_CAMERAWB_FALLBACK_TO_DAYLIGHT |
| If set (default is not), LibRaw::dcraw_process() will fallback to |
| daylight WB (excluding some very specific cases like Canon D30). |
| This is how LibRaw 0.19 (and older) works. |
| If not set: LibRaw::dcraw_process() will fallback to calculated auto WB if |
| camera WB is requested, but appropriate white balance was not found in |
| metadata. |
| |
| * Removed LIBRAW_PROCESSING_SKIP_MAKERNOTES processing flag: with new |
| Windows(-handle) datastreams metadata parsing performance is enough |
| to not skip makernotes parsing. |
| |
| * new output parameter: imgdata.params.output_flags and new |
| enum LibRaw_output_flags |
| Right now the only flag is implemented: LIBRAW_OUTPUT_FLAGS_PPMMETA |
| setting it will result into metadata written to PPM/PGM output file |
| |
| * LibRaw_*datastreams change and corresponding open_file() parameters change |
| LibRaw_file_datastream (based on iostreams) is moved under |
| #ifdef LIBRAW_USE_DEPRECATED_IOSTREAMS_DATASTREAM |
| Standard datastreams are: |
| LibRaw_bigfile_datastream (FILE* based) for POSIX systems |
| LibRaw_bigfile_buffered_datastream - for use with Win32 syscalls |
| API changes: |
| if LIBRAW_USE_DEPRECATED_IOSTREAMS_DATASTREAM is NOT defined, than |
| LibRaw::open_file() and similar calls drops the last INT64 max_buffered_sz |
| parameter which defines automatic selection between iostreams and |
| FILE* based datasteams. |
| |
| Note: LibRaw_bigfile_buffered_datastream does NOT implements |
| make_jas_stream() call, so RED Cine file decoding is not possible with |
| this datastream. Use deprecaded iostreams implementation instead. |
| |
| We plan to keep LIBRAW_USE_DEPRECATED_IOSTREAMS_DATASTREAM up to |
| LibRaw 0.21 and drop in 0.22. |
| |
| * Fuji decoder: |
| fuji_decode_loop/fuji_decode_strip parameters has changed; look into source |
| code for details if you're implementing your own fuji_decode_loop() |
| call in subclass to provide parallel fuji decoding. |
| |
| * Canon CR3 H265 (HEIF) preview limited support: |
| - new format value: LIBRAW_THUMBNAIL_H265 |
| - this thumbnail is NOT extracted by LibRaw::make_mem_thumb() yet; |
| |
| * LibRaw::capabilities |
| Two bits added: |
| LIBRAW_CAPS_ZLIB if compiled with USE_ZLIB |
| LIBRAW_CAPS_JPEG if compiled with USE_JPEG |
| |
| |
| * Windows datastreams: CreateFile2 is used if compiled for UWP. |
| |
| * API-datastruct: clarified behavior with use_camera_wb=1 setting. |
| |
| * identify(): restored the differentiation between fsize and flen. |
| |
| * New compile-time LIBRAW_FORCE_OPENMP to skip compiler version check |
| (if LibRaw user is absolutely sure that OpenMP is supported by compiler) |
| |
| 2020-10-14 Alex Tutubalin <lexa@lexa.ru> |
| |
| * LibRaw 0.20.2 |
| Reverted 0.20.1 change: |
| - const buffer for open_buffer() and open_bayer() calls |
| Because of 0.20.0 ABI break |
| |
| 2020-10-14 Alex Tutubalin <lexa@lexa.ru> |
| |
| * LibRaw 0.20.1 |
| * Improvements: |
| - exif callback is called on EXIF GPS and EXIF Interop IFDs |
| - open_bayer call documented |
| - Canon (ColorDatsSubver==32): parse Specular White instead of hardcoded value |
| * Fixes for normal files processing: |
| - Olympus XZ-1: do not provide linear_max (it is wrong in metadata) |
| - Nikon Z cameras: added space in camera list |
| - raw-identify: fixed wb-preset print |
| - Pentax Optio 33WR: maker index was incorrect |
| - dcraw_emu: corrected help line for -6 option. |
| - raw-identify: corrected range check for color matrices print |
| - use_camera_matrix option: fixed a bug introduced when making |
| compiler more happy. |
| |
| * Fixes for damaged/special crafted files processing: |
| - Fix for truncated CR3 files parsing |
| - DNG metadata merger: all color loops are limited to MIN(4,colors) |
| - Check for marings: should be less than raw image size |
| - Check for xmpdata present in Samsung Lens ID assignment |
| - Check for column range in leaf_hdr decoder |
| - Additional checks in Hasselblad model parser |
| - Fuji rotate: better limits check |
| - DNG files: limit tiff_samples |
| |
| * Not fixes, but makes ASAN/compilers/etc happy: |
| - corrected GPS EXIF output |
| - const buffer for open_buffer() and open_bayer() calls |
| |
| |
| 2020-07-23 Alex Tutubalin <lexa@lexa.ru> |
| |
| * LibRaw 0.20 |
| |
| == Camera Format support == |
| Canon CR3 |
| GoPro (via GPR SDK) |
| Panasonic 14-bit |
| Fujifilm compressed/16bit |
| Rapsberry Pi RAW+JPEG format (if USE_6BY9RPI defined) |
| Foveon X3F support changed: it is supported only if USE_X3FTOOLS defined |
| at build (see below for 'Imported code policy changed') |
| |
| == Camera support (+59, 1131 total) == |
| Canon: PowerShot G5 X Mark II, G7 X Mark III, SX70 HS, |
| EOS R, EOS RP, EOS 90D, EOS 250D, EOS M6 Mark II, EOS M50, EOS M200 |
| EOS 1DX Mark III (lossless files only) |
| DJI Mavic Air, Osmo Action |
| FujiFilm GFX 100, X-A7, X-Pro3, X100V, X-T4 (uncompressed/lossless compressed only), X-T200 |
| GoPro Fusion, HERO5, HERO6, HERO7, HERO8 |
| Hasselblad L1D-20c, X1D II 50C |
| Leica D-LUX7, Q-P, Q2, V-LUX5, C-Lux / CAM-DC25, SL2, M10 Monochrom |
| Nikon D780, Z50, P950 |
| Olympus TG-6, E-M5 Mark III, E-PL10, E-M1 Mark III, |
| Panasonic DC-FZ1000 II, DC-G90, DC-S1, DC-S1R, DC-S1H, DC-TZ95 |
| PhaseOne IQ4 150MP |
| Ricoh GR III |
| Sony A7R IV, A9 II, ILCE-6100, ILCE-6600, RX0 II, RX100 VII |
| Zenit M |
| |
| also multiple smartphones (the tested ones are listed in LibRaw::cameraList) |
| |
| == Source code re-arranged == |
| * dcraw.c is not used in the generation and build processes |
| * dcraw_common.cpp and libraw_cxx.cpp are split into multiple code chunks |
| placed in separate subfolders (decoders/ for raw data decoders, |
| metadata/ for metadata parsers, etc) |
| * dcraw_common.cpp and libraw_cxx.cpp remain to preserve existing |
| build environments (these files are now just a bunch of #include directives). |
| * It is possible to build LibRaw |
| a)without postprocessing functions (dcraw_process() and called function) |
| b)without postprocessing and LibRaw::raw2image() call (and called function). |
| It may be useful to reduce library memory/code footprint. |
| See Makefile.devel.nopp and Makefile.devel.noppr2i for the list of source |
| files needed to build reduced/stripped library. |
| |
| == Normalized make/model == |
| |
| There is a huge number of identical cameras sold under different names, |
| depending on the market (e.g. multiple Panasonic or Canon models) |
| and even some identical cameras sold under different brands |
| (Panasonic -> Leica, Sony -> Hasselblad). |
| |
| To reduce clutter, a normalization mechanism has been implemented in LibRaw: |
| |
| In imgdata.idata: |
| char normalized_make[64]; - primary vendor name (e.g. Panasonic for |
| Leica re-branded cameras) |
| char normalized_model[64]; - primary camera model name |
| unsigned maker_index; - primary vendor name in indexed form (enum |
| LibRaw_cameramaker_index, LIBRAW_CAMERAMAKER_* constant). |
| These fields are always filled upon LibRaw::open_file()/open_buffer() calls. |
| |
| const char* LibRaw::cameramakeridx2maker(int index): converts maker_index |
| to normalized_make. |
| |
| We recommend that you use these normalized names in a variety of data tables |
| (color profiles, etc.) to reduce the number of duplicate entries. |
| |
| New vendor index values will be added strictly to the end of the |
| LibRaw_cameramaker_index table, ensuring that the numbers assigned to |
| vendors that are already known to LibRaw will not change. |
| |
| == DNG frame selection == |
| |
| DNG frames selection code re-worked: |
| - by default all frames w/ the NewSubfileType tag equal to 0 |
| (high-res image) are added to the list of available images (selection |
| performed via imgdata.params.shot_select field, as usual) |
| - the special case for Fuju SuperCCD (SamplesPerPixel == 2) works as |
| before: shot_select=1 will extract second sub-image. |
| - Additional flags to imgdata.params.raw_processing_options: |
| LIBRAW_PROCESSING_DNG_ADD_ENHANCED - will add Enhanced DNG frame |
| (NewSubfileType == 16) to the list of available frames |
| LIBRAW_PROCESSING_DNG_ADD_PREVIEWS - will add previews |
| (NewSubfileType == 1) to the list. |
| |
| - By default, DNG frames are not reordered and are available in same order |
| as in DNG (LibRaw traverses IFD/Sub-IFD trees in deep-first order). |
| To prioritize the largest image, set LIBRAW_PROCESSING_DNG_PREFER_LARGEST_IMAGE |
| bit in imgdata.params.raw_processing_options. |
| |
| - DNG Stage2/Stage3 processing via DNG SDK (request via flags in |
| raw_processing_options) |
| |
| == Imported code policy disclaimer == |
| |
| We've changed the policy regarding 3rd party code imported into LibRaw. |
| |
| We (like other authors of open-source RAW parsers) gladly import support |
| code for various RAW formats from other projects (if the license allows it). |
| This is done to expand camera support. |
| Unfortunately, not all imported code can tolerate truncated or otherwise |
| damaged raw files, as well as arbitrary conditions or arbitrary data; |
| not all authors handle rejecting unexpected input well. |
| |
| LibRaw is now widely used in various projects, including ImageMagick, which, |
| in turn, is often used on web sites to process any input images, including |
| arbitrary data from unknown users. |
| This opens up wide possibilities for exploiting the various vulnerabilities |
| present in the code borrowed from other projects into LibRaw. In order to |
| avoid such security risks, - the borrowed code will no longer compile |
| by default. |
| We are not able to support it in general case, and the authors refuse |
| to add code to reject unexpected input. |
| |
| Thus, if you use some kind of camera for which the support is disabled |
| by default, you need to recompile LibRaw for your specific case. |
| |
| Formats currently affected: |
| X3F (Foveon) file format. |
| Code is imported from Kalpanika X3F tools: https://github.com/Kalpanika/x3f |
| To turn the support on, define USE_X3FTOOLS |
| |
| Rapsberry Pi RAW+JPEG format. |
| Code is imported from https://github.com/6by9/dcraw/, |
| To turn the support on, define USE_6BY9RPI |
| Format support is indicated via LibRaw::capabilities() call with flags: |
| LIBRAW_CAPS_X3FTOOLS - Foveon support |
| LIBRAW_CAPS_RPI6BY9 - RPi RAW+JPEG support |
| |
| == GoPro .gpr format support == |
| GoPro format supported via open-source GPR SDK |
| See README.GoPro.txt for details. |
| |
| == Windows support/Windows unicode (wchar_t*) filenames support == |
| |
| * (old) LibRaw's WIN32 external define split into 3 defines to fine tune |
| compiler/api compatibility: |
| LIBRAW_WIN32_DLLDEFS - use to compile DLLs (__dllimport/__dllexport attributes) |
| LIBRAW_WIN32_UNICODEPATHS - indicates that runtime has calls/datatypes for wchar_t filenames |
| LIBRAW_WIN32_CALLS - use Win32 calls where appropriative (binary mode for files, LibRaw_windows_datastream, _snprintf instead of snprintf, etc). |
| |
| If the (old) WIN32 macro is defined at compile time, all three new defines are defined in libraw.h |
| If not, these defines are defined based on compiler version/libc++ defines |
| |
| * LibRaw::open_file(wchar_t*) is always compiled in under Windows, but |
| if LIBRAW_WIN32_UNICODEPATHS (see above) is not defined, this call will |
| return LIBRAW_NOT_IMPLEMENTED. |
| Use (LibRaw::capabilities() & LIBRAW_CAPS_UNICODEPATHS) on runtime |
| to check that this call was really implemented (or check for #ifdef LIBRAW_WIN32_UNICODEPATHS after #include <libraw.h>) |
| |
| == LibRaw*datastream simplified == |
| |
| * tempbuffer_open, subfile_open are not used, so removed from |
| LibRaw_abstract_datastream and derived classes. |
| |
| * jpeg_src() call implemented using ->read() call and own buffering |
| (16k buffer). |
| * buffering_off() call added. It should be used in derived classes |
| to switch from buffered reads to unbuffered. |
| |
| == minor/unsorted changes == |
| * new flag LIBRAW_WARN_DNGSDK_PROCESSED to indicate decoder used |
| * LibRaw::open() call, max_buf_size special meaning: |
| == 1 => open using bigfile_datastream |
| == 2 => open using file_datastream |
| * Add support for zlib during configure |
| * Fixed multiple problems found by OSS-Fuzz |
| * Lots of changes in imgdata.makernotes (hope someone will document it) |
| * DNG SDK could be used (if enabled) to unpack multi-image DNG files. |
| * DNG whitelevel calculated via BitsPerSample if not set via tags. |
| * DNG: support for LinearDNG w/ BlackLevelRepeat.. pattern |
| * Generic Arri camera format replaced w/ list of specific camera models in supported cameras list. |
| * new samples/rawtextdump sample: allows one to dump (small selection) of RAW data in text format. |
| * samples/raw-identify: |
| * +M/-M params (same as in dcraw_emu) |
| * -L <file-w-filelist> parameter to get file list from a file |
| * -m paramerer to use mmap'ed IO. |
| * -t parameter for timing |
| * samples/dcraw_emu: fixed +M handling |
| * better support for Nikon Coolscan 16-bit NEF files. |
| * Visual Studio project files: re-generated to .vcxproj (Visual Studio 2019), different |
| intermediate folders for different sub-projects to allow 1-step rebuild. |
| * imgdata.makernotes...cameraspecific: removed the vendor name prefix from variables. |
| * Bayer images: ensure that even margins have the same COLOR() for both the active sensor area and the full sensor area. |
| * raw processing flag bit LIBRAW_PROCESSING_CHECK_DNG_ILLUMINANT inverted and renamed to |
| LIBRAW_PROCESSING_DONT_CHECK_DNG_ILLUMINANT. If not set, DNG illuminant will be checked. |
| * New libraw_decoder_t flags: |
| LIBRAW_DECODER_FLATDATA - in-file data could be used as is (if byte order matches), e.g. via mmap() |
| LIBRAW_DECODER_FLAT_BG2_SWAPPED - special flag for Sony ARQ: indicates R-G-G2-B channel |
| order in 4-color data |
| * Camera-recorded image crop data is parsed into imgdata.sizes.raw_inset_crop structure: |
| ctop,cleft,cwidth,cheight - crop size. |
| aspect - LibRawImageAspects enum (3to2, 4to3, etc) |
| * New define LIBRAW_NO_WINSOCK2 to not include winsock2.h on compile |
| |
| * New processing flag LIBRAW_PROCESSING_PROVIDE_NONSTANDARD_WB |
| If set (default is not), and when applicable, color.cam_mul[] and |
| color.WB_Coeffs/WBCT_Coeffs will contain WB settings for a non-standard |
| workflow. |
| Right now only Sony DSC-F828 is affected: camera-recorded white balance |
| can't be directly applied to raw data because WB is for RGB, while raw |
| data is RGBE. |
| |
| * New processing flag: LIBRAW_PROCESSING_CAMERAWB_FALLBACK_TO_DAYLIGHT |
| If set (default is not), LibRaw::dcraw_process() will fallback to |
| daylight WB (excluding some very specific cases like Canon D30). |
| This is how LibRaw 0.19 (and older) works. |
| If not set: LibRaw::dcraw_process() will fallback to calculated auto WB if |
| camera WB is requested, but appropriate white balance was not found in |
| metadata. |
| |
| * Google changes cherry-picked (thanks to Jamie Pinheiro) |
| * speedup: ppg interpolate: const loop invariant |
| |
| * Bugs fixed |
| -Fixed several UBs found by OSS Fuzz |
| -Fixed several problems found by other fuzzers. |
| - Thumbnail size range check (CVE-2020-15503) |
| Thanks to Jennifer Gehrke of Recurity Labs GmbH for problem report. |
| - fixed possible overflows in canon and sigma makernotes parsers |
| - fixed possible buffer overrun in crx (cr3) decoder |
| - fixed memory leak in crx decoder (if compiled with LIBRAW_NO_CR3_MEMPOOL) |
| - fixed possible overrun in Sony SRF and SR2 metadata parsers |
| |
| * Fixed typo in longitude (member of parsed GPS structure), update required for code that uses it. |
| |
| |
| 2019-03-05 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support |
| Canon A560 (CHDK hack) |
| FujiFilm X-T30 |
| Nikon Coolpix A1000 |
| Olympus E-M1X |
| Sony ILCE-6400 |
| Several dng files from phones and drones was tested |
| and added to built-in camera list too. |
| |
| * Multiple names for same Panasonic cameras are processed via |
| aliaces mechanics, no multiple duplicate fields in adobe_coeffs() table |
| |
| * Better makernotes parsing for many cameras |
| |
| * Better parsing of makernotes embedded into DNG files created by |
| Adobe DNG Converter |
| |
| * New imgdata.params.raw_processing_options value: LIBRAW_PROCESSING_ZEROFILTERS_FOR_MONOCHROMETIFFS |
| - If this bit is set |
| - and TIFF file contains SamplesPerPixel == 1 |
| - and filters value was not guessed from metadata parsing |
| LibRaw will assume the file is monochrome, not bayer. |
| This option is needed for monochrome scan processing (Imacon X1 etc). |
| This option may broke old TIF-like RAW files processing (Kodak 760,etc) |
| use with care (it is better to let user choose). |
| |
| 2018-12-12 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Canon: PowerShot A480 (CHDK hack), EOS 2000D, EOS 4000D |
| Eyedeas E1 |
| FujiFilm: GFX 50R, XF10, X-T3, X-T100, DBP680 |
| GITUP G3 DUO (16:9 mode only, use custom camera for 4:3) |
| Kodak PIXPRO AZ901 |
| Leica M10-D, M10-P |
| Nikon D3500, Z6, Z7, P1000 |
| Panasonic LX100M2 |
| Pentax K-1 II |
| Sony A7 III, HX95, HX99, RX100-VA, RX100-VI |
| |
| * Fixed long standing bug in remove_zeroes: first two rows/cols was unprocessed |
| * Better parsing for NEF files modified (damaged) by NikonTransfer |
| * Better parsing for floating point DNG black levels (into color.dnglevels.fblack and dng_fcblack[], similar |
| to color.black and color.cblack[] for other formats). |
| * More flexible limit for RAW decoding memory usage: |
| imgdata.params.max_raw_memory_mb (default is LIBRAW_MAX_ALLOC_MB_DEFAULT) |
| |
| * New flags for imgdata.params.raw_processing_options: |
| LIBRAW_PROCESSING_CHECK_DNG_ILLUMINANT - will check DNG illuminant field when selecting color matrix |
| (note: incompatibility with previous versions, so default is not set). |
| LIBRAW_PROCESSING_DNGSDK_ZEROCOPY - will not copy data from Adobe DNG SDK decoded buffer, but use it as is |
| |
| * Switched from auto_ptr to unique_ptr, to get back define LIBRAW_USE_AUTOPTR |
| |
| * dcraw_emu: it is now possible to create output filename in a more flexible manner, via -Z switch: |
| -Z - will output to stdout |
| -Z ext will output into inputfilename.ext |
| -Z .ext will output into inputfilename.inputext.ext |
| |
| |
| 2018-11-22 Alex Tutubalin <lexa@lexa.ru> |
| * Finally: got Sinar 4shot sample, works fine now |
| * OpenMP critical sections for malloc/free; extra #ifdefs removed; bin/dcraw_dist could be built again using Makefile.devel |
| * additional checks in parse_phase_one() |
| * more checks on file offsets/tag len in parse_minolta |
| * more checks in parse_ciff |
| * Mempool check reworked |
| * Old Leaf (16bit/3color/TIFF) support |
| * Fix cameraWB->autoWB fallback |
| * Polaroid x530 channel swap; get metadata pointer for Foveon files |
| * Fixed Secunia Advisory SA86384 |
| - possible infinite loop in unpacked_load_raw() |
| - possible infinite loop in parse_rollei() |
| - possible infinite loop in parse_sinar_ia() |
| Credits: Laurent Delosieres, Secunia Research at Flexera |
| |
| * LibRaw 0.19.1-Release |
| |
| 2018-06-28 Alex Tutubalin <lexa@lexa.ru> |
| * changed wrong fix for Canon D30 white balance |
| * fixed possible stack overrun while reading zero-sized strings |
| * fixed possible integer overflow |
| * LibRaw 0.19.0-Release |
| |
| 2018-06-11 Alex Tutubalin <lexa@lexa.ru> |
| * Sony uncompressed/untiled DNGs: do not set bits-per-sample to 14 bit |
| * Do not change tiff_bps for DNG files |
| * Another possible stack overflow in kodak radc reader |
| * Secunia Advisory SA83507, credits Kasper Leigh Haabb, |
| Secunia Research at Flexera" |
| - parse_qt: possible integer overflow |
| - reject broken/crafted NOKIARAW files |
| * LibRaw 0.19-Beta6 |
| |
| 2018-05-10 Alex Tutubalin <lexa@lexa.ru> |
| * Put rogue printf's behind #ifdef DCRAW_VERBOSE |
| * Exceptions was not caught in x3f_new_from_file resulting in x3f handle leak |
| * packed_load_raw(): EOF check on each row |
| * define LIBRAW_USE_CALLOC_INSTEAD_OF_MALLOC to use ::calloc instead of |
| ::malloc in LibRaw_mem_mgr malloc calls; |
| Note: realloc is not changed, so only partial fix |
| * Fixed possible div by zero in EOS D30 WB data parse |
| * U-suffix for filter-var manipulation consts |
| * restored static specifier for utf2char() lost in previous bugfix |
| * Fixed stack overrun in kodak_radc_load_raw |
| * Secunia Advisory SA83050: possible infinite loop in parse_minolta() |
| * LibRaw 0.19-Beta5 |
| |
| 2018-05-03 Alex Tutubalin <lexa@lexa.ru> |
| * CVE-2018-10529 fixed: out of bounds read in X3F parser |
| * CVE-2018-10528 fixed: possible stack overrun in X3F parser |
| * LibRaw 0.19-Beta4 |
| |
| 2018-04-24 Alex Tutubalin <lexa@lexa.ru> |
| * LibRaw 0.19-Beta3 |
| * fixed lot of bugs reported by ImageMagic/oss-fuzz |
| * fixed several bugs reported by Secunia team (adv 81800, |
| Credit: Laurent Delosieres, Secunia Research at Flexera) |
| |
| 2018-03-22 Alex Tutubalin <lexa@lexa.ru> |
| * LibRaw 0.19-Beta2 |
| * Better handling of broken JPEG thumbnails |
| * Panasonic GH5S/G9-hires decoder, thanks to Alexey Danilchenko |
| Note: ABI has changed due to this patch, so shlib version increased |
| * Fujifilm X-A5/A20 metadata parsing fix |
| * New error code LIBRAW_TOO_BIG: image data size excess LIBRAW_MAX_ALLOC_MB |
| * winsock2 included before windows.h to make MinGW happy |
| |
| 2018-02-23 Alex Tutubalin <lexa@lexa.ru> |
| |
| * LibRaw 0.19-Beta1 |
| |
| * 84 cameras added compared to 0.18 (1014 total): |
| Apple |
| iPhone 8(*), iPhone 8 plus, iPhone X |
| BlackMagic |
| URSA Mini 4k, URSA Mini 4.6k, URSA Mini Pro 4.6k |
| Canon CHDK hack |
| PowerShot A410, A540, D10, ELPH 130 IS, ELPH 160 IS, SD750, |
| SX100 IS,SX130 IS, SX160 IS, SX510 HS, SX10 IS, IXUS 900Ti |
| Canon |
| PowerShot G1 X Mark III, G9 X Mark II, EOS 6D Mark II, EOS 77D, |
| EOS 200D, EOS 800D, EOS M6, EOS M100 |
| Casio EX-ZR4100/5100 |
| DJI |
| Phantom4 Pro/Pro+, Zenmuse X5, Zenmuse X5R |
| FujiFilm |
| S6500fd, GFX 50S, X100f, X-A3, X-A5, X-A10, X-A20, X-E3, X-H1, X-T20 |
| GITUP GIT2P |
| Hasselblad |
| H6D-100c, A6D-100c |
| Huawei |
| P9 (EVA-L09/AL00), Honor6a, Honor9, Mate10 (BLA-L29) |
| Leica |
| CL, M10, TL2 |
| LG |
| V20 (F800K), VS995, |
| Nikon |
| D850, D5600, D7500, Coolpix B700 |
| Olympus |
| E-PL9, E-M10 Mark III, TG-5 |
| OnePlus |
| One, A3303, A5000 |
| Panasonic |
| DMC-FZ45, DMC-FZ72, DC-FZ80/82, DC-G9 (std. res mode only), DC-GF10/GF90, |
| DC-GH5, DC-GX9, DC-GX800/850/GF9, DMC-LX1, DC-ZS70 (DC-TZ90/91/92, DC-T93), |
| DC-TZ100/101/ZS100, DC-TZ200/ZS200 |
| PARROT |
| Bebop 2, Bebop Drone |
| Pentax KP |
| PhaseOne IQ3 100MP Trichromatic |
| Samsung |
| Galaxy Nexus, Galaxy S3, S6 (SM-G920F), S7, S7 Edge, S8 (SM-G950U), |
| Sony |
| A7R III, A9, DSC-RX0, DSC-RX10IV |
| Yi M1 |
| YUNEEC |
| CGO3, CGO3P |
| Xiaoyi YIAC3 (YI 4k) |
| |
| Note(*): for mobile phones with DNG format recording, only really tested cameras |
| are added to supported camera list. Really LibRaw should support any correct DNG. |
| |
| * No more built-in support for LibRaw demosaic packs (GPL2/GPL3). |
| We're unable to support this (very old code), so we'll be happy to transfer this |
| code to some maintainer who wish to work with it. |
| |
| In LibRaw 0.19 we provide extension API: user-settable callbacks to be called in |
| code points where demosaic pack code was called. |
| |
| - int callbacks.pre_identify_cb(void *) => to be called in LibRaw::open_datastream |
| before call to (standard) identify() function. If this call returns 1, this means |
| that RAW file is identified and all metadata fields are set, so no need to run |
| standard identify code. |
| - void callbacks.post_identify_cb(void*) => called just after identify(), but before |
| any cleanup code; |
| - dcraw_process() callbacks are called before dcraw_process phases (name speaks for itself): |
| pre_subtractblack_cb, pre_scalecolors_cb, pre_preinterpolate_cb, pre_interpolate_cb, |
| interpolate_bayer_cb, interpolate_xtrans_cb, post_interpolate_cb, pre_converttorgb_cb, |
| post_converttorgb_cb |
| |
| All these new callbacks are called with (this) as the only arg. |
| To continue LibRaw-demosaic-pack-GPLx support one need to subclass LibRaw, set needed |
| callbacks in (e.g.) constructor code, than these callbacks to be called |
| |
| * Better DNG parser: |
| - support for DefaultCrop Origin/Size tags (add LIBRAW_PROCESSING_USE_DNG_DEFAULT_CROP to raw_processing_options to enable) |
| - better parsing for nested DNG tags (use tag from RAW IFD, fallback to IFD0 if no tag in current IFD) |
| - DNG PreviewColorspace extracted into dng_levels.preview_colorspace |
| |
| * Metadata extraction: |
| - Better extraction of camera measured balance (LIBRAW_WBI_Auto and WBI_Measured), |
| this not the same as 'as shot' if some preset/manual tune is used. |
| - Extraction of camera custom balances (LIBRAW_WBI_CustomN) |
| - Nikon data compression tag extracted into makernotes.nikon.NEFCompression |
| - Hasselblad BaseISO and Gain extracted into makernotes.hasselblad |
| - Canon multishot params extracted into makernotes.canon.multishot |
| - lot of other vendor-specific makernotes data (see data structures definitions for details). |
| |
| * New LibRaw::open_bayer call allows to pass sensor dump w/o metadata directly to LibRaw: |
| virtual int open_bayer(unsigned char *data, unsigned datalen, |
| ushort _raw_width, ushort _raw_height, ushort _left_margin, ushort _top_margin, |
| ushort _right_margin, ushort _bottom_margin, |
| unsigned char procflags, unsigned char bayer_pattern, unsigned unused_bits, unsigned otherflags, |
| unsigned black_level); |
| Parameters: |
| data, datalen - buffer passed |
| width/height/margins - speaks for itself |
| procflags: |
| for 10-bit format: |
| 1: "4 pixels in 5 bytes" packing is used |
| 0: "6 pixels in 8 bytes" packing is used |
| for 16-bit format: |
| 1: Big-endian data |
| bayer_pattern: one of LIBRAW_OPENBAYER_RGGB,LIBRAW_OPENBAYER_BGGR, |
| LIBRAW_OPENBAYER_GRBG,LIBRAW_OPENBAYER_GBRG |
| unused_bits: count of upper zero bits |
| otherflags: |
| Bit 1 - filter (average neighbors) for pixels with values of zero |
| Bits 2-4 - the orientation of the image (0=do not rotate, 3=180, 5=90CCW, 6=90CW) |
| black_level: file black level (it also may be specified via imgdata.params) |
| |
| see samples/openbayer_sample.cpp for usage sample (note, this sample is 'sample only', suited for |
| Kodak KAI-0340 sensor, you'll need change open_bayer() params for your data). |
| |
| * Color data added/updated/fixed for many cameras |
| |
| * Correct data maximum for Fuji X-* cameras |
| |
| * Thumbnail processing: |
| - JPEG thumbnails: if compiled with libjpeg, color count is extracted into imgdata.thumbnail.tcolors |
| - PPM (bitmap) thumbnails: color count is set according to thumbnail IFD tag |
| - PPM16 thumbnails: if LIBRAW_PROCESSING_USE_PPM16_THUMBS set in raw_processing_options, than thumbnail will be extracted |
| as is, not converted to 8 bit. thumbnail.tformat is set to LIBRAW_THUMBNAIL_BITMAP16 in this case. |
| Untested, because it is hard to find RAWs with 16-bit bitmaps. |
| |
| == Compatibility fixes |
| |
| * struct tiff_tag renamed to libraw_tiff_tag |
| * pow64f renamed to libraw_pow64f |
| |
| == Bugs fixed: |
| |
| * COLOR(r,c) works correctly on X-Trans files |
| |
| == Security fixes: |
| Secunia #81000: |
| Credit: Laurent Delosieres, Secunia Research at Flexera |
| * leaf_hdr_load_raw: check for image pointer for demosaiced raw |
| * NOKIARAW parser: check image dimensions readed from file |
| * quicktake_100_load_raw: check width/height limits |
| |
| Secunia #79000: |
| Credit: Laurent Delosieres, Secunia Research at Flexera |
| * All legacy (RGB raw) image loaders checks for imgdata.image is not NULL |
| * kodak_radc_load_raw: check image size before processing |
| * legacy memory allocator: allocate max(widh,raw_width)*max(height,raw_height) |
| |
| Secunia #76000: |
| * Fixed fuji_width handling if file is neither fuji nor DNG |
| * Fixed xtrans interpolate for broken xtrans pattern |
| * Fixed panasonic decoder |
| * LibRaw 0.18.6 |
| |
| Other fixes: |
| * Checks for width+left_margin/height+top_margin not larger than 64k |
| * LIBRAW_MAX_ALLOC_MB define limits maximum image/raw_image allocation |
| (default is 2048 so 2Gb per array) |
| * LibRaw::read_shorts item count is now unsigned |
| * Fixed possible out of bound access in Kodak 65000 loader |
| * CVE-2017-14348: Fix for possible heap overrun in Canon makernotes parser |
| Credit: Henri Salo from Nixu Corporation |
| * Fix for CVE-2017-13735 |
| * CVE-2017-14265: Additional check for X-Trans CFA pattern data |
| * Fixed several errors (Secunia advisory SA75000) |
| * ACES colorspace output option included in dcraw_emu help page |
| * Avoided possible 32-bit overflows in Sony metadata parser |
| * Phase One flat field code called even for half-size |
| |
| |
| 2016-12-27 Alex Tutubalin <lexa@lexa.ru> |
| * Licensing changes: |
| - there is no 'LibRaw Software License 27032010' licensing anymore (and all signed |
| agreements have expired) |
| - LibRaw is now dual-licensed: LGPL 2.1 or CDDL 1.0 |
| |
| * Camera support (+87): |
| Apple: iPad Pro, iPhone SE, iPhone 6s, iPhone 6 plus, iPhone 7, iPhone 7 plus |
| BlackMagic Micro Cinema Camera, URSA, URSA Mini |
| Canon PowerShot G5 X, PowerShot G7 X Mark II, PowerShot G9 X, |
| IXUS 160 (CHDK hack), EOS 5D Mark IV, EOS 80D, EOS 1300D, EOS M10, EOS M5, |
| EOS-1D X Mark II |
| Casio EX-ZR4000/5000 |
| DXO One, |
| FujiFilm X-Pro2, X70, X-E2S, X-T2 |
| Gione E7 |
| GITUP GIT2 |
| Google Pixel,Pixel XL |
| Hasselblad X1D, True Zoom |
| HTC MyTouch 4G, One (A9), One (M9), 10 |
| Huawei P9 |
| Leica M (Typ 262), M-D (Typ 262), S (Typ 007), SL (Typ 601), X-U (Typ 113), TL |
| LG G3, G4 |
| Meizy MX4 |
| Nikon D5, D500, D3400 |
| Olympus E-PL8, E-M10 Mark II, Pen F, SH-3, E-M1-II |
| Panasonic DMC-G8/80/81/85, DMC-GX80/85, DMC-TZ80/81/85/ZS60, DMC-TZ100/101/ZS100,DMC-LX9/10/15, FZ2000/FZ2500 |
| Pentax K-1, K-3 II, K-70 |
| PhaseOne IQ3 100MP |
| RaspberryPi Camera, Camera V2 |
| Ricoh GR II |
| Samsung Galaxy S7, S7 Edge |
| Sigma sd Quattro |
| Sony A7S II, ILCA-68 (A68),ILCE-6300,DSC-RX1R II,DSC-RX10III, DSC-RX100V,ILCA-99M2 (A99-II), a6500 |
| IMX214, IMX219, IMX230, IMX298-mipi 16mp, IMX219-mipi 8mp, Xperia L |
| PtGrey GRAS-50S5C |
| YUNEEC CGO4 |
| Xiaomi MI3, RedMi Note3 Pro |
| |
| * Floating point DNG support: |
| - new data fields: |
| imgdata.rawdata.float_image - bayer float data |
| imgdata.rawdata.float3_image - 3-component float data |
| imgdata.rawdata.float4_image - 4-component float data |
| imgdata.color.fmaximum - float data maximum (calculated from real data, |
| rounded to 1.0 if below 1.0) |
| - new raw processing flag |
| LIBRAW_PROCESSING_CONVERTFLOAT_TO_INT - converts float data to 16-bit |
| integer immediately after decoding with default parameters |
| - new API Calls: |
| int LibRaw::is_floating_point() returns non-zero if RAW file contains |
| floating point data |
| int LibRaw::have_fpdata() returns non-zero if rawdata.float*_image is not |
| null (so FP data has been unpacked but not converted to integrer, see below). |
| LibRaw::convertFloatToInt(float dmin=4096.f, float dmax=32767.f, float dtarget = 16383.f) |
| converts float/float3/float4_image to raw_image/color3/color4_image with or without scaling: |
| - if both real data maximum and metadata maximum are within the range ( >= dmin && <=dmax), float |
| data is just converted to integer |
| - if data is out of the range given above, values are scaled so real data maximum becomes dtarget |
| - if data was rescaled (normalized), scale multiplier is stored in imgdata.color.fnorm |
| |
| * LibRaw can be built with Adobe DNG SDK support to decode exotic DNG formats (e.g. 8 bit). |
| See README.DNGSDK.txt for details |
| |
| * New API calls |
| unsigned LibRaw::capabilities and C-API libraw_capabilities() |
| allows developers to determine LibRaw compile flags at runtime. |
| Returns ORed bit fields: |
| LIBRAW_CAPS_RAWSPEED - LibRaw was compiled with RawSpeed Support |
| LIBRAW_CAPS_DNGSDK - LibRaw was compiled with Adobe DNG SDK |
| LIBRAW_CAPS_DEMOSAICSGPL2, LIBRAW_CAPS_DEMOSAICSGPL3 - LibRaw was compiled with demosaic packs (GPL2/GPL3) |
| |
| * More metadata parsed: |
| - White balance coefficients stored in the raw file are extracted into: |
| int imgdata.color.WBCoeffs[256][4] - array indexed by EXIF lightsource type |
| for example, WBCoeffs[21][..] contains coefficients for D65 lightsource |
| float imgdata.color.WBCT_Coeffs[64][5] contains white balance data specified |
| for given color temperature: WBCT_Coeffs[i][0] contains temperature value, |
| and [1]..[4] are WB coefficients. |
| - DNG analog balance, per-channel black/white level, and forward matrix |
| - vendor specific metadata stored in vendor-specific data structures |
| |
| * new C-API calls: |
| void libraw_set_user_mul(libraw_data_t *lr,int index, float val); |
| void libraw_set_ca_correction(libraw_data_t *lr,int ca_correc, float ca_red, float ca_blue); |
| void libraw_set_cfalinenoise(libraw_data_t *lr,int cfaline, float linenoise); |
| void libraw_set_wf_debanding(libraw_data_t *lr, int wf_debanding, float wfd0, float wfd1, float wfd2, float wfd3); |
| void libraw_set_interpolation_passes(libraw_data_t *lr,int passes); |
| |
| * Existing API changes: |
| imgdata.params fields (all very specific purpose): sony_arw2_options, sraw_ycc, and params.x3f_flags |
| replaced with single bit-field raw_processing_options |
| See LIBRAW_PROCESSING_* bits in documentation. |
| |
| * zlib library is optional |
| Use -DUSE_ZLIB to compile with zlib (to provide deflate DNG support) |
| * libjpeg version: jpeg_mem_src() is mandatory, so use libjpeg-turbo |
| or libjpeg 8+ |
| * Fixes in vng_interpolate to make modern compilers happy |
| * Fixed bug in Sony SR2 files black level |
| * DNG files with BlackLevel both in vendor makernotes and BlackLevel: |
| BlackLevel tag always takes precedence |
| * strlen replaced with strnlen in most cases, added local version of strnlen |
| * ChannelBlackLevel added to canon makernotes |
| * unpack_thumb() data size/offset check against file size |
| |
| 2015-08-15 Alex Tutubalin <lexa@lexa.ru> |
| |
| * LibRaw 0.17 |
| |
| * Fixed dcraw.c ljpeg_start possibly buffer overrun |
| |
| * fixed several bugs detected by using American Fuzzy Lop |
| |
| * C-API extension to support 3DLut Creator |
| |
| * More metadata parsing/extraction: |
| - XMP packet extracted (if exists) |
| - DNG Color information parsed |
| - GPS data (partially) parsed |
| - EXIF/Makernotes parsed for used optics (for both RAW files and DNG converted by Adobe convertor). |
| |
| * Exif/Makernotes parser callback (called for each processed tag) |
| |
| * Sony ARW2.3 decoder: |
| - params.sony_arw2_hack removed, decoded data are always in 0...17k range (note the difference with dcraw!) |
| - Additional processing options for Sony lossy compression technical analysis. |
| |
| * Dcraw 9.26 imported (but some changes not approved because Libraw do it better) with some exceptions: |
| - no Pentax K3-II frame selection code |
| - no built-in JPEG decompressor |
| |
| * Many improvements in data decoding/processing: |
| - Correct decoding of black level values from metadata for many formats, LibRaw do not rely on hardcoded black levels. |
| |
| * 224 camera models added to supported camera list. |
| Some of them are new (released since LibRaw 0.16 come out), some was supported before, but missed from the list. |
| Added cameras are: |
| |
| Alcatel 5035D |
| BlackMagic Pocket Cinema Camera, Production Camera 4k |
| Canon PowerShot A550, A3300 IS, G1 X Mark II, G7 X, SD950, SX60 HS, EOS 7D Mark II, EOS 20Da, EOS 60Da, EOS 1200D, EOS-1D C, 5DS, 5DS R, 750D, 760D, M2, M3, G3 X |
| Casio EX-FC300S, EX-FC400S, EX-Z1080, EX-ZR700, EX-ZR710, EX-ZR750, EX-ZR800, EX-ZR850, EX-ZR1000, EX-ZR1100, ZR1200, ZR1300, EX-ZR1500, EX-100, EX-10 |
| Digital Bolex D16,D16M |
| DJI 4384x3288, |
| Epson R-D1s, R-D1x |
| FujiFilm E505,S1,S205EXR,HS10,HS11,HS22EXR,HS33EXR,HS35EXR,F505EXR,F605EXR,F775EXR,F900EXR,X100T,X30,X-T1,X-T1 Graphite Silver, XQ2, X-A2, X-T10 |
| Hasselblad H5D-60, H5D-50,H5D-50c,H5D-40,H4D-60,H4D-50,H4D-40,H4D-31,H3DII-22,H3DII-31,H3DII-39,H3DII-50,H3D-22,H3D-31,H3D-39,H2D-22,H2D-39,CF-22,CF-31,CF-39,Stellar II,HV |
| HTC UltraPixel |
| Imacon Ixpress 96, 96C, 384, 384C (single shot only),132C, 528C (single shot only) |
| ISG 2020x1520 |
| Ikonoskop A-Cam dII Panchromatic, A-Cam dII |
| Kinefinity KineMINI, KineRAW Mini, KineRAW S35 |
| Kodak DCS460D, S-1 |
| Leaf Credo 50 |
| Lenovo a820 |
| Leica Digital-Modul-R, D-Lux (Typ 109), M (Typ 240), Monochrom (Typ 240), M-E, M-P, R8, S, T (Typ 701), X (Typ 113), X2, X-E (Typ 102), V-Lux (Typ 114), Monochrom (Typ 246), Q |
| Matrix 4608x3288 |
| Nikon D4s, D600, D610, D750, D800, D800E, D810, D3300, D5500, Df, 1 J4, 1 S2, 1 V3, Coolpix P340, Coolscan NEF, D7200, 1 J5,D810A |
| Nokia 1200x1600 |
| Olympus E-450, E-600, E-PL6, E-PL7, E-M1, E-M10, E-M5 Mark II, SP565UZ, STYLUS1s, SH-2, TG-4, AIR-A01 |
| Panasonic DMC-CM1, DMC-FZ7, DMC-FZ70, DMC-FZ1000, DMC-GF7, DMC-GH4, AG-GH4, DMC-GM1s, DMC-GM5, DMC-LX100, DMC-TZ60/61/SZ40, DMC-TZ70, FZ300/330, GX8 |
| Pentax GR, K110D, K-01, K-S1, Q, QS-1, 645Z, K-S2, K3 II |
| PhaseOne IQ250, IQ260, IQ260 Achromatic, IQ280, Achromatic+, P 20+, P 21, P 25+, P 30+, P 40+ |
| Ricoh GXR MOUNT A12, GXR MOUNT A16 24-85mm F3.5-5.5, GXR, S10 24-72mm F2.5-4.4 VC, GXR, GR A12 50mm F2.5 MACRO, GXR, GR LENS A12 28mm F2.5, GXR, GXR P10 |
| Samsung GX-1L, NX1, NX5, NX1000, NX1100, NX30, NX300, NX300M, NX3000, NX mini, Galaxy S3, Galaxy Nexus, NX500 |
| Sigma dp1 Quattro, dp2 Quattro, dp3 Quattro, dp0 Quattro |
| Sinar eMotion 22, eMotion 54, eSpirit 65, eMotion 75, eVolution 75, Sinarback 54 |
| Sony A7 II, A7S, ILCA-77M2 (A77-II), ILCE-3000, ILCE-5000, ILCE-5100, ILCE-6000, ILCE-QX1, DSC-RX100III, DSLR-A560, NEX-VG20, NEX-VG30, NEX-VG900, IMX135-mipi 13mp, IMX135-QCOM, IMX072-mipi, RX100-IV, A7R-II, RX10-II |
| |
| * Fujifilm F700/S20Pro second frame support |
| |
| 2014-02-01 Alex Tutubalin <lexa@lexa.ru> |
| * Updated Oly E-M10 & Panasonic TZ60/61 color data |
| * Updated foveon SD9-14 white level |
| * Support for 1x1 BlackLevelRepeatDim |
| |
| 2014-01-31 Alex Tutubalin <lexa@lexa.ru> |
| * imported dcraw 1.461: fixed error in BlackLevelDim handling |
| * Accurate work with pattern black-level (cblack[6+]) |
| * Support for Olympus E-M10 and Fujifilm X-T1 |
| * Adjusted possible maximum value for Sigma SD9 small raws |
| |
| 2014-01-27 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 1.460: Nikon D3300, Panasonic DMC-TZ61, Sony ILCE-5000 |
| 2014-01-25 Alex Tutubalin <lexa@lexa.ru> |
| * PhaseOne IQ250 support (both compressed and uncompressed) |
| 2014-01-21 Alex Tutubalin <lexa@lexa.ru> |
| * imgdata.params.sony_arw2_hack removed. |
| It always on for ARW2-files. |
| * New imgdata.params.sony_arw2_options processing flags |
| Values: |
| LIBRAW_SONYARW2_NONE - normal processing |
| LIBRAW_SONYARW2_BASEONLY - BASE pixels outputeed, delta pixels set to 0 |
| LIBRAW_SONYARW2_DELTAONLY - Delta pixels written to raw data, base pixels zeroed |
| LIBRAW_SONYARW2_DELTAZEROBASE - Only deltas written without base offset |
| |
| 2014-01-20 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 9.20: |
| - Support for DNG BlackLevelRepeatDim tags |
| - imgdata.color.cblack[] holds variable BlackLevel for DNG files (up to ~4k values) |
| - imgdata.params.use_camera_matrix is now ON by default. Set it to 3 if you want |
| to force use of DNG embedded matrix. |
| - Tone curve for Canon RMF format supported |
| - Color data for Canon C500 |
| * Additional camera support: |
| Alcatel 5035D |
| DJI 4384x3288 |
| Fujifilm F900EXR |
| Kodak 12MP |
| Matrix 4608x3288 |
| Nokia 1200x1600 |
| Olympus E-PL6 |
| Panasonic DMC-FZ7 |
| |
| 2014-01-17 Alex Tutubalin <lexa@lexa.ru> |
| * Camera support: |
| Added: Fujifilm XE2, XQ1 |
| Color data updated: Nikon D4 1 AW1/J3, Fuji X-M2 |
| Fixes: Nikon D610 visible image area, Canon A3300 bayer |
| pattern |
| * RawSpeed support: enabled processing for cameras, |
| unknown to RawSpeed |
| * Fixed error in LibRaw::unpack_thumb() |
| * little improve performance in my_strcasestr |
| * Fix compiler errors for VS2012/OpenMP |
| * Fixed typo which prevents to use Demosaic Pack GPL2 |
| * LibRaw 0.16.0-Release |
| |
| 2013-11-15 Alex Tutubalin <lexa@lexa.ru> |
| * New cameras supported |
| Leica C, X VARIO |
| Nikon D5300, D610, Df, 1 AW1 |
| Nokia Lumia 1020, 1520 |
| Olympus STYLUS1 |
| Pentax K-3 |
| Sony RX10, A3000 (ILCE-3000), |
| * Color data updated: |
| Canon S120 |
| Nikon P7800, 1 J3 |
| Olympus E-M1 |
| * Corrected image visible area sizes |
| Canon G16 |
| Sigma pre-Merrill cameras: small and medium-sized RAWs |
| |
| * Better EXIF parsing: |
| - ISO values for new Nikon cameras (D4, D800) |
| - black level extraction for Nikon D5300 |
| - correct Olympus color data conversion |
| |
| * Better Visual Studio compatibility (esp. old versions) |
| * Cmake build: added ws2_32 library for MinGW builds |
| * LibRaw 0.16.0-Beta1 |
| |
| 2013-10-22 Alex Tutubalin <lexa@lexa.ru> |
| * Support for new cameras: |
| Sony A7, A7R |
| Panasonic GM1 |
| |
| * Sony RX1R and RX100M2 color data updated. |
| |
| * Sony cameras model name is set by SonyModelID EXIF tag |
| |
| * Sony ARW2: black level and color matrix extracted from EXIF data |
| |
| * Samsung: black level and color matrix extracted from EXIF; |
| Camera multipliers are now extracted correctly even if black is not 0 |
| |
| * Better source compatibility with Mac OS X compilation |
| |
| * Better source compatibility with Win32 compilation |
| |
| * DNG without Compression tag assumed uncompressed |
| |
| * Better X3F-tools based Foveon support: |
| - new Foveon metadata parser based on X3F-tools. So, if LibRaw compiled |
| without demosaic-pack-GPL2, then no dcraw Foveon code used. |
| - Support for Medium resolution RAWs from DPx Merrill and SD1 cameras. |
| RAW data extracted as is (4800x1600 pixels), aspect ratio is set to |
| 0.5, so these RAWs are processed to full-size 4800x3200 RGB. |
| - Support for Foveon thumbnail extraction. Only JPEG and bitmap |
| thumbnails extracted, but 'foveon' (RAW) thumbnails are really not used |
| in production cameras. |
| - New imgdata.params.force_foveon_x3f flag |
| Forces use of x3f-tools based code for Foveon processing if LibRaw |
| compiled with demosaic-pack-GPL2 (and does nothing if LibRaw compiled |
| without this pack). |
| New flag -disadcf added to dcraw_emu sample to use this flag. |
| - LibRaw do not calls exit() on broken Foveon files. |
| |
| * API/ABI changed, so all code using LibRaw should be recompiled. |
| |
| * LibRaw 0.16.0-Alpha3 |
| |
| |
| 2013-10-16 Alex Tutubalin <lexa@lexa.ru> |
| * Support for new cameras: |
| Canon S120 (preliminary color data), G16 |
| Fujifilm X-A1 (preliminary color data) |
| Hasselblad Lunar, Stellar |
| Nikon P7800 (preliminary color data) |
| Pentax K50, K500, Q7 |
| Samsung Galaxy NX (EK-GN120) |
| Sony NEX-5T |
| |
| * Updated color data for: |
| Samsung NX300 |
| Sony RX1R |
| Sigma SD1, SD1 Merrill, DPxx (only if non-GPL2 foveon decoder used) |
| |
| * Image dimensions table for Foveon cameras (only if |
| non-GPL2 foveon decoder used) |
| |
| * Fixed memory leak in x3f-tools code (new Foveon decoder) |
| * Fixed DHT-demosaic incompatibility with MS VisualStudio in OpenMP directives |
| * Additional image size checks. |
| * LibRaw 0.16-Alpha2 |
| |
| 2013-09-22 Alex Tutubalin <lexa@lexa.ru> |
| * Support for new cameras: |
| Baumer TXG14 |
| Blackmagic Cinema |
| Canon EOS 70D, C500 |
| Fujifilm X-M1 |
| Nikon D5200 |
| Olympus E-P5,E-M1 |
| OmniVision OV5647 (Raspberry Pi) |
| Panasonic LF1, GX7, GF6 |
| Richon GR |
| Samsung NX300, NX1100, NX2000 |
| Sony RX100II, RX1R, NEX-3N |
| |
| * Support for Foveon sensor based on X3F code by Roland Karlsson |
| BSD-like license, so included in main LibRaw code. |
| No 'foveon interpolation', so no way to get good colors from |
| old Sigma cameras (SD9, SD14, Polaroid x530). For modern Foveon cameras |
| one may try to create ICC profile (not supplied). |
| |
| TODO: thumbnail extraction, fast cancellation |
| |
| Old foveon_*_load_raw (from dcraw) code is used if compiled with |
| LIBRAW_DEMOSAIC_PACK_GPL2 |
| |
| * API Changes: |
| |
| + New parameters in imgdata.params: |
| - imgdata.params.no_interpolation - disables interpolation step in |
| LibRaw::dcraw_process() call. |
| - imgdata.params.no_auto_scale - disables call to scale_colors() in |
| LibRaw::dcraw_process() call. |
| - imgdata.params.sraw_ycc - disables Canon sRAW YCbCr to RGB conversion |
| in LibRaw::unpack() call (use for RAW analyzers |
| |
| + New Fuji X-Trans handling: |
| - imgdata.iparams.filters value is now 9 for Fuji X-Trans (instead of 2) |
| - imgdata.iparams.xtrans[6][6] matrix contains row/col to color mapping |
| for Fuji X-Trans sensor. |
| |
| + LibRaw::setCancelFlag() - use for fast decoder termination |
| |
| + LibRaw_abstract_datastream::make_byte_buffer() call is not needed more. |
| |
| + New demosaic code: DHT Demosaic by Anton Petrusevich |
| Set params.user_qual=11 to use. |
| |
| + New demosaic code: Modified AHD Demosaic by Anton Petrusevich |
| Set params.user_qual=12 to use. |
| |
| + New C-API call libraw_COLOR(libraw_data_t *t, int row,int col) |
| (so LibRaw::COLOR(row,col) exposed to C-API users) |
| |
| * Removed faster lossless jpeg decoder ported from RawSpeed library |
| some years ago. Build LibRaw with RawSpeed to get fast decoding. |
| |
| * Fixed decoding error for some Canon sRAW files. |
| |
| * Disabled RawSpeed's bad pixel processing if RawSpeed used. |
| |
| * EOS M and EOS 70D added to unique Canon ID table |
| |
| * Canon EOS model name normalized by unique ID table |
| |
| * Backported 0.15.4 input data checks |
| |
| * Support for CMake builds |
| |
| * Updated RawSpeed supported camera list |
| |
| * Internals changed, so all code using LibRaw should be recompiled. |
| |
| * LibRaw 0.16.0-Alpha1 |
| |
| 2013-05-23 Alex Tutubalin <lexa@lexa.ru> |
| |
| LibRaw 0.15-Release |
| |
| New camera/format support: |
| * Adobe DNG: fast Load DNG (LightRoom 4.x), support for |
| lossy-compressed DNG (LR 4.x, requires libjpeg 6+) |
| * Canon: G1 X, SX220 HS, EOS 5D Mark III, EOS 650D, EOS 1D-X, |
| 100D (Rebel SL1), 700D (Rebel T5i), 6D, EOS M, G15, S110, SX50 |
| * Casio: EX-ZR100,EX-Z8 |
| * Fujifilm: X-S1, HS30EXR, X1-Pro,X-E1, X20, X100S, SL1000, HS50EXR, |
| F800EXR, XF1 |
| * Leica: D-LUX6 and V-LUX4 |
| * Nikon: D4, D3200, D800, D800E, 1 J2, 1 V2, D600, 1 J3, 1 S1, Coolpix A, |
| Coolpix P330, Coolpix P7700, D7100 |
| * Olympus: E-M5, XZ-2, XZ-10, E-PL5, E-PM2 |
| * Panasonic: G5, G6, DMC-GF5, FZ200, GH3, LX7 |
| * Pentax: MX-1, K-5 II, K-5 IIs, K-30, Q10 |
| * Samsung: EX2F, NX20, NX210, support for the new firmware for NX100 |
| * Sigma: SD15, SD1, SD1 Merill, DP1, DP1S, DP1X, DP2, DP2S, DP2X |
| (only with Demosaic-pack-GPL2) |
| * Sony: SLT-A58, RX-1, SLT-A99, NEX-5R, NEX-6, NEX-F3, SLT-A37, SLT-A57 |
| * Multishot files: Imacon Ixpress 39Mpix |
| |
| API changes: |
| 1. dcraw_process() can now be called several times with different parameters |
| without re-opening and unpacking the file for second and consecutive |
| calls to dcraw_process |
| |
| 2. deleted (nobody uses those) |
| - LibRaw::dcraw_document_mode_processing (and respective C-API) |
| - imgdata.color.color_flags data field |
| |
| 3. LibRaw::unpack() now decodes data into different buffers, the buffer |
| depends on the raw data type |
| - imgdata.rawdata.raw_image - 1 color component per pixel, |
| for b/w and Bayer type sensors |
| - imgdata.rawdata.color3_image - 3 color components per pixel, |
| sRAW/mRAW files, RawSpeed decoding |
| - imgdata.rawdata.color4_image - 4 components per pixel, the 4th |
| component can be void |
| |
| 4. Support for compiling with RawSpeed library, http://rawstudio.org/blog/?p=800 |
| details are in README.RawSpeed |
| |
| 5. Suppression of banding |
| |
| 6. New API calls |
| - recycle_datastream(), |
| - open_file(wchar_t*) (Win32) |
| |
| |
| 2012-04-05 Alex Tutubalin <lexa@lexa.ru> |
| * Casio EX-Z500 support |
| * (possible) I/O exceptions on file open caught in open_datastream |
| * Fixed possible read-after-buffer in Sony ARW2 decoder |
| * Fixed mingw32 errors when compiling LibRaw_windows_datastream |
| * Makefile.msvc: support of OpenMP and LCMS (uncomment to use) |
| * Fixed decoding of some Leaf Aptus II files |
| * LibRaw 0.14.6-Release |
| |
| 2011-12-24 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug (uninitialized variable) in SMAL format decoding. |
| |
| * Imported new dcraw 9.12 (1.446): support for Leica V-LUX 3, |
| updated color data for Canon S100, Fujifilm X10, Nikon 1 J1/V1, |
| Panasonic GX1, Samsung NX200, Sony NEX-7 |
| |
| * LibRaw 0.14.5-Release |
| |
| 2011-12-12 Alex Tutubalin <lexa@lexa.ru> |
| |
| * Fixes to Panasonic/Leica file parser to prevent crash |
| on broken jpegs. |
| |
| * Fixes to include order in src/libraw_datastream.cpp to |
| better compile with KDEWIN |
| |
| * Floating-point DNGs are rejected on early processing stage. |
| |
| * Support for new cameras: Canon S100, Fuji X10, Panasonic GX1, |
| Samsung NX200, Sony NEX-7. |
| |
| * LibRaw 0.14.4-Release |
| |
| |
| 2011-10-26 Alex Tutubalin <lexa@lexa.ru> |
| * Bug fixes in black level subtraction code for PhaseOne files |
| |
| * New API call LibRaw::get_internal_data_pointer() for developers |
| who need access to libraw_internal_data fields (i.e. |
| Fuji SuperCCD layout). |
| |
| * doc/API-overview fixes to reflect 0.14 changes |
| |
| * LibRaw 0.14.3-Release |
| |
| 2011-10-19 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in Canon 1D and 1Ds files decoding. |
| * New decoder information bit DECODER_HASRAWCURVE |
| * LibRaw 0.14.2-Release |
| |
| 2011-10-11 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 9.11/1.445: |
| + Support for new cameras added: Fujifilm F600EXR, Nikon P7100, |
| Olympus E-PL3 and E-PM1, Panasonic DMC-FZ150, Sony NEX-5N, |
| A65 and A77. |
| + Changed color data for: Olympus E-P3, Panasonic G3 and GF3, |
| PhaseOne H25, P40 and P65, Sony NEX-C3, NEX-5, NEX-3, A35 and A55. |
| + Support for dark frame extraction on Sony cameras. |
| |
| * DCB demosaicing: reserving 6 pixels instead of 3 to suppress |
| colored image frame. |
| * LibRaw 0.14.1-Release |
| |
| 2011-09-21 Alex Tutubalin <lexa@lexa.ru> |
| * Cosmetic changes to make Visual C++/OpenMP more happy |
| * Fix megapixel calculation for postprocessing_benchmark in half mode |
| * Shlib version number increment |
| * LibRaw 0.14.0-Release |
| |
| 2011-09-04 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug with Kodak thumbnail extraction |
| * raw2image_ex() always return value |
| * LibRaw 0.14.0-Beta2 |
| |
| 2011-09-02 Alex Tutubalin <lexa@lexa.ru> |
| * Cosmetic changes to LibRaw_file_datastream interface |
| |
| * OpenMP speedup of postprocessing steps (up to 50% for |
| half mode and 4-core machine) |
| |
| * LibRaw 0.14.0-Beta1 |
| |
| 2011-08-20 Alex Tutubalin <lexa@lexa.ru> |
| |
| * Patch to dcraw_emu for SunStudio compiler compatibility |
| |
| * Fixed crash in unprocessed_raw sample due to uninitialized |
| timestamp variable. |
| |
| * Fixed crash in raw decoding if raw_width/raw_height is |
| less than resulting image width/height. |
| |
| * imgdata.sizes.flip is set from user_flip only on |
| postprocessing and/or adjust_sizes_info_only() |
| |
| * Fixed buffer overrun for some LJPEG-compressed files |
| |
| * Most of LibRaw_datastream function bodies are moved to |
| separate source file |
| |
| * LibRaw_windows_datastream is merged to main sourcetree |
| |
| * LibRaw 0.14.0-Alpha5 |
| |
| 2011-08-11 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 9.10 (1.444), support for new cameras added: |
| ARRIRAW format, Canon SX30 IS, Leica D-LUX 5 and V-LUX2, |
| Olympus E-P3, Panasonic G3 and GF3, Sony NEX-C3 and SLT-A35 |
| |
| * Support for RedOne digital movie cameras (R3D format). |
| To enable this support you should: |
| + install libjasper JPEG2000 support library |
| |
| + compile LibRaw with -DUSE_JASPER compiler switch (./configure |
| will do it for you) |
| |
| + If you use own LibRaw_datastream implementation, you should |
| implement make_jas_stream() call for your datastream. See |
| bottom of src/libraw_cxx.cpp for implementations in datafile |
| and mem-buffer LibRaw streams. |
| |
| * Bugfix: green matching is turned off if output image is shrinked |
| due to wavelet filtering or aberration correction. |
| |
| * fixed open_file()/adjust_sizes_info_only() code path |
| |
| * Removed imgdata.sizes.bottom_margin and right_margin data fields |
| use imgdata.sizes.raw_width - width - left_margin to get right one, |
| the same with bottom_margin. |
| |
| * minor ./configure cleanup |
| |
| * Qmake files and Visual Studio Project files are updated. |
| |
| * New version check macros: |
| For use at runtime checks: |
| LIBRAW_RUNTIME_CHECK_VERSION_EXACT() - checks that runtime |
| major/minor version numbers are same with compile-time values. |
| |
| LIBRAW_RUNTIME_CHECK_VERSION_NOTLESS() - checks that runtime |
| version is not less that compile-time one. |
| |
| For use at compile-time in preprocessor directives: |
| LIBRAW_COMPILE_CHECK_VERSION_EXACT(major,minor) - Compile-time |
| check that LibRaw version is exact major.minor. |
| |
| LIBRAW_COMPILE_CHECK_VERSION_NOTLESS(major,minor) - Compile-time |
| check that version is not less than major.minor. |
| |
| * all client code should be recompiled due to internals change. |
| |
| * LibRaw 0.14.0-Alpha4 |
| |
| 2011-07-19 Alex Tutubalin <lexa@lexa.ru> |
| * New sample samples/postprocessing_benchmark.cpp |
| This sample measures postprocessing speed. |
| All demosaic methods, averaged white balance, median |
| filtering, wavelet filtration, highlight recovery, and |
| cropping are supported. |
| |
| * Removed LibRaw::rotate_fuji_raw() call and corresponding C-API call. |
| |
| * The LibRaw::adjust_sizes_info_only() call may be called repeated |
| and mixed with dcraw_process() call. |
| |
| * Postprocessing speedup and optimization, especially if cropping set. |
| |
| * Cropping works for FujiCCD raws. For the technical reasons, the position |
| of top-left corner of crop area will be rounded to the nearest |
| multiple of 4 (the corner is shifted top-left). |
| |
| * LibRaw 0.14.0-Alpha3 |
| |
| 2011-07-15 Alex Tutubalin <lexa@lexa.ru> |
| * imported cropping code from 0.13 branch |
| |
| 2011-07-12 Alex Tutubalin <lexa@lexa.ru> |
| * samples/multirender_test - check for different clip settings |
| |
| 2011-07-11 Alex Tutubalin <lexa@lexa.ru> |
| * New call LibRaw::free_image(), deallocates imgdata.image buffer. |
| Use this call if current postprocessing results are not |
| needed, but it is to early to call recycle() because |
| dcraw_process() may be called later. |
| |
| * New C-API calls |
| libraw_raw2image() - C API for LibRaw::raw2image() |
| libraw_free_image() - C API for LibRaw::free_image() |
| libraw_get_decoder_info() - C API for LibRaw::get_decoder_info() |
| |
| * Bugfix: change of params.user_flip aftee open()/unpack() |
| calls should work. |
| |
| * LibRaw 0.14.0-Alpha2 |
| |
| 2011-07-10 Alex Tutubalin <lexa@lexa.ru> |
| * Multiple rendering (LibRaw::dcraw_process() calls) allowed |
| without re-opening RAW file thrfough the sequence of open()/unpack() |
| calls. |
| You should be able to change any processing parameters (except |
| shot_select parameter) between dcraw_process() calls. |
| |
| + New sample in samples/multirender_test.cpp: renders data 4 times: |
| in half and full modes with different white balance settings. |
| |
| + Unprocessed RAW data is stored in separate data buffer: |
| (2 bytes per pixel for all Bayer-pattern images, |
| 8 bytes per pixel for Foveon, sRAW, and other full-color raw |
| formats), so now LibRaw uses 25% more memory for full processing of |
| most common Bayer images; while for just unpack memory is reduced |
| 4 times. |
| |
| + New call LibRaw::raw2image() fills imgdata.image array |
| with fresh copy of data. |
| There is no need to call raw2image() separately if you use |
| dcraw_process() or dcraw_document_mode_processing() calls. |
| |
| + New call LibRaw::get_decoder_info() to determine raw data |
| storage layout. See samples/unprocessed_raw.cpp for an example |
| of how to use it. |
| |
| If your code uses usual open()/unpack()/dcraw_process() call |
| sequence, then NOTHING CHANGED: your program should produce same |
| results. For interactive programs you may skip open()/unpack() |
| calls after adjusting processing parameters, so user should see |
| image refreshed much faster. |
| |
| If your code uses raw data (open+unpack calls), you need to call |
| LibRaw::raw2image(), and imgdata.image will contain same bitmap |
| as in LibRaw 0.13.x |
| |
| If you code uses access to masked borders data, you need to |
| rewrite it. See samples/unprocessed_raw.cpp as a sample. |
| |
| Unfortunately, documentation is untouched yet. This problem will be |
| fixed in next Alpha release. |
| |
| Other changes: |
| |
| * No separate imgdata.masked_pixels buffers, Bayer raw formats are read |
| to buffer with borders. So, no ugly add_masked_border_to_bitmap() |
| call. |
| |
| * No filtering_mode parameter. Raw tone curve is applied |
| at unpack() stage; zero pixels removed on postprocessing stage. |
| |
| * unprocessed_raw and 4colors samples are adjusted to use |
| new RAW data storage layout. |
| |
| * all client code should be recompiled due to internals change. |
| |
| * LibRaw 0.14.0-Alpha1 |
| |
| 2011-07-03 Alex Tutubalin <lexa@lexa.ru> |
| * Cosmetic cleanup in Libraw_memmgr code |
| |
| * Permit OpenMP support on MS VS2008 |
| |
| * More general mem_image interface: |
| + New call get_mem_image_format returns bitmap size and bit depth |
| + New call copy_mem_image can copy bitmap into buffer with |
| different color order (RGB/BGR) and line stride |
| + dcraw_make_mem_image() uses calls mentioned above |
| + see documentation for info on these function parameters. |
| |
| * libraw/librawwindows.h implements LibRaw_datastream class based |
| on Windows memory mapped files.Win32/64-only |
| Thanks to Linc Brookes. |
| |
| * Fixed parallel make errors in configure/Makefile.am |
| |
| * LibRaw 0.13.6-Release |
| |
| |
| 2011-05-18 Alex Tutubalin <lexa@lexa.ru> |
| * Imported new dcraw 9.08/1.443: |
| + New color data for Canon 600D and 1100D, Fuji S200EXR |
| + New camera supported: Fuji HS20EXR and F550EXR, Kodak Z990, |
| Nikon D5100, Olympus E-PL1s and XZ-1, |
| Samsung NX11, Sony A230 and 290. |
| * LibRaw 0.13.5-Release |
| |
| 2011-04-02 Alex Tutubalin <lexa@lexa.ru> |
| * Imported new dcraw 9.07/1.442: |
| + Support for Canon 600D and 1100D, Hasselblad H4D-60, |
| Olympus E-PL2 |
| * Color data for Leaf Aptus II and Canon Powershot S2 IS |
| * LibRaw 0.13.4-Release |
| |
| 2011-03-30 Alex Tutubalin <lexa@lexa.ru> |
| * Preliminary support for Leaf Aptus II cameras (no color data yet): |
| Leaf Aptus II 6,7,8,10 and 12 are tested, Aptus II 5 should work. |
| * Preliminary support for Fujifilm X100 camera (again, no color data). |
| * Fixed possible after the end of buffer read when working with |
| in-memory data. |
| * Fixed possible loss of JPEG stream sync marks in LJPEG decoder |
| (this bug was found only for Leaf Aptus II RAWs). |
| * LibRaw 0.13.3-Release |
| |
| 2011-03-08 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed broken camera white balance reading for some Sony cameras |
| * LibRaw 0.13.2-Release |
| |
| 2011-02-25 Alex Tutubalin <lexa@lexa.ru> |
| * Sony A390 support (colordata from A380) |
| * Leica D-LUX 4: fixed typo in camera name in colordata |
| |
| 2011-02-15 Alex Tutubalin <lexa@lexa.ru> |
| * New -mem option for dcraw_emu: I/O via allocated buffer |
| * Removed debug printf from LibRaw_memory_buffer code |
| * Preliminary shared library support |
| |
| 2011-02-12 Alex Tutubalin <lexa@lexa.ru> |
| * Added qmake .pro and Visual Studio 2008 sln/vcproj project files |
| 2011-02-07 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw_emu documentation updated |
| * ./configure stuff changed for correct linking on some systems |
| * FBDD denoising is disabled for full-color images and 4-color bayer |
| data (including forced 4-color via four_color_rgb option) |
| * LibRaw 0.13.1-Release |
| |
| 2011-02-05 Alex Tutubalin <lexa@lexa.ru> |
| * ./configure fixes for PACKAGE_REQUIRES |
| * Makefile.msvc: correct compiler flags for demosaic packs |
| * dcraw.c 9.06/1.440 imported: |
| + New camera support: Canon S95, Casio EX-Z1080, Panasonic GF2 |
| and GH2, Samsung NX100, Sony A-580 |
| + New color data for: Canon G12, Nikon D3100, D7000 and P7000, |
| Olympus E-5, Pentax K-r and K-5, Samsung NX10 and WB2000 |
| * green_matching() code is disabled for half-size processing |
| * LibRaw 0.13.0-Release |
| |
| 2011-01-15 Alex Tutubalin <lexa@lexa.ru> |
| * Fallback to old huffman decoder for Sony files with unspecified |
| data length (Sony A100) |
| * Fixed incomplete data fields reset in LibRaw::recycle() |
| * LibRaw 0.13.0-Beta3 |
| |
| 2011-01-13 Alex Tutubalin <lexa@lexa.ru> |
| * Better parsing of unknown command-line params in dcraw_emu sample |
| * Brigtness table in ahd_demosaic is calculated in reversed order |
| to prevent possible (very unlikely) multithreaded app problem. |
| * New exposure correction code based on linear-cubic root combination. |
| New working correction range is from 0.25 (-2 stops) to 8 (+3 stops) |
| * LibRaw 0.13.0-Beta2 |
| |
| 2011-01-10 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed file extension in half_mt.c sample |
| |
| 2011-01-10 Alex Tutubalin <lexa@lexa.ru> |
| * Three patches provided by Jacques Desmis: |
| - Exposure correction before demosaic (demosaic pack GPL3) |
| - OpenMP speed-up in median filters (demosaic pack GPL2) |
| - OpenMP speed-up in green equilibration (demosaic pack GPL3) |
| * Merged 0.12.2-0.12.3 changes: |
| - Patches for ./configure system for better LCMS2 support |
| - Patches for ./configure system |
| - math.h included before any other includes to make KDE compile |
| with Visual C++ happy |
| - Fuji FinePix S5500 size adjusted to ignore (rare?) garbage |
| at top of frame. |
| * all client code should be recompiled due to internals change. |
| * LibRaw 0.13.0-Beta1 |
| |
| 2010-12-22 Alex Tutubalin <lexa@lexa.ru> |
| * Zero copy huffman buffer for LibRaw_buffer_datastream |
| * Fixed memory leak in compressed NEFs handling |
| * LibRaw 0.13.0-Alpha2 |
| |
| 2010-12-20 Alex Tutubalin <lexa@lexa.ru> |
| * Demosaic-pack-GPL3 changes: |
| + New noise reduction methods before demosaic |
| - Banding suppression |
| - High-frequency noise suppression |
| - Green channel equalization |
| + New chromatic aberration correction. |
| All three methods are written by Emil Martinec for Raw Therapee. |
| Adapted to LibRaw by Jacques Desmis |
| |
| * Merged Foveon code fix from LibRaw 0.12.1 |
| |
| * LJPEG decompressor speed-up (about 1.5 times for Canon cameras |
| and slightly less for others). Some ideas are from RawSpeed library. |
| |
| * all client code should be recompiled due to internals change. |
| |
| * LibRaw 0.13.0-Alpha1 |
| |
| 2010-12-12 Alex Tutubalin <lexa@lexa.ru> |
| * Thread-safe and demosaic packs support for MinGW build |
| * Demosaic packs support for MS VC build |
| * LibRaw 0.12.0-Release |
| |
| 2010-12-09 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in add_masked_borders_to_bitmap() call for cameras |
| with odd pixels border. |
| * New command line options for unprocessed_raw sample: |
| -B - subtract black level, -M - add masked pixels to bitmap. |
| * Foveon-sensor cameras added to supported camera list if |
| compiled with demosaic pack GPL2 |
| * LibRaw 0.12.0-Beta4 |
| |
| 2010-12-05 Alex Tutubalin <lexa@lexa.ru> |
| * Demosaic packs support in Makefile.dist |
| * Foveon support in LibRaw demosaic pack GPL2 |
| * all client code should be recompiled due to internals change. |
| * LibRaw 0.12.0-Beta3 |
| |
| 2010-11-27 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed allocation bug in lmmse_interpolation (demosaic-pack-GPL2) |
| * In LMMSE and AMaZE interpolators allocation changed to calloc |
| to make valgrind happy with uninitialized values |
| * Changes in distribution-making scripts |
| * LibRaw 0.12.0-Beta2 |
| |
| 2010-11-21 Alex Tutubalin <lexa@lexa.ru> |
| * Fixes to green_matching code by Sergey Pavlov |
| |
| 2010-11-20 Alex Tutubalin <lexa@lexa.ru> |
| * Update for new demosaic-pack-GPL3 |
| * LibRaw 0.12.0-Beta1 |
| |
| 2010-11-19 Alex Tutubalin <lexa@lexa.ru> |
| * Demosaic pack(s) supported via ./configure |
| |
| 2010-11-17 Alex Tutubalin <lexa@lexa.ru> |
| * LCMS2 support |
| * afd_interpolate(2,1) instead of (5,0) |
| * dcraw_emu sample command line keys added and reordered |
| to reflect changes in LibRaw 0.12. |
| * Nikon P7000: color matrix data and black level patch for ISO >=400 |
| Thanks to Gunnar Thorburn |
| * Support for several industrial cameras based on Sony ICX 625/655 |
| sensor: JAI BB500CL/GE, SVS625CL, ptGrey GRAS-50S5C |
| Thanks to kaare |
| |
| 2010-11-15 Alex Tutubalin <lexa@lexa.ru> |
| |
| * Several demosaic algorithms, found in other open-source RAW processing |
| packages are implemented in LibRaw. |
| |
| 1) DCB demosaic and FBDD denoise by Jacek Gozdz are included in |
| main LibRaw source. |
| 2) GPL2 demosaic pack with these demosaic methods: |
| * AFD and LMMSE implementations from PerfectRaw by Manuel Llorens |
| * VCD, Modified AHD, post-demosaic refinemend and median |
| filters by Paul Lee |
| 3) GPL3 demosaic pack with AMaZe interpolation by Emil Martinec |
| |
| See more details in README.demosaic-packs |
| |
| * Current implementation of dcraw_emu sample allows only selection |
| of demosaic method (via -q) options. All other parameters change |
| will be implemented later. |
| |
| * LibRaw 0.12-alpha1 |
| |
| 2010-11-11 Alex Tutubalin <lexa@lexa.ru> |
| * Imported 0.11(2) version changes: |
| + Fixed dcraw_emu command line processing code |
| + OpenMP is completely disabled on MacOS X if compiled with -pthread |
| due to well-known MacOS problem. |
| + dcraw 9.05 (1.439) imported, many new cameras supported: |
| Canon: G12, SX120, 60D, |
| Hasselblad H4D, Nokia X2, Olympus E-5, |
| Nikon: D3100, D7000, P7000, |
| Panasonic: FZ40, FZ100, LX5, |
| Pentax: K-r, K-5, 645D, |
| Samsung GX20, WB2000 |
| * LibRaw 0.12-alpha0 |
| |
| 2010-11-08 Alex Tutubalin <lexa@lexa.ru> |
| * Fixes for Sun Studio compiler compatibility |
| * Fixes for Visual Studio 2010 compatibility |
| * All russian-language files are converted to UTF-8 |
| * LibRaw 0.11.0-Release |
| |
| 2010-10-18 Alex Tutubalin <lexa@lexa.ru> |
| * Disabled OpenMP for wavelet_denoise under Mac OS X |
| * More Visual C++ 2003 warnings cleaned in libraw/*h files |
| * LibRaw 0.11-Beta7 |
| |
| 2010-10-16 Alex Tutubalin <lexa@lexa.ru> |
| * internal/dcraw_fileio.c can be compiled with -DDCRAW_VERBOSE again |
| * fixed comment style in libraw_datastream.h |
| * LibRaw 0.11-Beta6 |
| |
| 2010-10-15 Alex Tutubalin <lexa@lexa.ru> |
| |
| * New changes to I/O layer. Three LibRaw_*datastream clasees are |
| exists: |
| + LibRaw_buffer_datastream - buffer reaging |
| + LibRaw_file_datastream - file reading using iostreams |
| (large files are no supported on some systems) |
| + LibRaw_bigfile_datastream - FILE*-based file I/O |
| |
| * file/bigfile_datastream is selected automatically by |
| LibRaw::open_file based on input file size. |
| By default, files larger than 250Mb are opened using |
| bigfile interface, you may change this behaviour |
| by using second optional parameter of open_file() |
| |
| * There is no way to use default parameter values in C API, |
| so new call libraw_open_file_ex added with two parameters |
| (file name and minimal file size for bigfile_datastream use). |
| |
| * all client code should be recompiled due to internals change. |
| |
| * All LibRaw_abstract_datastream functions are virtual again. You may |
| (again) use your own I/O layer. |
| |
| * new -d key for dcraw_emu sample: print timings of processing stages |
| |
| * simple_dcraw sample simplified: no mmap code |
| |
| * LibRaw 0.11-Beta5 |
| |
| 2010-10-08 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in exception handling in OpenMP sections in |
| AHD interpolation code. |
| |
| * LibRaw_datastreams are now C++ iostreams based instead of old |
| plain FILE* calls. |
| LibRaw::open_file() in multithreaded programs are WAY faster |
| on many OSes (Linux, Windows, MacOSX) because of no extra locks. |
| |
| * all client code should be recompiled due to internals change. |
| |
| * LibRaw 0.11-Beta4 |
| |
| |
| 2010-10-01 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in LibRaw::dcraw_process() code: for half_size |
| processing, params.four_color_rgb was set to 1 internally |
| and not returned back after postprocessing. |
| |
| * Several Visual Studio 2003 compatibility fixes |
| |
| * AHD interpolation refactored. Now it is about 10% faster than |
| dcraw in single-process mode and up to 1.5 times faster on |
| 4-core and OpenMP (total execution time counted, not AHD itself) |
| Thanks to Adam Hooper |
| * AHD interpolation refactored. Now it is about 10% faster than |
| dcraw in single-process mode and up to 1.5 times faster on |
| 4-core and OpenMP (total execution time counted, not AHD itself) |
| Thanks to Adam Hooper |
| |
| * LibRaw 0.11-Beta3 |
| |
| 2010-09-07 Alex Tutubalin <lexa@lexa.ru> |
| * Phase One files: LibRaw::unpack() sets colordata.black to |
| approximately correct value. |
| |
| * Fixed minor error in setting colordata.maximum value |
| for Phase One files. |
| |
| * LibRaw::subtract_black() sets colordata.black and |
| colordata.cblack[] to zero to preserve data integrity. |
| |
| * LibRaw 0.11-Beta2 |
| |
| |
| 2010-09-04 Alex Tutubalin <lexa@lexa.ru> |
| |
| * It is now possible to crop output image on postprocessing |
| stage (dcraw_process). Coordinates and size of the output box |
| are set via imgdata.params.cropbox[4] parameter. Look into |
| LibRaw documentation for more details. |
| |
| + New fatal error code LIBRAW_BAD_CROP |
| |
| + New dcraw_emu sample command line switch: -B x y w h |
| (sets cropbox) |
| |
| Thanks to Patrick and Jan. |
| |
| * Processing pipeline has changed: the black level is subtracted |
| from data on postprocessing stage either automatically |
| (on dcraw_process() stage) or by special LibRaw API call: |
| |
| + New API calls: LibRaw::subtract_black() (C++ API) and |
| libraw_subtract_black (C API). |
| If you use dcraw_process() or dcraw_document_mode_processing() |
| calls YOU DON'T NEED to call subtract_black() directly. |
| |
| + The raw preprocessing mode LIBRAW_FILTERING_NOBLACKS |
| is deprecated and removed from LibRaw. |
| |
| * New ./configure script. |
| Use ./configure -h for usage details. |
| Thanks to Siddhesh Poyarekar |
| |
| * New API cals static LibRaw::dcraw_clear_mem() (C++ API) |
| and libraw_dcraw_clear_mem(..) (C API). |
| This calls are used to free memory, allocated by |
| dcraw_make_mem_image() and dcraw_make_mem_thumb() instead |
| of free() call. |
| |
| In some cases LibRaw and calling process have different |
| memory managers, so free() of make_mem_image() data |
| results to program crash (especially in Win32/VisualStudio |
| environment). |
| |
| * LibRaw::free() is now private instead of public (again). |
| |
| * Minor changes and bugfixes: |
| |
| + Memory allocation exceptions (std::bad_alloc) are caught, |
| so LibRaw API calls will return reasonable error codes |
| instead of C++ exception (possibly unhandled). |
| This problem is very unlikely to see in wild: if application |
| cannot allocate small data for internal structure, it will |
| always fail on allocation for RAW image data. |
| |
| + WIN32/VisualStudio 2008/2010: fopen,fscanf and sscanf calls |
| in Libraw_datastream code are changed to *_s (secure) ones. |
| |
| + Debug print removed from fatal error handler. |
| |
| + Mmaped I/O for dcraw_emu sample is turned on via -E switch |
| now (because old -B switch is used for setting cropbox). |
| |
| * all client code should be recompiled due to structures size change |
| |
| * LibRaw 0.11-Beta1 |
| |
| |
| 2010-07-31 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 9.04 (1.438) imported: changes in tiff metadata parser, |
| fixed a typo in Canon A720 model name |
| * small patch in Sony ARW2 unpacking code to make valgrind happy |
| * LibRaw 0.10.0-Beta3. |
| |
| 2010-07-05 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 9.03 (1.437) imported: |
| + New cameras: Canon SX20, Nikon D3s, Olympus E-P2, Panasoni DMC-GF1, |
| Samsung EX1, Sony A450 |
| + Color data changed for some cameras |
| |
| * LibRaw 0.10.0-Beta2. |
| |
| 2010-06-06 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 9.01 (1.434) imported: |
| + Separate black levels for each color channel. |
| + New cameras: Canon 550D, Casio EX-Z1050, Fuji HS10/HS11, |
| Kodak Z981, Panasonic G2 and G10, Phase One P65, |
| Samsung NX-10 and WB550, Sony NEX-3 and NEX-5. |
| + Fixed file descriptor leak in dark frame subtraction processing |
| |
| * Fixed dcraw 9.01's bug in DNG black level processing |
| |
| * Preliminary support for Sony A450 camera. |
| |
| * New command-line switch -h in mem_image sample (half_size support) |
| |
| * Some patches by Johannes Hanika (darktable author): |
| + OpenMP speedup for PPG-interpolation |
| + green_matching - suppress of 'color maze' on cameras with |
| different green channel sensitivity. This option is turns on |
| by filed with same name in imgdata.params |
| |
| * all client code should be recompiled due to structures size |
| change |
| |
| * LibRaw::free() is now public instead of private. |
| |
| * LibRaw 0.10.0-Beta1. |
| |
| 2010-05-15 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in 8-bit RAW processing code |
| * LibRaw 0.9.1-Release |
| |
| 2010-04-26 Alex Tutubalin <lexa@lexa.ru> |
| * OpenMP support: OpenMP is possible under MinGW (untested) |
| * LibRaw 0.9.0-Release |
| |
| 2010-04-21 Alex Tutubalin <lexa@lexa.ru> |
| * Finally fixed inconsistency in Fuji files processing |
| * New COLOR(row,col) call to get bayer color index in image[] array |
| * Old FC() call is deprecated and will be removed in future releases |
| * unprocessed_raw sample switched to COLOR() call |
| * LibRaw 0.9.0-Beta5 |
| |
| |
| 2010-04-10 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in unpacking DNG files made from Fuji RAFs. |
| * LibRaw 0.9.0-Beta4 |
| |
| 2010-04-09 Alex Tutubalin <lexa@lexa.ru> |
| |
| * Fixed typecast error (problem reported only on gcc 4.2.1/32bit) |
| in CRW files processing. |
| |
| * C++ API call LibRaw::adjust_maximum() is now deprecated and |
| de-documented, use params.adjust_maximum_thr instead (on by default) |
| |
| * C-API call libraw_adjust_maximum() removed. |
| |
| * New postprocessing parameter params.adjust_maximum_thr |
| This parameter replaces LibRaw::adjust_maximum(), but more flexible |
| Defaults are reasonable (0.75, same as in old adjust_maximum), |
| look into documentation for more details. |
| |
| * Removed last OpenMP warning |
| |
| * dcraw_emu's -c parameter now wants numeric (float) argument. This value |
| is assigned to params.adjust_maximum_thr. |
| Use -c 0.0 for dcraw compatibility. |
| |
| * all client code should be recompiled due to structures size |
| change |
| |
| * LibRaw 0.9.0-Beta3 |
| |
| |
| 2010-03-29 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed a bug in channel_maximum[] calculation for |
| Panasonic cameras. |
| * channel_maximum[] data now calculated for ALL cameras. |
| * OpenMP warnings suppressed. |
| * Documented the -c command-line switch for dcraw_emu sample. |
| * Removed extra messages from dcraw_emu sample. |
| * LibRaw 0.9.0-Beta2 |
| |
| 2010-03-28 Alex Tutubalin <lexa@lexa.ru> |
| |
| New licensing: |
| |
| * Triple licensing (selected by LibRaw user): |
| |
| + LGPL 2.1 (http://www.gnu.org/licenses/lgpl-2.1.html) |
| + CDDL 1.0 (http://www.opensource.org/licenses/cddl1.txt) |
| + LibRaw Software License (27 March 2010 version) |
| (http://www.libraw.org/data/LICENSE.LibRaw.pdf) |
| |
| * There is no separate LibRaw-Lite and LibRaw-Commercial versions, |
| only single LibRaw. |
| Current LibRaw-Lite and LibRaw-Commercial users should switch |
| to LibRaw without loss of functionality. |
| It is possible to change licensig too (e.g. from LGPL to CDDL |
| for LibRaw-Lite users and from LibRaw License to LGPL or CDDL |
| for LibRaw-Commercial users). |
| |
| * No Foveon support :( |
| It is not possible to get good color from Foveon sensors with |
| *any* converter. So, there is no need to support these cameras. |
| Dcraw's Foveon-processing code is too strict licensed (GPL), |
| so we choose to drop it. |
| |
| New Features: |
| |
| * New data field colordata.channel_maximum[4] - per channel data |
| maximum (calculated for most cameras, 0 for others). |
| |
| * New call LibRaw::adjust_maximum() (and libraw_adjust_maximum() in C API). |
| This call changes hardcoded colordata.maximum value to calculated |
| at unpack stage. This helps suppress false color in highlights |
| (magenta clouds and so). |
| |
| * New command line parameter -c for dcraw_emu sample. Calls adjust_maximum() |
| for each processed file. |
| |
| * all client code should be recompiled due to structures size |
| change |
| |
| * LibRaw 0.9.0-Beta1 |
| |
| 2010-02-06 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed ambiguity in pow/sqrt calls (to make Sun C++ compiler happy) |
| * OpenMP is not supported under MS Visual Studio |
| * Masked a bug in RIFF format parser |
| * LibRaw 0.8.6 |
| |
| 2009-12-30 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in simple_dcraw sample parameters processing |
| * Imported dcraw 8.99 (1.432): |
| + New cameras: Canon: 1D mk IV, Canon S90; Casio Z750, |
| Nikon D3S, Pentax K-x, Sony A-500/550, Fuji S200EXR |
| + New color data for Canon G11 and Sony A850 |
| + Changes in Canon sRAW processing |
| + Changes in Kodak metadata processing |
| + Changes in uncompressed Fuji files processing (FinePix S5xxx) |
| * LibRaw 0.8.5 |
| |
| 2009-11-21 Alex Tutubalin <lexa@lexa.ru> |
| + Fixed a bug in processing of uncompressed Phase One files |
| * LibRaw 0.8.4 |
| |
| 2009-10-24 Alex Tutubalin <lexa@lexa.ru> |
| + Imported dcraw 8.98/1.431: |
| * New Cameras: Canon 7D, Panasonic GF1, Sony A850 and A380, |
| Casio Z850, Nikon D300s |
| + changes in libraw_datastream.h to make compilers more happy |
| * LibRaw 0.8.3 |
| |
| 2009-09-02 Alex Tutubalin <lexa@lexa.ru> |
| + Fixed bug in Hasselblad .3FR unpacking code |
| * Imported dcraw 8.97/1.428: Nikon D3000 image width fix |
| * LibRaw 0.8.2 |
| |
| 2009-08-31 Alex Tutubalin <lexa@lexa.ru> |
| + Enum LibRaw_thumbnail_formats (LIBRAW_IMAGE_*) values changed to |
| match values in enum LibRaw_image_formats (LIBRAW_THUMBNAIL_*). |
| You need to recompile all sources using these constants. |
| |
| 2009-08-30 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 8.97/1.427: |
| + new cameras: Canon A470, Canon G11 (without color data), |
| Nikon D3000, Olympus E-P1, Panasonic DMC-FZ35/FZ38 |
| + some changes in decoding code. |
| * Fixes for Microsoft Visual C++ 6.0 compatibility |
| * C-API dcraw_make_mem_thumb() call finally exported in API |
| * LibRaw 0.8.1 |
| |
| 2009-08-24 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 8.96/1.426 |
| + New cameras: Casio EX-Z60 and EX-Z75, Kodak Z980, |
| Nikon D5000, Olympus X200, D560Z,C350Z,E620, |
| Pentax K7, Sony A330. |
| + New color data for many cameras |
| + Generalized unpacker code for Canon and Casio P&S cameras |
| * LibRaw 0.8.0-Release |
| |
| 2009-08-13 Alex Tutubalin <lexa@lexa.ru> |
| * RAW files larger than 2Gb are supported on: |
| - Unix (all supported: FreeBSD, MacOS X, Linux) |
| - Windows (with C runtime version >= 8.0) |
| * bzero replaced with memset to make Solaris users happy |
| * All applications on 32-bit systems should be recompiled |
| due to data structures size changes. |
| * Minor fixes in windows makefile |
| * LibRaw 0.8.0-Beta5 |
| |
| 2009-07-21 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 8.95 (1.425): |
| + new huffman tree code |
| + New cameras supported: AGFAPHOTO DC-833m, Casio EX-S20, |
| Phase One P65, Samsung S850 |
| + Removed hardcoded white-balance data for many P&S cameras. |
| It is recommended to set params.use_camera_wb to 1 for |
| safe WB. |
| * Fixes for Nikon D5000 files: no pink stripe at |
| right side of frame |
| * C-wrapper: added missed calls |
| libraw_dcraw_make_mem_image |
| libraw_dcraw_ make_mem_thumb |
| * Minor fixes to make non-gcc compilers more happy |
| * Internal structures changed, full recompilation of all client |
| code is needed. |
| * LibRaw 0.8.0-Beta4 |
| |
| 2009-06-08 Alex Tutubalin <lexa@lexa.ru> |
| * Fixes: gamma curve processing was not performed in |
| dcraw_write_mem_image() |
| * Fixes: gamma curve processing was not performed for |
| Kodak thumbnails |
| * LibRaw 0.8.0-Beta3 |
| |
| 2009-06-05 Alex Tutubalin <lexa@lexa.ru> |
| * Fixes in documentation: params.gamm[] described more precisely |
| * Fixes in version number, 0.8-beta1 was mistakenly 0.0.0-beta1 |
| * LibRaw 0.8.0-Beta2 |
| |
| 2009-06-04 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 8.94 (1.423): |
| + New camera support: |
| Canon: SX1, 500D/Rebel T1i, A570, A590, SX110 |
| Kodak Z1015, Motorola PIXL, Olympus E30, Panasonic DMC-GH1 |
| + Improved color data for Nikon D3X |
| + New gamma curve model |
| + Many changes in RAW unpacking code |
| + Canon cameras: black level is not subtracted if set |
| params.document_mode > 1 |
| |
| * API changed: params.gamma_16bit field removed. Gamma curve is |
| set via params.gamm[0]/gamm[1] values (see documentation and |
| samples for details) |
| * LibRaw::identify() split to avoid MS VS2008 bug (too many |
| nested blocks) |
| |
| * Samples: dcraw_emu and mem_image samples supports new dcraw |
| 16bit/gamma semantics: |
| -6: set 16 bit output |
| -4: set 16 bit output and linear gamma curve and no auto |
| brightness |
| * LibRaw 0.8.0-Beta1 |
| |
| 2009-04-28 Alex Tutubalin <lexa@lexa.ru> |
| * Identify sample renamed to raw-identify (name conflict |
| with ImageMagic) |
| * Copyright notice changes |
| * Many compiler warnings removed |
| |
| 2009-04-07 Alex Tutubalin <lexa@lexa.ru> |
| * More accurate types conversion in libraw_datastream.h |
| * New postprocessing parameter auto_bright_thr: set portion of |
| clipped pixels for auto brightening code (instead of |
| dcraw-derived hardcoded 1%) |
| * -U option for dcraw_emu sample sets auto_bright_thr parameter |
| * all client code should be recompiled due to structures size |
| change |
| * LibRaw 0.7.2-Release |
| |
| 2009-03-22 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed typo in OpenMP support code |
| * MinGW support |
| * dcraw source is included in distribution |
| * LibRaw 0.7.1-Release |
| |
| 2009-03-15 Alex Tutubalin <lexa@lexa.ru> |
| * Fuji SuperCCD RAWs: color channels unshuffled on RAW |
| read stage (moved from postprocessing stage) |
| |
| * LibRaw 0.7.0-Release |
| |
| 2009-03-13 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 8.93/1.421 imported: |
| + more accurate pentax dSLR support |
| + fixes in Kodak 620x/720x identification |
| + faster identification procedure for some formats. |
| * LibRaw 0.7.0-Beta5 |
| |
| |
| 2009-03-08 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 8.92/1.420 imported: |
| + user-specified gamma curve |
| + Pentax K2000/Km support |
| + Changes in Canon sRAW processing (support for 5D2 fw 1.07) |
| |
| * all client code should be recompiled |
| |
| * LibRaw 0.7.0-Beta4 |
| |
| 2009-02-13 Alex Tutubalin <lexa@lexa.ru> |
| * bugfix: 4channels sample finally subtracts black by default |
| * dcraw 8.91/1.419 imported: |
| + fixes in RIFF files parsing |
| |
| * LibRaw 0.7.0-Beta3 |
| |
| 2009-02-12 Alex Tutubalin <lexa@lexa.ru> |
| * Black level was not calculated for Canon RAWs in |
| some filtering modes |
| |
| * 4channels sample prints calculated black level |
| (scaled if autoscaling used). |
| Also output file names for this sample now includes |
| color channel name (R/G/B/G2 or C/M/Y/G) |
| |
| * LibRaw 0.7.0-Beta2 |
| |
| 2009-02-09 Alex Tutubalin <lexa@lexa.ru> |
| * New sample 4channels: splits RAW color channels into four |
| separate TIFFs |
| |
| * LibRaw 0.7.0-Beta1 |
| |
| 2009-02-07 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in external jpeg metadata reading code. |
| |
| * Cleaned some C++ warnings |
| |
| * dcraw 8.91/1.418 imported |
| + Hasselblad V96C support |
| |
| * You need to clean and recompile client code which |
| uses LibRaw_*_datastream classes. |
| |
| * LibRaw 0.7.0-Alpha6 |
| |
| 2009-01-30 Alex Tutubalin <lexa@lexa.ru> |
| |
| * New data input framework is created. It is possible now to |
| easyly implement your own data input interface for LibRaw |
| (e.g. for reading RAW data from network data stream) |
| |
| * All older programs using previous LibRaw versions are |
| compatible at source code level. |
| |
| * LibRaw can read RAW data from memory buffer via |
| new LibRaw::open_buffer() API call (implemented on top of |
| new input framework). |
| This call used in sample application dcraw_emu and simple_dcraw |
| (with -B command-line switch) to test new API. |
| |
| * Error handling callback functions now can be called with |
| NULL filename passed (if underlying data stream object |
| does not know file name). |
| So, client error handling callbacks should work with NULL |
| filename. |
| |
| * All client code should be recompiled |
| |
| * Imported dcraw 8.90/1.417: |
| + Support for loading White Balance data from |
| Sony ARW files edited with Sony IDC software. |
| |
| * LibRaw 0.7.0-Alpha5 |
| |
| 2009-01-17 Alex Tutubalin <lexa@lexa.ru> |
| * Raw filtering mode LIBRAW_FILTERING_NOPOSTPROCESS has renamed |
| to LIBRAW_FILTERING_NORAWCURVE for better reflect its purpose. |
| This filtering_mode bit turns off tone curve applying on |
| RAW data on bayer-pattern cameras with raw tone curve: |
| + Adobe DNG (only RAW with bayer pattern) |
| + Nikon compressed NEF |
| + Some Kodak cameras |
| + Sony A700/A900 (tone curve applied to 8-bit raws) |
| |
| * unprocessed_raw sample: added command-line key -N, this key |
| turns on LIBRAW_FILTERING_NORAWCURVE filtering mode. |
| |
| * New scheme of Fuji RAW processing (introduced in 0.7-Alpha3) |
| supports DNG files generated from Fuji RAF. |
| |
| * Imported dcraw 8.90/1.416: |
| + better support for Samsung S85 |
| + fixed possible integer overflow in wavelet denoising code |
| |
| * LibRaw 0.7.0-Alpha4 |
| |
| |
| 2009-01-14 Alex Tutubalin <lexa@lexa.ru> |
| * Black mask extraction supported for all files with bayer data |
| (one component per pixel). Black mask data not available |
| for multi-component data (Foveon, Canon sRAW, Sinar 4-shot, |
| Kodak YCC/YRGB). |
| |
| * Black level subtraction can be turned off for all bayer |
| cameras (added support for PhaseOne backs). |
| |
| * Fujifilm camera processing model changed: |
| + RAW data is extracted without 45-degree rotation |
| + dcraw-compatible rotation is performed on postptocessing stage |
| + it is possible to rotate RAW data without postprocessing |
| by LibRaw::rotate_fuji_raw() call. |
| |
| * New filtering mode setting: LIBRAW_FILTERING_NOPOSTPROCESS |
| This bits turns off RAW tone curve processing based on tone curve |
| readed from RAW metadata. |
| This mode supported only for PhaseOne backs now (to be supported |
| on all relevant cameras in nearest future releases) |
| |
| * Black level data (got from RAW data) are stored for PhaseOne backs. |
| |
| * Black level subtraction bug (derived from dcraw) fixed |
| for PhaseOne files. |
| |
| * Fixed processing of -s parameter for dcraw_emu sample |
| |
| * Parameter -s N (select shot number) added to |
| unprocessed_raw sample. |
| |
| * Imported dcraw 8.90/1.414: |
| + changes in QuickTake 100 metadata processing |
| + changes in external jpeg processing code |
| + Samsung S85 support |
| |
| * All client code should be recompiled |
| |
| * LibRaw 0.7.0-Alpha3 released |
| |
| 2009-01-10 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in add_masked_borders: crash if output dimensions |
| is already larger than raw dimensions |
| * Fixed out of bounds in samples/unprocessed_raw.cpp for files |
| with non-square pixels |
| |
| * LibRaw 0.7.0-Alpha2 released |
| |
| 2009-01-08 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed bug in 0.7.0-a0: black frame size has not reset, |
| so in batch processing there is an error in black frame |
| size for files without black frame. |
| |
| * Implemented reading of black/masked pixels data for |
| near all cameras with masked pixels, exclding: |
| + Canon sRAW, Leaf (MOS), Sinar 4-shot - more than one |
| color component in black frame (redesign of black frame |
| data structures required). |
| + Fuji SuperCCD: need to design right methods of extraction |
| (should we rotate and resize black pixels as active ones??) |
| |
| * Tested for most dSLR data formats with masked pixels: 7 of 9 |
| untested formats are from old P&S cameras. |
| |
| * New call LibRaw::unpack_function_name() returns unpack function name |
| (useful for testers only) |
| |
| * New identify sample parameters (useful for test-suite builders |
| to check test coverage): |
| -u - print unpack function name |
| -f - print masked frame size |
| These parameters works only for identify run without -v parameter |
| |
| * Imported dcraw 8.89/1.411 |
| + changes in Panasonic FZ50 files parsing |
| |
| * LibRaw 0.7.0-Alpha1 released |
| |
| |
| 2009-01-05 Alex Tutubalin <lexa@lexa.ru> |
| * It is possible to turn off RAW data filtration (black level |
| subtraction, zero pixels averaging): |
| + supported on all cameras except Foveon and Phase One |
| + filtraction controlled by new parameter "filtering_mode" |
| + it is possible to expand API by filtering procedures |
| built for specific camera model. |
| |
| * Black border (masked pixels) extraction: |
| + API (data structures) for storing black mask. |
| + Black mask extraction supported only for limited list of |
| data formats: |
| - Canon .CRW, .CR2 (with exception of sRAW),A600, A5 |
| - Adobe DNG (both converted RAW and native DNG) |
| - Nikon NEF (compressed only) |
| this list to be expanded in future LibRaw versions |
| * New call add_masked_borders_to_bitmap makes full bitmap |
| 'masked border' + image |
| * Usage sample for functionality listed above: |
| samples/unprocessed_raw |
| * Imported dcraw 8.89/1.410: |
| + fixed bugs in Hasselblad .fff decoding |
| + fixes in Imacon metadata decoding |
| * Documentation changes |
| * All client code should be recompiled |
| * LibRaw 0.7.0-Alpha0 |
| |
| |
| 2009-01-01 Alex Tutubalin <lexa@lexa.ru> |
| * Fixed a bug (filedescriptor and buffer memory leak) in thumbnail |
| extraction when called before metadata analysis. |
| Thanks to Albert Astalis Cid. |
| * LibRaw 0.6.4 Release |
| |
| 2008-12-11 Alex Tutubalin <lexa@lexa.ru> |
| * Imported new edition of dcraw 8.89 (version 1.409) |
| * Nikon NEF decoding changed |
| * LibRaw 0.6.3 Release |
| |
| 2008-12-03 Alex Tutubalin <lexa@lexa.ru> |
| * fixed bug in Panasonic .RW2 processing (only for thread-safe version, |
| single-threaded version was not affected) |
| * All client code should be recompiled |
| * LibRaw 0.6.2 Release |
| |
| 2008-12-03 Alex Tutubalin <lexa@lexa.ru> |
| * Imported dcraw 8.89 (version 1.407) |
| * New cameras: |
| Canon G10 & 5D Mk2, Leaf AFi 7, Leica D-LUX4, Panasonic FX150 & G1, |
| Fujifilm IS Pro, |
| * Changed camera support (color conversion tables): |
| Canon 50D, Nikon D90 & P6000, Panasonic LX3 & FZ28, Sony A900 |
| * LibRaw 0.6.2 beta |
| |
| 2008-09-25 Alex Tutubalin <lexa@lexa.ru> |
| * Added new data field float LibRaw::imgdata.color.cam_xyz[4][3]. |
| This field contains constant table (different for each camera) for |
| Camera RGB->XYZ conversion. |
| * All client code should be recompiled |
| * LibRaw 0.6.1 Release |
| |
| 2008-09-18 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 8.88 imported: |
| - new cameras (Canon 50D, Sony A900, Nikon D90 & P6000, |
| Panasonic LX3 FZ28) |
| - new method of black point subtraction for Canon cameras, |
| preliminary banding suppression. |
| * Stack memory usage lowered (some thread data moved to dynamic |
| memory) |
| * some patches for MSVC compatibility |
| * LibRaw 0.6.0 Release |
| |
| 2008-09-16 Alex Tutubalin <lexa@lexa.ru> |
| * Enum definitions changed to make gcc -pedantic happy |
| * Compiler/preprocessor flags does not affects LibRaw class field set |
| (i.e. structure for thread local storage is always allocated) |
| * Default library compilation mode (i.e. sources imported in another |
| project) is thread-safe |
| |
| 2008-09-14 Alex Tutubalin <lexa@lexa.ru> |
| * OpenMP support for most CPU consuming steps of processing: |
| ahd_interpolation. wavelet_denoise |
| 10-30% speed-up of full processing pipe on 2-core CPU |
| OpenMP supported only on gcc (Linux/FreeBSD and Mac OS X) |
| |
| * LibRaw 0.6.0-Beta-1 |
| |
| 2008-09-10 Alex Tutubalin <lexa@lexa.ru> |
| * All set_**handler accepts additional void* pointer, which should point to |
| callback private data. This pointer passed to user callback when it called. |
| |
| * LibRaw 0.6.0-alpha5 |
| |
| * All client code should be recompiled |
| |
| 2008-09-10 Alex Tutubalin <lexa@lexa.ru> |
| * New processing stages in enum LibRaw_progress: |
| LIBRAW_PROGRESS_BAD_PIXELS LIBRAW_PROGRESS_DARK_FRAME |
| (reserved stages LIBRAW_PROGRESS_RESERVED_PRE1-PRE2 has removed) |
| * libraw_strprogress() - convert progress code into string |
| |
| * Added progress/cancellation user callbacks |
| + new fatal error code: CANCELLED_BY_CALLBACK |
| + sample usage in samples/dcraw_emu.cpp (try run it with -v -v -v opts) |
| |
| * LibRaw 0.6.0-alpha4 |
| |
| * All client code should be recompiled |
| |
| 2008-09-08 Alex Tutubalin <lexa@lexa.ru> |
| * ICC-profiles support (same as in dcraw) |
| + input/output profiles (specified as path to 'icc' file or 'embed' for |
| embedded input profile) |
| + additional warnings |
| + LCMS library used |
| |
| * support of bad pixel map (caller should specify path to bad pixel file |
| in dcraw-compatible format) |
| |
| * dark frame subtraction support (caller should supply path to 16-bit PGM |
| map). samples/simple_dcraw.cpp - -4 option added for dark frame file |
| generation |
| |
| * support of bad pixeld map (dcraw-compatible format) |
| |
| * the dcraw_emu sample supports all new features (ICC, dark frame, bad |
| pixels) |
| |
| * libraw/libraw_version.h, defines, calls and macros for version checks: |
| + LibRaw::version(), LibRaw::versionNumber(), LIBRAW_CHECK_VERSION() |
| |
| * List of supported cameras: |
| + LibRaw::cameraCount() |
| + LibRaw::cameraList() |
| |
| * fixed error in adjust_sizes_info_only |
| |
| * documentation changes |
| |
| * LibRaw 0.6.0-alpha3 |
| |
| 2008-09-07 Alex Tutubalin <lexa@lexa.ru> |
| * samples/mem_image.c - bitwise equal output with dcraw -4 |
| (PPMs outputted with network byte order) |
| * LibRaw 0.6.0-alpha2 |
| |
| 2008-09-06 Alex Tutubalin <lexa@lexa.ru> |
| * Added calls dcraw_make_mem_image and dcraw_make_mem_image: |
| + functions (and supporting code) |
| + documentation changed |
| + new sample code samples/mem_image.cpp |
| * Added processing parameter LibRaw::imgdata.params.gamma_16bit |
| (set to 1 to make gamma correction for 16-bit output) |
| * LibRaw 0.6.0-alpha1 |
| |
| 2008-08-28 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 1.404 (8.87) imported: |
| - 6 new cameras supported (Canon 1000D, A720, SD300; |
| Nikon D700, Oly E-520,Kodak C603) |
| * Licensing changed to GPL v2 |
| |
| 2008-05-02 Alex Tutubalin <lexa@lexa.ru> |
| * mmap/malloc+read IO-layer removed due to no performance gain. |
| FILE I/O returned |
| |
| 2008-05-02 Alex Tutubalin <lexa@lexa.ru> |
| * dcraw 1.403 imported |
| - changes in ljpeg decompression (index values cut to 12 bit) |
| - changes in parse_foveon() jpeg thumbnail extraction |
| * LibRaw 0.5.3 released |
| |
| 2008-04-24 Alex Tutubalin <lexa@lexa.ru> |
| * Linux build of samples/identify fixed |
| * documentation editorial |
| * LibRaw 0.5.2 released |
| |
| 2008-04-21 Alex Tutubalin <lexa@lexa.ru> |
| * All documentation translated to English |
| * English changelog started :) |
| * minor bug (include path) fixed in samples/half_mt |
| * LibRaw 0.5.1 released |
