Files
wuffs/std/gif/decode_gif.wuffs
T
2018-08-18 10:11:43 +10:00

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
}