mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 16:32:11 +01:00
705 lines
23 KiB
Plaintext
705 lines
23 KiB
Plaintext
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
use "std/lzw"
|
|
|
|
pub status "?bad block"
|
|
pub status "?bad extension label"
|
|
pub status "?bad graphic control"
|
|
pub status "?bad header"
|
|
pub status "?bad literal width"
|
|
pub status "?not enough pixel data"
|
|
pub status "?too much pixel data"
|
|
|
|
pri status "?internal error: inconsistent ri/wi"
|
|
|
|
// See the spec appendix E "Interlaced Images" on page 29. The first element
|
|
// represents either that the frame was non-interlaced, or that all interlace
|
|
// stages are complete. Otherwise, the four interlace stages are elements 4, 3,
|
|
// 2 and 1 in descending order. For example, the start and delta for the first
|
|
// interlace stage is 0 and 8, for the second interlace stage is 4 and 8, etc.
|
|
// For interlaced frames, the decoder.interlace field starts at 4 and is
|
|
// decremented towards 0.
|
|
//
|
|
// interlace_start[0] is a special case. For non-interlaced frames, that
|
|
// element is never accessed. For interlaced frames, that element is only
|
|
// accessed after all interlace stages are complete. Being the maximum base.u32
|
|
// value means that, after all interlace stages are complete, dst_y will be set
|
|
// to that maximum value (and therefore outside the frame rect).
|
|
pri const interlace_start array[5] base.u32 = [0xFFFFFFFF, 1, 2, 4, 0]
|
|
pri const interlace_delta array[5] base.u8 = [1, 2, 4, 8, 8]
|
|
|
|
pub struct decoder?(
|
|
width base.u32,
|
|
height base.u32,
|
|
|
|
// Call sequence states:
|
|
// - 0: initial state.
|
|
// - 1: image config decoded, including the first frame's bounds, but not
|
|
// the first frame's pixels.
|
|
// - 2: frame config decoded.
|
|
// - 3: frame decoded.
|
|
//
|
|
// State transitions:
|
|
//
|
|
// - 0 -> 1: via IC
|
|
// - 0 -> 2: via FC with implicit IC
|
|
// - 0 -> 3: via F with implicit IC and FC
|
|
//
|
|
// - 1 -> 2: via FC
|
|
// - 1 -> 3: via F with implicit FC
|
|
//
|
|
// - 2 -> 2: via FC with implicit F
|
|
// - 2 -> 3: via F
|
|
//
|
|
// - 3 -> 2: via FC
|
|
// - 3 -> 3: via F with implicit FC
|
|
//
|
|
// Where:
|
|
// - F is decode_frame, implicit means skip_frame
|
|
// - FC is decode_frame_config, implicit means nullptr args.dst
|
|
// - IC is decode_image_config, implicit means nullptr args.dst
|
|
call_sequence base.u8,
|
|
|
|
end_of_data base.bool,
|
|
previous_lzw_decode_ended_abruptly base.bool,
|
|
previous_use_global_palette base.bool,
|
|
|
|
has_full_global_palette base.bool,
|
|
has_full_palette base.bool,
|
|
use_local_palette base.bool,
|
|
|
|
which_palette base.u8[..2],
|
|
|
|
// interlace indexes the interlace_start and interlace_delta arrays.
|
|
interlace base.u8[..4],
|
|
|
|
// Absent an ANIMEXTS1.0 or NETSCAPE2.0 extension, the implicit number of
|
|
// animation loops is 1.
|
|
seen_num_loops base.bool,
|
|
num_loops base.u32,
|
|
|
|
seen_graphic_control base.bool,
|
|
gc_has_transparent_index base.bool,
|
|
gc_transparent_index base.u8,
|
|
gc_disposal base.u8,
|
|
// There are 7056000 flicks per centisecond.
|
|
gc_duration base.u64[..0xFFFF * 7056000],
|
|
|
|
num_decoded_frame_configs_value base.u64,
|
|
num_decoded_frames_value base.u64,
|
|
|
|
frame_rect_x0 base.u32,
|
|
frame_rect_y0 base.u32,
|
|
frame_rect_x1 base.u32,
|
|
frame_rect_y1 base.u32,
|
|
|
|
// The dst_etc fields are the output cursor during copy_to_image_buffer.
|
|
dst_x base.u32,
|
|
dst_y base.u32,
|
|
|
|
uncompressed_ri base.u32[..4096],
|
|
uncompressed_wi base.u32[..4096],
|
|
uncompressed array[4096] base.u8,
|
|
|
|
// palettes[0] and palettes[1] are the Global and Local Color Table.
|
|
palettes array[2] array[4 * 256] base.u8,
|
|
|
|
util base.utility,
|
|
lzw lzw.decoder,
|
|
)
|
|
|
|
pub func decoder.decode_image_config!??(dst nptr base.image_config, src base.io_reader) {
|
|
if this.call_sequence >= 1 {
|
|
return status "?invalid call sequence"
|
|
}
|
|
this.decode_header!??(src:args.src)
|
|
this.decode_lsd!??(src:args.src)
|
|
this.decode_up_to_id_part1!??(src:args.src)
|
|
|
|
// TODO: if this.end_of_data, return an error and/or set dst to zero?
|
|
|
|
var num_loops base.u32 = 1
|
|
if this.seen_num_loops {
|
|
num_loops = this.num_loops
|
|
}
|
|
|
|
var ffio base.bool = (not this.gc_has_transparent_index) and
|
|
(this.frame_rect_x0 == 0) and
|
|
(this.frame_rect_y0 == 0) and
|
|
(this.frame_rect_x1 == this.width) and
|
|
(this.frame_rect_y1 == this.height) and
|
|
(this.has_full_palette)
|
|
|
|
if args.dst != nullptr {
|
|
// TODO: rename initialize to set?
|
|
//
|
|
// TODO: a Wuffs (not just C) name for the
|
|
// WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED magic pixfmt constant.
|
|
args.dst.initialize!(pixfmt:0x22088888, pixsub:0,
|
|
width:this.width, height:this.height, num_loops:num_loops, first_frame_is_opaque:ffio)
|
|
}
|
|
|
|
this.call_sequence = 1
|
|
}
|
|
|
|
pub func decoder.num_decoded_frame_configs() base.u64 {
|
|
return this.num_decoded_frame_configs_value
|
|
}
|
|
|
|
pub func decoder.num_decoded_frames() base.u64 {
|
|
return this.num_decoded_frames_value
|
|
}
|
|
|
|
pub func decoder.work_buffer_size() base.range_ii_u64 {
|
|
return this.util.make_range_ii_u64(min_incl:0, max_incl:0)
|
|
}
|
|
|
|
pub func decoder.decode_frame_config!??(dst nptr base.frame_config, src base.io_reader) {
|
|
if not this.end_of_data {
|
|
if this.call_sequence == 0 {
|
|
this.decode_image_config!??(dst:nullptr, src:args.src)
|
|
} else if this.call_sequence != 1 {
|
|
if this.call_sequence == 2 {
|
|
this.skip_frame!??(src:args.src)
|
|
}
|
|
this.decode_up_to_id_part1!??(src:args.src)
|
|
}
|
|
}
|
|
|
|
// This is a new "if", not an "else", because the calls above can modify
|
|
// this.end_of_data.
|
|
if this.end_of_data {
|
|
while true {
|
|
yield status "$end of data"
|
|
}
|
|
}
|
|
|
|
if this.use_local_palette or this.gc_has_transparent_index {
|
|
this.which_palette = 1
|
|
} else if not this.previous_use_global_palette {
|
|
// This frame uses the global palette but the previous one didn't.
|
|
this.which_palette = 0
|
|
} else {
|
|
// Both this frame and the previous one used the global palette. No
|
|
// palette update is necessary.
|
|
this.which_palette = 2
|
|
}
|
|
this.previous_use_global_palette =
|
|
not (this.use_local_palette or this.gc_has_transparent_index)
|
|
|
|
if args.dst != nullptr {
|
|
args.dst.update!(bounds:this.util.make_rect_ie_u32(
|
|
min_incl_x:this.frame_rect_x0,
|
|
min_incl_y:this.frame_rect_y0,
|
|
max_excl_x:this.frame_rect_x1,
|
|
max_excl_y:this.frame_rect_y1),
|
|
duration:this.gc_duration, blend:true, disposal:this.gc_disposal,
|
|
palette_changed:this.which_palette != 2)
|
|
}
|
|
|
|
this.num_decoded_frame_configs_value ~sat+= 1
|
|
this.call_sequence = 2
|
|
}
|
|
|
|
pri func decoder.skip_frame!??(src base.io_reader) {
|
|
var lw base.u8 = args.src.read_u8!??()
|
|
this.skip_blocks!??(src:args.src)
|
|
|
|
// The Image Descriptor is mandatory, but the Graphic Control extension is
|
|
// optional. Reset the GC related fields for the next decode_frame call.
|
|
this.seen_graphic_control = false
|
|
this.gc_has_transparent_index = false
|
|
this.gc_transparent_index = 0
|
|
this.gc_disposal = 0
|
|
this.gc_duration = 0
|
|
|
|
this.num_decoded_frames_value ~sat+= 1
|
|
this.call_sequence = 3
|
|
}
|
|
|
|
// TODO: honor pixbuf_origin_x and pixbuf_origin_y args.
|
|
pub func decoder.decode_frame!??(dst ptr base.pixel_buffer, pixbuf_origin_x base.u32, pixbuf_origin_y base.u32, src base.io_reader, work_buffer slice base.u8) {
|
|
if this.call_sequence != 2 {
|
|
this.decode_frame_config!??(dst:nullptr, src:args.src)
|
|
}
|
|
|
|
this.decode_id_part1!??(dst:args.dst, src:args.src)
|
|
|
|
// The Image Descriptor is mandatory, but the Graphic Control extension is
|
|
// optional. Reset the GC related fields for the next decode_frame call.
|
|
this.seen_graphic_control = false
|
|
this.gc_has_transparent_index = false
|
|
this.gc_transparent_index = 0
|
|
this.gc_disposal = 0
|
|
this.gc_duration = 0
|
|
|
|
this.num_decoded_frames_value ~sat+= 1
|
|
this.call_sequence = 3
|
|
}
|
|
|
|
pri func decoder.decode_up_to_id_part1!??(src base.io_reader) {
|
|
while true {
|
|
var block_type base.u8 = args.src.read_u8!??()
|
|
if block_type == 0x21 { // The spec calls 0x21 the "Extension Introducer".
|
|
this.decode_extension!??(src:args.src)
|
|
} else if block_type == 0x2C { // The spec calls 0x2C the "Image Separator".
|
|
this.decode_id_part0!??(src:args.src)
|
|
break
|
|
} else if block_type == 0x3B { // The spec calls 0x3B the "Trailer".
|
|
this.end_of_data = true
|
|
break
|
|
} else {
|
|
return status "?bad block"
|
|
}
|
|
}
|
|
}
|
|
|
|
// decode_header reads either "GIF87a" or "GIF89a".
|
|
//
|
|
// See the spec section 17 "Header" on page 7.
|
|
pri func decoder.decode_header!??(src base.io_reader) {
|
|
var c array[6] base.u8
|
|
var i base.u32
|
|
while i < 6 {
|
|
c[i] = args.src.read_u8!??()
|
|
i += 1
|
|
}
|
|
if (c[0] != 0x47) or (c[1] != 0x49) or (c[2] != 0x46) or (c[3] != 0x38) or
|
|
((c[4] != 0x37) and (c[4] != 0x39)) or (c[5] != 0x61) {
|
|
return status "?bad header"
|
|
}
|
|
}
|
|
|
|
// decode_lsd reads the Logical Screen Descriptor.
|
|
//
|
|
// See the spec section 18 "Logical Screen Descriptor" on page 8.
|
|
pri func decoder.decode_lsd!??(src base.io_reader) {
|
|
this.width = args.src.read_u16le!??() as base.u32
|
|
this.height = args.src.read_u16le!??() as base.u32
|
|
var flags base.u8 = args.src.read_u8!??()
|
|
// Ignore the Background Color Index and Pixel Aspect Ratio bytes.
|
|
args.src.skip!??(n:2)
|
|
|
|
// Read the optional Global Color Table.
|
|
if (flags & 0x80) != 0 {
|
|
var num_palette_entries base.u32[..256] = (1 as base.u32) << (1 + (flags & 0x07))
|
|
var i base.u32 = 0
|
|
while i < num_palette_entries {
|
|
assert i < 256 via "a < b: a < c; c <= b"(c:num_palette_entries)
|
|
// Convert from RGB (in memory order) to ARGB (in native u32 order)
|
|
// to BGRA (in memory order).
|
|
var argb base.u32 = args.src.read_u24be!??() | 0xFF000000
|
|
this.palettes[0][(4 * i) + 0] = ((argb >> 0) & 0xFF) as base.u8
|
|
this.palettes[0][(4 * i) + 1] = ((argb >> 8) & 0xFF) as base.u8
|
|
this.palettes[0][(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
|
|
this.palettes[0][(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
|
|
i += 1
|
|
}
|
|
this.has_full_global_palette = i == 256
|
|
// Set the remaining palette entries to transparent black.
|
|
while i < 256 {
|
|
this.palettes[0][(4 * i) + 0] = 0x00
|
|
this.palettes[0][(4 * i) + 1] = 0x00
|
|
this.palettes[0][(4 * i) + 2] = 0x00
|
|
this.palettes[0][(4 * i) + 3] = 0x00
|
|
i += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
// decode_extension reads an extension. The Extension Introducer byte has
|
|
// already been read.
|
|
//
|
|
// See the spec:
|
|
// - section 23 "Graphic Control Extension" on page 15.
|
|
// - section 24 "Comment Extension" on page 17.
|
|
// - section 25 "Plain Text Extension" on page 18.
|
|
// - section 26 "Application Extension" on page 21.
|
|
pri func decoder.decode_extension!??(src base.io_reader) {
|
|
var label base.u8 = args.src.read_u8!??()
|
|
if label == 0xF9 { // The spec calls 0xF9 the "Graphic Control Label".
|
|
this.decode_gc!??(src:args.src)
|
|
return
|
|
} else if label == 0xFF { // The spec calls 0xFF the "Application Extension Label".
|
|
this.decode_ae!??(src:args.src)
|
|
return
|
|
}
|
|
// We skip over all other extensions, including 0x01 "Plain Text Label" and
|
|
// 0xFE "Comment Label".
|
|
this.skip_blocks!??(src:args.src)
|
|
}
|
|
|
|
pri func decoder.skip_blocks!??(src base.io_reader) {
|
|
while true {
|
|
var block_size base.u8 = args.src.read_u8!??()
|
|
if block_size == 0 {
|
|
return
|
|
}
|
|
args.src.skip!??(n:block_size as base.u32)
|
|
}
|
|
}
|
|
|
|
// animexts1dot0 is "ANIMEXTS1.0" as bytes.
|
|
pri const animexts1dot0 array[11] base.u8 = [
|
|
0x41, 0x4E, 0x49, 0x4D, 0x45, 0x58, 0x54, 0x53, 0x31, 0x2E, 0x30,
|
|
]
|
|
|
|
// netscape2dot0 is "NETSCAPE2.0" as bytes.
|
|
pri const netscape2dot0 array[11] base.u8 = [
|
|
0x4E, 0x45, 0x54, 0x53, 0x43, 0x41, 0x50, 0x45, 0x32, 0x2E, 0x30,
|
|
]
|
|
|
|
// decode_ae reads an Application Extension.
|
|
pri func decoder.decode_ae!??(src base.io_reader) {
|
|
// This "while true" always executes exactly once, as it ends with a
|
|
// "break", but using "break"s throughout simplifies the control flow.
|
|
while true {
|
|
var c base.u8
|
|
var block_size base.u8 = args.src.read_u8!??()
|
|
if block_size == 0 {
|
|
return
|
|
}
|
|
|
|
// Look only for an 11 byte "ANIMEXTS1.0" or "NETSCAPE2.0" extension,
|
|
// as per:
|
|
// - http://www.vurdalakov.net/misc/gif/animexts-looping-application-extension
|
|
// - http://www.vurdalakov.net/misc/gif/netscape-looping-application-extension
|
|
if block_size != 11 {
|
|
args.src.skip!??(n:block_size as base.u32)
|
|
break
|
|
}
|
|
var not_animexts base.bool
|
|
var not_netscape base.bool
|
|
block_size = 0 // Re-purpose the block_size variable as a counter.
|
|
while block_size < 11 {
|
|
c = args.src.read_u8!??()
|
|
not_animexts = not_animexts or (c != animexts1dot0[block_size])
|
|
not_netscape = not_netscape or (c != netscape2dot0[block_size])
|
|
block_size += 1
|
|
}
|
|
if not_animexts and not_netscape {
|
|
break
|
|
}
|
|
|
|
// Those 11 bytes should be followed by 0x03, 0x01 and then the loop
|
|
// count.
|
|
block_size = args.src.read_u8!??()
|
|
if block_size != 3 {
|
|
args.src.skip!??(n:block_size as base.u32)
|
|
break
|
|
}
|
|
c = args.src.read_u8!??()
|
|
if c != 0x01 {
|
|
args.src.skip!??(n:2)
|
|
break
|
|
}
|
|
this.num_loops = args.src.read_u16le!??() as base.u32
|
|
this.seen_num_loops = true
|
|
|
|
// A loop count of N, in the wire format, actually means "repeat N
|
|
// times after the first play", if N is positive. A zero N means to
|
|
// loop forever. Playing the frames exactly once is denoted by the
|
|
// *absence* of this NETSCAPE2.0 application extension.
|
|
//
|
|
// For example, if there are four frames: A, B, C, D, and N is 2, then
|
|
// each frame is actually played N+1 or 3 times: ABCDABCDABCD.
|
|
//
|
|
// Thus, we increment N if it is positive. The comparison against
|
|
// 0xFFFF will never fail, but is necessary for the overflow checker.
|
|
if (0 < this.num_loops) and (this.num_loops <= 0xFFFF) {
|
|
this.num_loops += 1
|
|
}
|
|
|
|
break
|
|
}
|
|
this.skip_blocks!??(src:args.src)
|
|
}
|
|
|
|
// decode_gc reads a Graphic Control.
|
|
pri func decoder.decode_gc!??(src base.io_reader) {
|
|
if this.seen_graphic_control {
|
|
return status "?bad graphic control"
|
|
}
|
|
var c base.u8 = args.src.read_u8!??()
|
|
if c != 4 {
|
|
return status "?bad graphic control"
|
|
}
|
|
|
|
var flags base.u8 = args.src.read_u8!??()
|
|
this.gc_has_transparent_index = (flags & 0x01) != 0
|
|
|
|
// Convert the disposal method from GIF's wire format to Wuffs constants.
|
|
//
|
|
// The GIF spec discusses the 3-bit flag value being 0, 1, 2 or 3. Values
|
|
// in the range [4..7] are "to be defined". In practice, some encoders also
|
|
// use 4 for "restore previous". See
|
|
// https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/image-decoders/gif/gif_image_reader.cc?rcl=5161173c43324da2b13e1aa45bbe69901daa1279&l=625
|
|
//
|
|
// TODO: named constants instead of assigning 1 for
|
|
// WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND, etc.
|
|
flags = (flags >> 2) & 0x07
|
|
if flags == 2 {
|
|
this.gc_disposal = 1 // 1 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND
|
|
} else if (flags == 3) or (flags == 4) {
|
|
this.gc_disposal = 2 // 2 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS
|
|
} else {
|
|
this.gc_disposal = 0
|
|
}
|
|
|
|
// There are 7056000 flicks per centisecond.
|
|
this.gc_duration = (args.src.read_u16le!??() as base.u64) * 7056000
|
|
this.gc_transparent_index = args.src.read_u8!??()
|
|
|
|
c = args.src.read_u8!??()
|
|
if c != 0 {
|
|
return status "?bad graphic control"
|
|
}
|
|
this.seen_graphic_control = true
|
|
}
|
|
|
|
// decode_id_partX reads an Image Descriptor. The Image Separator byte has
|
|
// already been read.
|
|
//
|
|
// See the spec section 20 "Image Descriptor" on page 11.
|
|
//
|
|
// The code is split into two parts (part0 and part1) because determining the
|
|
// overall image's width and height also requires decoding the first frame's
|
|
// bounds (but doesn't require decoding the first frame's pixels).
|
|
pri func decoder.decode_id_part0!??(src base.io_reader) {
|
|
this.frame_rect_x0 = args.src.read_u16le!??() as base.u32
|
|
this.frame_rect_y0 = args.src.read_u16le!??() as base.u32
|
|
this.frame_rect_x1 = this.frame_rect_x0 ~mod+ (args.src.read_u16le!??() as base.u32)
|
|
this.frame_rect_y1 = this.frame_rect_y0 ~mod+ (args.src.read_u16le!??() as base.u32)
|
|
this.dst_x = this.frame_rect_x0
|
|
this.dst_y = this.frame_rect_y0
|
|
|
|
// Set the image's overall width and height to be the maximum of the
|
|
// nominal image width and height (given in the Logical Screen Descriptor)
|
|
// and the bottom right extent of the first frame. See
|
|
// test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt for
|
|
// more discussion.
|
|
if this.call_sequence == 0 {
|
|
this.width = this.width.max(x:this.frame_rect_x1)
|
|
this.height = this.height.max(x:this.frame_rect_y1)
|
|
}
|
|
|
|
var flags base.u8 = args.src.read_u8!??()
|
|
if (flags & 0x40) != 0 {
|
|
this.interlace = 4
|
|
} else {
|
|
this.interlace = 0
|
|
}
|
|
|
|
this.has_full_palette = this.has_full_global_palette
|
|
|
|
// Read the optional Local Color Table.
|
|
this.use_local_palette = (flags & 0x80) != 0
|
|
if this.use_local_palette {
|
|
var num_palette_entries base.u32[..256] = (1 as base.u32) << (1 + (flags & 0x07))
|
|
var i base.u32
|
|
while i < num_palette_entries {
|
|
assert i < 256 via "a < b: a < c; c <= b"(c:num_palette_entries)
|
|
// Convert from RGB (in memory order) to ARGB (in native u32 order)
|
|
// to BGRA (in memory order).
|
|
var argb base.u32 = args.src.read_u24be!??() | 0xFF000000
|
|
this.palettes[1][(4 * i) + 0] = ((argb >> 0) & 0xFF) as base.u8
|
|
this.palettes[1][(4 * i) + 1] = ((argb >> 8) & 0xFF) as base.u8
|
|
this.palettes[1][(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
|
|
this.palettes[1][(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
|
|
i += 1
|
|
}
|
|
this.has_full_palette = i == 256
|
|
// Set the remaining palette entries to transparent black.
|
|
while i < 256 {
|
|
this.palettes[1][(4 * i) + 0] = 0x00
|
|
this.palettes[1][(4 * i) + 1] = 0x00
|
|
this.palettes[1][(4 * i) + 2] = 0x00
|
|
this.palettes[1][(4 * i) + 3] = 0x00
|
|
i += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
pri func decoder.decode_id_part1!??(dst ptr base.pixel_buffer, src base.io_reader) {
|
|
if this.gc_has_transparent_index {
|
|
if not this.use_local_palette {
|
|
this.palettes[1][:].copy_from_slice(s:this.palettes[0][:])
|
|
}
|
|
|
|
// Set the gc_transparent_index palette entry to transparent black.
|
|
this.palettes[1][(4 * (this.gc_transparent_index as base.u32)) + 0] = 0x00
|
|
this.palettes[1][(4 * (this.gc_transparent_index as base.u32)) + 1] = 0x00
|
|
this.palettes[1][(4 * (this.gc_transparent_index as base.u32)) + 2] = 0x00
|
|
this.palettes[1][(4 * (this.gc_transparent_index as base.u32)) + 3] = 0x00
|
|
}
|
|
args.dst.set_palette!(palette:this.palettes[this.which_palette & 1][:])
|
|
|
|
// Other GIF implementations accept GIF files that aren't completely spec
|
|
// compliant. For example, the test/data/gifplayer-muybridge.gif file
|
|
// (created by the gifsicle program) is accepted by other GIF decoders.
|
|
// However, in that file, frame #61's embedded LZW data is truncated,
|
|
// finishing with only 8 of the 9 bits required of the LZW end code. The
|
|
// end code itself, 0x81, is representable in only 8 bits, but the number
|
|
// of bits for the decoder to read has ticked over from 8 to 9 just before
|
|
// that end code is encountered.
|
|
//
|
|
// To accommodate such malformed GIFs, we detect when the previous frame's
|
|
// LZW decoding ended abruptly. The previous LZW decode 'works', in that it
|
|
// decodes as much pixel data as is available, but without seeing that end
|
|
// code (i.e. returning the "ok" status code), the LZW decoder is stuck in
|
|
// a coroutine-in-progress lzw_decoder.decode call, still waiting for that
|
|
// end code. To cancel that coroutine, we reset the LZW decoder.
|
|
if this.previous_lzw_decode_ended_abruptly {
|
|
this.lzw.reset()
|
|
}
|
|
|
|
var lw base.u8 = args.src.read_u8!??()
|
|
if (lw < 2) or (8 < lw) {
|
|
return status "?bad literal width"
|
|
}
|
|
this.lzw.set_literal_width!(lw:lw as base.u32)
|
|
|
|
this.previous_lzw_decode_ended_abruptly = true
|
|
while true {
|
|
var block_size base.u64 = args.src.read_u8!??() as base.u64
|
|
if block_size == 0 {
|
|
break
|
|
}
|
|
this.previous_lzw_decode_ended_abruptly = true
|
|
|
|
while:inner true {
|
|
var w base.io_writer
|
|
io_bind (args.src, w) {
|
|
w.set!(s:this.uncompressed[this.uncompressed_wi:])
|
|
// TODO: enforce that calling r.set_limit has a precondition
|
|
// that r.is_bound(), and that you can't suspend inside an
|
|
// io_bind? Otherwise, the cgen implementation becomes more
|
|
// complicated if we must save and re-apply limits.
|
|
//
|
|
// Should calling r.set_mark also require r.is_bound()?
|
|
args.src.set_limit!(l:block_size)
|
|
args.src.set_mark!()
|
|
var z base.status = try this.lzw.decode!??(dst:w, src:args.src)
|
|
this.uncompressed_wi = 4096 - (w.available().min(x:4096) as base.u32)
|
|
block_size ~sat-= args.src.since_mark().length()
|
|
}
|
|
|
|
if z.is_ok() or (z == status "$short write") {
|
|
this.copy_to_image_buffer!??(pb:args.dst)
|
|
|
|
if z == status "$short write" {
|
|
continue:inner
|
|
}
|
|
// TODO: check that block_size is zero?
|
|
this.previous_lzw_decode_ended_abruptly = false
|
|
break:inner
|
|
}
|
|
if (block_size == 0) and (z == status "$short read") {
|
|
break:inner
|
|
}
|
|
yield z
|
|
}
|
|
}
|
|
|
|
if this.uncompressed_ri != this.uncompressed_wi {
|
|
this.copy_to_image_buffer!??(pb:args.dst)
|
|
}
|
|
|
|
// TODO: check for "not enough pixel data".
|
|
}
|
|
|
|
pri func decoder.copy_to_image_buffer!??(pb ptr base.pixel_buffer) {
|
|
// TODO: don't assume a packed pixel format.
|
|
var dst slice base.u8
|
|
var src slice base.u8
|
|
var n base.u32
|
|
// TODO: we shouldn't need this temporary variable.
|
|
var new_ri base.u32
|
|
|
|
var tab table base.u8 = args.pb.plane(p:0)
|
|
|
|
while this.uncompressed_wi > this.uncompressed_ri {
|
|
assert this.uncompressed_ri < this.uncompressed_wi via "a < b: b > a"()
|
|
src = this.uncompressed[this.uncompressed_ri:this.uncompressed_wi]
|
|
|
|
if this.dst_y >= this.frame_rect_y1 {
|
|
return status "?too much pixel data"
|
|
}
|
|
|
|
// First, copy from src to that part of the frame rect that is inside
|
|
// args.pb's bounds.
|
|
|
|
dst = tab.row(y:this.dst_y)
|
|
if (this.dst_x as base.u64) < dst.length() {
|
|
if ((this.dst_x as base.u64) <= (this.frame_rect_x1 as base.u64)) and
|
|
((this.frame_rect_x1 as base.u64) <= dst.length()) {
|
|
// TODO: drop the "as base.u64"s on the next line?
|
|
dst = dst[this.dst_x as base.u64:this.frame_rect_x1 as base.u64]
|
|
} else {
|
|
dst = dst[this.dst_x as base.u64:]
|
|
}
|
|
n = (dst.copy_from_slice(s:src) & 0xFFFFFFFF) as base.u32
|
|
|
|
new_ri = this.uncompressed_ri ~sat+ n
|
|
this.uncompressed_ri = new_ri.min(x:4096)
|
|
this.dst_x ~sat+= n
|
|
}
|
|
|
|
if this.frame_rect_x1 <= this.dst_x {
|
|
this.dst_x = this.frame_rect_x0
|
|
this.dst_y ~sat+= interlace_delta[this.interlace] as base.u32
|
|
while (this.interlace > 0) and (this.dst_y >= this.frame_rect_y1) {
|
|
this.interlace -= 1
|
|
this.dst_y = this.frame_rect_y0 ~sat+ interlace_start[this.interlace]
|
|
}
|
|
continue
|
|
}
|
|
|
|
if this.uncompressed_wi == this.uncompressed_ri {
|
|
break
|
|
} else if this.uncompressed_wi < this.uncompressed_ri {
|
|
return status "?internal error: inconsistent ri/wi"
|
|
}
|
|
|
|
// Second, skip over src for that part of the frame rect that is
|
|
// outside args.pb's bounds. This second step should be infrequent.
|
|
|
|
// Set n to the number of pixels (i.e. the number of bytes) to skip.
|
|
n = this.frame_rect_x1 - this.dst_x
|
|
n = n.min(x:this.uncompressed_wi - this.uncompressed_ri)
|
|
|
|
new_ri = this.uncompressed_ri ~sat+ n
|
|
this.uncompressed_ri = new_ri.min(x:4096)
|
|
this.dst_x ~sat+= n
|
|
|
|
if this.frame_rect_x1 <= this.dst_x {
|
|
this.dst_x = this.frame_rect_x0
|
|
this.dst_y ~sat+= interlace_delta[this.interlace] as base.u32
|
|
while (this.interlace > 0) and (this.dst_y >= this.frame_rect_y1) {
|
|
this.interlace -= 1
|
|
this.dst_y = this.frame_rect_y0 ~sat+ interlace_start[this.interlace]
|
|
}
|
|
continue
|
|
}
|
|
|
|
if this.uncompressed_ri != this.uncompressed_wi {
|
|
return status "?internal error: inconsistent ri/wi"
|
|
}
|
|
break
|
|
}
|
|
this.uncompressed_ri = 0
|
|
this.uncompressed_wi = 0
|
|
}
|