diff --git a/Userland/Libraries/LibGfx/ImageFormats/JPEGLoader.cpp b/Userland/Libraries/LibGfx/ImageFormats/JPEGLoader.cpp index 37a21e5870..7a1cc0502d 100644 --- a/Userland/Libraries/LibGfx/ImageFormats/JPEGLoader.cpp +++ b/Userland/Libraries/LibGfx/ImageFormats/JPEGLoader.cpp @@ -615,14 +615,12 @@ static inline ErrorOr read_marker_at_cursor(Stream& stream) return is_supported_marker(marker) ? marker : JPEG_INVALID; } -static ErrorOr read_start_of_scan(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr read_start_of_scan(Stream& stream, JPEGLoadingContext& context) { // B.2.3 - Scan header syntax - if (context.state < JPEGLoadingContext::State::FrameDecoded) { - dbgln_if(JPEG_DEBUG, "{}: SOS found before reading a SOF!", TRY(stream.tell())); + if (context.state < JPEGLoadingContext::State::FrameDecoded) return Error::from_string_literal("SOS found before reading a SOF"); - } [[maybe_unused]] u16 const bytes_to_read = TRY(stream.read_value>()) - 2; u8 const component_count = TRY(stream.read_value()); @@ -673,8 +671,7 @@ static ErrorOr read_start_of_scan(AK::SeekableStream& stream, JPEGLoadingC // FIXME: Support SOF2 jpegs with current_scan.successive_approximation != 0 if (current_scan.spectral_selection_start > 63 || current_scan.spectral_selection_end > 63 || current_scan.successive_approximation != 0) { - dbgln_if(JPEG_DEBUG, "{}: ERROR! Start of Selection: {}, End of Selection: {}, Successive Approximation: {}!", - TRY(stream.tell()), + dbgln_if(JPEG_DEBUG, "ERROR! Start of Selection: {}, End of Selection: {}, Successive Approximation: {}!", current_scan.spectral_selection_start, current_scan.spectral_selection_end, current_scan.successive_approximation); @@ -686,19 +683,19 @@ static ErrorOr read_start_of_scan(AK::SeekableStream& stream, JPEGLoadingC return {}; } -static ErrorOr read_restart_interval(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr read_restart_interval(Stream& stream, JPEGLoadingContext& context) { // B.2.4.4 - Restart interval definition syntax u16 bytes_to_read = TRY(stream.read_value>()) - 2; if (bytes_to_read != 2) { - dbgln_if(JPEG_DEBUG, "{}: Malformed DRI marker found!", TRY(stream.tell())); + dbgln_if(JPEG_DEBUG, "Malformed DRI marker found!"); return Error::from_string_literal("Malformed DRI marker found"); } context.dc_restart_interval = TRY(stream.read_value>()); return {}; } -static ErrorOr read_huffman_table(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr read_huffman_table(Stream& stream, JPEGLoadingContext& context) { i32 bytes_to_read = TRY(stream.read_value>()); bytes_to_read -= 2; @@ -708,11 +705,11 @@ static ErrorOr read_huffman_table(AK::SeekableStream& stream, JPEGLoadingC u8 table_type = table_info >> 4; u8 table_destination_id = table_info & 0x0F; if (table_type > 1) { - dbgln_if(JPEG_DEBUG, "{}: Unrecognized huffman table: {}!", TRY(stream.tell()), table_type); + dbgln_if(JPEG_DEBUG, "Unrecognized huffman table: {}!", table_type); return Error::from_string_literal("Unrecognized huffman table"); } if (table_destination_id > 1) { - dbgln_if(JPEG_DEBUG, "{}: Invalid huffman table destination id: {}!", TRY(stream.tell()), table_destination_id); + dbgln_if(JPEG_DEBUG, "Invalid huffman table destination id: {}!", table_destination_id); return Error::from_string_literal("Invalid huffman table destination id"); } @@ -743,13 +740,13 @@ static ErrorOr read_huffman_table(AK::SeekableStream& stream, JPEGLoadingC } if (bytes_to_read != 0) { - dbgln_if(JPEG_DEBUG, "{}: Extra bytes detected in huffman header!", TRY(stream.tell())); + dbgln_if(JPEG_DEBUG, "Extra bytes detected in huffman header!"); return Error::from_string_literal("Extra bytes detected in huffman header"); } return {}; } -static ErrorOr read_icc_profile(SeekableStream& stream, JPEGLoadingContext& context, int bytes_to_read) +static ErrorOr read_icc_profile(Stream& stream, JPEGLoadingContext& context, int bytes_to_read) { if (bytes_to_read <= 2) return Error::from_string_literal("icc marker too small"); @@ -807,7 +804,7 @@ static ErrorOr read_icc_profile(SeekableStream& stream, JPEGLoadingContext return {}; } -static ErrorOr read_colour_encoding(SeekableStream& stream, [[maybe_unused]] JPEGLoadingContext& context, int bytes_to_read) +static ErrorOr read_colour_encoding(Stream& stream, [[maybe_unused]] JPEGLoadingContext& context, int bytes_to_read) { // The App 14 segment is application specific in the first JPEG standard. // However, the Adobe implementation is globally accepted and the value of the color transform @@ -851,7 +848,7 @@ static ErrorOr read_colour_encoding(SeekableStream& stream, [[maybe_unused return {}; } -static ErrorOr read_app_marker(SeekableStream& stream, JPEGLoadingContext& context, int app_marker_number) +static ErrorOr read_app_marker(Stream& stream, JPEGLoadingContext& context, int app_marker_number) { i32 bytes_to_read = TRY(stream.read_value>()); @@ -912,10 +909,10 @@ static inline void set_macroblock_metadata(JPEGLoadingContext& context) context.mblock_meta.total = context.mblock_meta.hcount * context.mblock_meta.vcount; } -static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr read_start_of_frame(Stream& stream, JPEGLoadingContext& context) { if (context.state == JPEGLoadingContext::FrameDecoded) { - dbgln_if(JPEG_DEBUG, "{}: SOF repeated!", TRY(stream.tell())); + dbgln_if(JPEG_DEBUG, "SOF repeated!"); return Error::from_string_literal("SOF repeated"); } @@ -923,14 +920,14 @@ static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoading context.frame.precision = TRY(stream.read_value()); if (context.frame.precision != 8) { - dbgln_if(JPEG_DEBUG, "{}: SOF precision != 8!", TRY(stream.tell())); + dbgln_if(JPEG_DEBUG, "SOF precision != 8!"); return Error::from_string_literal("SOF precision != 8"); } context.frame.height = TRY(stream.read_value>()); context.frame.width = TRY(stream.read_value>()); if (!context.frame.width || !context.frame.height) { - dbgln_if(JPEG_DEBUG, "{}: ERROR! Image height: {}, Image width: {}!", TRY(stream.tell()), context.frame.height, context.frame.width); + dbgln_if(JPEG_DEBUG, "ERROR! Image height: {}, Image width: {}!", context.frame.height, context.frame.width); return Error::from_string_literal("Image frame height of width null"); } @@ -943,7 +940,7 @@ static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoading auto component_count = TRY(stream.read_value()); if (component_count != 1 && component_count != 3) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported number of components in SOF: {}!", TRY(stream.tell()), component_count); + dbgln_if(JPEG_DEBUG, "Unsupported number of components in SOF: {}!", component_count); return Error::from_string_literal("Unsupported number of components in SOF"); } @@ -960,16 +957,14 @@ static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoading // By convention, downsampling is applied only on chroma components. So we should // hope to see the maximum sampling factor in the luma component. if (!validate_luma_and_modify_context(component, context)) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported luma subsampling factors: horizontal: {}, vertical: {}", - TRY(stream.tell()), + dbgln_if(JPEG_DEBUG, "Unsupported luma subsampling factors: horizontal: {}, vertical: {}", component.hsample_factor, component.vsample_factor); return Error::from_string_literal("Unsupported luma subsampling factors"); } } else { if (component.hsample_factor != 1 || component.vsample_factor != 1) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported chroma subsampling factors: horizontal: {}, vertical: {}", - TRY(stream.tell()), + dbgln_if(JPEG_DEBUG, "Unsupported chroma subsampling factors: horizontal: {}, vertical: {}", component.hsample_factor, component.vsample_factor); return Error::from_string_literal("Unsupported chroma subsampling factors"); @@ -978,7 +973,7 @@ static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoading component.qtable_id = TRY(stream.read_value()); if (component.qtable_id > 1) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported quantization table id: {}!", TRY(stream.tell()), component.qtable_id); + dbgln_if(JPEG_DEBUG, "Unsupported quantization table id: {}!", component.qtable_id); return Error::from_string_literal("Unsupported quantization table id"); } @@ -988,19 +983,19 @@ static ErrorOr read_start_of_frame(AK::SeekableStream& stream, JPEGLoading return {}; } -static ErrorOr read_quantization_table(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr read_quantization_table(Stream& stream, JPEGLoadingContext& context) { i32 bytes_to_read = TRY(stream.read_value>()) - 2; while (bytes_to_read > 0) { u8 info_byte = TRY(stream.read_value()); u8 element_unit_hint = info_byte >> 4; if (element_unit_hint > 1) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported unit hint in quantization table: {}!", TRY(stream.tell()), element_unit_hint); + dbgln_if(JPEG_DEBUG, "Unsupported unit hint in quantization table: {}!", element_unit_hint); return Error::from_string_literal("Unsupported unit hint in quantization table"); } u8 table_id = info_byte & 0x0F; if (table_id > 1) { - dbgln_if(JPEG_DEBUG, "{}: Unsupported quantization table id: {}!", TRY(stream.tell()), table_id); + dbgln_if(JPEG_DEBUG, "Unsupported quantization table id: {}!", table_id); return Error::from_string_literal("Unsupported quantization table id"); } u32* table = table_id == 0 ? context.luma_table : context.chroma_table; @@ -1016,7 +1011,7 @@ static ErrorOr read_quantization_table(AK::SeekableStream& stream, JPEGLoa bytes_to_read -= 1 + (element_unit_hint == 0 ? 64 : 128); } if (bytes_to_read != 0) { - dbgln_if(JPEG_DEBUG, "{}: Invalid length for one or more quantization tables!", TRY(stream.tell())); + dbgln_if(JPEG_DEBUG, "Invalid length for one or more quantization tables!"); return Error::from_string_literal("Invalid length for one or more quantization tables"); } @@ -1357,7 +1352,7 @@ static bool is_miscellaneous_or_table_marker(Marker const marker) return is_misc || is_table; } -static ErrorOr handle_miscellaneous_or_table(AK::SeekableStream& stream, JPEGLoadingContext& context, Marker const marker) +static ErrorOr handle_miscellaneous_or_table(Stream& stream, JPEGLoadingContext& context, Marker const marker) { if (is_app_marker(marker)) { TRY(read_app_marker(stream, context, marker - JPEG_APPN0)); @@ -1369,7 +1364,7 @@ static ErrorOr handle_miscellaneous_or_table(AK::SeekableStream& stream, J case JPEG_DAC: dbgln_if(JPEG_DEBUG, "TODO: implement marker \"{:x}\"", marker); if (auto result = skip_segment(stream); result.is_error()) { - dbgln_if(JPEG_DEBUG, "{}: Error skipping marker: {:x}!", TRY(stream.tell()), marker); + dbgln_if(JPEG_DEBUG, "Error skipping marker: {:x}!", marker); return result.release_error(); } break; @@ -1390,11 +1385,11 @@ static ErrorOr handle_miscellaneous_or_table(AK::SeekableStream& stream, J return {}; } -static ErrorOr parse_header(AK::SeekableStream& stream, JPEGLoadingContext& context) +static ErrorOr parse_header(Stream& stream, JPEGLoadingContext& context) { auto marker = TRY(read_marker_at_cursor(stream)); if (marker != JPEG_SOI) { - dbgln_if(JPEG_DEBUG, "{}: SOI not found: {:x}!", TRY(stream.tell()), marker); + dbgln_if(JPEG_DEBUG, "SOI not found: {:x}!", marker); return Error::from_string_literal("SOI not found"); } for (;;) { @@ -1421,7 +1416,7 @@ static ErrorOr parse_header(AK::SeekableStream& stream, JPEGLoadingContext case JPEG_RST7: case JPEG_SOI: case JPEG_EOI: - dbgln_if(JPEG_DEBUG, "{}: Unexpected marker {:x}!", TRY(stream.tell()), marker); + dbgln_if(JPEG_DEBUG, "Unexpected marker {:x}!", marker); return Error::from_string_literal("Unexpected marker"); case JPEG_SOF0: case JPEG_SOF2: @@ -1430,7 +1425,7 @@ static ErrorOr parse_header(AK::SeekableStream& stream, JPEGLoadingContext return {}; default: if (auto result = skip_segment(stream); result.is_error()) { - dbgln_if(JPEG_DEBUG, "{}: Error skipping marker: {:x}!", TRY(stream.tell()), marker); + dbgln_if(JPEG_DEBUG, "Error skipping marker: {:x}!", marker); return result.release_error(); } break; @@ -1516,7 +1511,7 @@ static ErrorOr> construct_macroblocks(JPEGLoadingContext& con } else if (marker == JPEG_EOI) { return macroblocks; } else { - dbgln_if(JPEG_DEBUG, "{}: Unexpected marker {:x}!", TRY(context.stream->tell()), marker); + dbgln_if(JPEG_DEBUG, "Unexpected marker {:x}!", marker); return Error::from_string_literal("Unexpected marker"); }