From 26b8512ae016dd8e263f3e58fb45c129e9b98b37 Mon Sep 17 00:00:00 2001 From: eabdullin Date: Thu, 21 Sep 2023 08:56:41 +0000 Subject: [PATCH] import UBI libwebp-1.0.0-8.el8_8.1 --- SOURCES/4619a48fc-1.0.0.patch | 572 ++++++++++++++++++++++++++++++++++ SPECS/libwebp.spec | 11 +- 2 files changed, 581 insertions(+), 2 deletions(-) create mode 100644 SOURCES/4619a48fc-1.0.0.patch diff --git a/SOURCES/4619a48fc-1.0.0.patch b/SOURCES/4619a48fc-1.0.0.patch new file mode 100644 index 0000000..ac6f361 --- /dev/null +++ b/SOURCES/4619a48fc-1.0.0.patch @@ -0,0 +1,572 @@ +diff -up libwebp-1.0.0/src/dec/vp8l_dec.c.old libwebp-1.0.0/src/dec/vp8l_dec.c +--- libwebp-1.0.0/src/dec/vp8l_dec.c.old 2023-09-15 11:07:05.229790896 +0200 ++++ libwebp-1.0.0/src/dec/vp8l_dec.c 2023-09-15 10:54:47.046025885 +0200 +@@ -253,11 +253,11 @@ static int ReadHuffmanCodeLengths( + int symbol; + int max_symbol; + int prev_code_len = DEFAULT_CODE_LENGTH; +- HuffmanCode table[1 << LENGTHS_TABLE_BITS]; ++ HuffmanTables tables; + +- if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS, +- code_length_code_lengths, +- NUM_CODE_LENGTH_CODES)) { ++ if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) || ++ !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS, ++ code_length_code_lengths, NUM_CODE_LENGTH_CODES)) { + goto End; + } + +@@ -277,7 +277,7 @@ static int ReadHuffmanCodeLengths( + int code_len; + if (max_symbol-- == 0) break; + VP8LFillBitWindow(br); +- p = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK]; ++ p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK]; + VP8LSetBitPos(br, br->bit_pos_ + p->bits); + code_len = p->value; + if (code_len < kCodeLengthLiterals) { +@@ -300,6 +300,7 @@ static int ReadHuffmanCodeLengths( + ok = 1; + + End: ++ VP8LHuffmanTablesDeallocate(&tables); + if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR; + return ok; + } +@@ -307,7 +308,8 @@ static int ReadHuffmanCodeLengths( + // 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman + // tree. + static int ReadHuffmanCode(int alphabet_size, VP8LDecoder* const dec, +- int* const code_lengths, HuffmanCode* const table) { ++ int* const code_lengths, ++ HuffmanTables* const table) { + int ok = 0; + int size = 0; + VP8LBitReader* const br = &dec->br_; +@@ -362,12 +364,7 @@ static int ReadHuffmanCodes(VP8LDecoder* + VP8LMetadata* const hdr = &dec->hdr_; + uint32_t* huffman_image = NULL; + HTreeGroup* htree_groups = NULL; +- // When reading htrees, some might be unused, as the format allows it. +- // We will still read them but put them in this htree_group_bogus. +- HTreeGroup htree_group_bogus; +- HuffmanCode* huffman_tables = NULL; +- HuffmanCode* huffman_tables_bogus = NULL; +- HuffmanCode* next = NULL; ++ HuffmanTables* huffman_tables = &hdr->huffman_tables_; + int num_htree_groups = 1; + int num_htree_groups_max = 1; + int max_alphabet_size = 0; +@@ -376,6 +373,10 @@ static int ReadHuffmanCodes(VP8LDecoder* + int* mapping = NULL; + int ok = 0; + ++ // Check the table has been 0 initialized (through InitMetadata). ++ assert(huffman_tables->root.start == NULL); ++ assert(huffman_tables->curr_segment == NULL); ++ + if (allow_recursion && VP8LReadBits(br, 1)) { + // use meta Huffman codes. + const int huffman_precision = VP8LReadBits(br, 3) + 2; +@@ -418,12 +419,6 @@ static int ReadHuffmanCodes(VP8LDecoder* + if (*mapped_group == -1) *mapped_group = num_htree_groups++; + huffman_image[i] = *mapped_group; + } +- huffman_tables_bogus = (HuffmanCode*)WebPSafeMalloc( +- table_size, sizeof(*huffman_tables_bogus)); +- if (huffman_tables_bogus == NULL) { +- dec->status_ = VP8_STATUS_OUT_OF_MEMORY; +- goto Error; +- } + } else { + num_htree_groups = num_htree_groups_max; + } +@@ -444,72 +439,80 @@ static int ReadHuffmanCodes(VP8LDecoder* + + code_lengths = (int*)WebPSafeCalloc((uint64_t)max_alphabet_size, + sizeof(*code_lengths)); +- huffman_tables = (HuffmanCode*)WebPSafeMalloc(num_htree_groups * table_size, +- sizeof(*huffman_tables)); + htree_groups = VP8LHtreeGroupsNew(num_htree_groups); + +- if (htree_groups == NULL || code_lengths == NULL || huffman_tables == NULL) { ++ if (htree_groups == NULL || code_lengths == NULL || ++ !VP8LHuffmanTablesAllocate(num_htree_groups * table_size, ++ huffman_tables)) { + dec->status_ = VP8_STATUS_OUT_OF_MEMORY; + goto Error; + } + +- next = huffman_tables; + for (i = 0; i < num_htree_groups_max; ++i) { +- // If the index "i" is unused in the Huffman image, read the coefficients +- // but store them to a bogus htree_group. +- const int is_bogus = (mapping != NULL && mapping[i] == -1); +- HTreeGroup* const htree_group = +- is_bogus ? &htree_group_bogus : +- &htree_groups[(mapping == NULL) ? i : mapping[i]]; +- HuffmanCode** const htrees = htree_group->htrees; +- HuffmanCode* huffman_tables_i = is_bogus ? huffman_tables_bogus : next; +- int size; +- int total_size = 0; +- int is_trivial_literal = 1; +- int max_bits = 0; +- for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { +- int alphabet_size = kAlphabetSize[j]; +- htrees[j] = huffman_tables_i; +- if (j == 0 && color_cache_bits > 0) { +- alphabet_size += 1 << color_cache_bits; +- } +- size = +- ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables_i); +- if (size == 0) { +- goto Error; +- } +- if (is_trivial_literal && kLiteralMap[j] == 1) { +- is_trivial_literal = (huffman_tables_i->bits == 0); ++ // If the index "i" is unused in the Huffman image, just make sure the ++ // coefficients are valid but do not store them. ++ if (mapping != NULL && mapping[i] == -1) { ++ for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { ++ int alphabet_size = kAlphabetSize[j]; ++ if (j == 0 && color_cache_bits > 0) { ++ alphabet_size += (1 << color_cache_bits); ++ } ++ // Passing in NULL so that nothing gets filled. ++ if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) { ++ goto Error; ++ } + } +- total_size += huffman_tables_i->bits; +- huffman_tables_i += size; +- if (j <= ALPHA) { +- int local_max_bits = code_lengths[0]; +- int k; +- for (k = 1; k < alphabet_size; ++k) { +- if (code_lengths[k] > local_max_bits) { +- local_max_bits = code_lengths[k]; ++ } else { ++ HTreeGroup* const htree_group = ++ &htree_groups[(mapping == NULL) ? i : mapping[i]]; ++ HuffmanCode** const htrees = htree_group->htrees; ++ int size; ++ int total_size = 0; ++ int is_trivial_literal = 1; ++ int max_bits = 0; ++ for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { ++ int alphabet_size = kAlphabetSize[j]; ++ if (j == 0 && color_cache_bits > 0) { ++ alphabet_size += (1 << color_cache_bits); ++ } ++ size = ++ ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables); ++ htrees[j] = huffman_tables->curr_segment->curr_table; ++ if (size == 0) { ++ goto Error; ++ } ++ if (is_trivial_literal && kLiteralMap[j] == 1) { ++ is_trivial_literal = (htrees[j]->bits == 0); ++ } ++ total_size += htrees[j]->bits; ++ huffman_tables->curr_segment->curr_table += size; ++ if (j <= ALPHA) { ++ int local_max_bits = code_lengths[0]; ++ int k; ++ for (k = 1; k < alphabet_size; ++k) { ++ if (code_lengths[k] > local_max_bits) { ++ local_max_bits = code_lengths[k]; ++ } + } ++ max_bits += local_max_bits; + } +- max_bits += local_max_bits; + } +- } +- if (!is_bogus) next = huffman_tables_i; +- htree_group->is_trivial_literal = is_trivial_literal; +- htree_group->is_trivial_code = 0; +- if (is_trivial_literal) { +- const int red = htrees[RED][0].value; +- const int blue = htrees[BLUE][0].value; +- const int alpha = htrees[ALPHA][0].value; +- htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue; +- if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) { +- htree_group->is_trivial_code = 1; +- htree_group->literal_arb |= htrees[GREEN][0].value << 8; ++ htree_group->is_trivial_literal = is_trivial_literal; ++ htree_group->is_trivial_code = 0; ++ if (is_trivial_literal) { ++ const int red = htrees[RED][0].value; ++ const int blue = htrees[BLUE][0].value; ++ const int alpha = htrees[ALPHA][0].value; ++ htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue; ++ if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) { ++ htree_group->is_trivial_code = 1; ++ htree_group->literal_arb |= htrees[GREEN][0].value << 8; ++ } + } ++ htree_group->use_packed_table = ++ !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS); ++ if (htree_group->use_packed_table) BuildPackedTable(htree_group); + } +- htree_group->use_packed_table = +- !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS); +- if (htree_group->use_packed_table) BuildPackedTable(htree_group); + } + ok = 1; + +@@ -517,15 +520,13 @@ static int ReadHuffmanCodes(VP8LDecoder* + hdr->huffman_image_ = huffman_image; + hdr->num_htree_groups_ = num_htree_groups; + hdr->htree_groups_ = htree_groups; +- hdr->huffman_tables_ = huffman_tables; + + Error: + WebPSafeFree(code_lengths); +- WebPSafeFree(huffman_tables_bogus); + WebPSafeFree(mapping); + if (!ok) { + WebPSafeFree(huffman_image); +- WebPSafeFree(huffman_tables); ++ VP8LHuffmanTablesDeallocate(huffman_tables); + VP8LHtreeGroupsFree(htree_groups); + } + return ok; +@@ -757,11 +758,11 @@ static WEBP_INLINE HTreeGroup* GetHtreeG + + typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row); + +-static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows, ++static void ApplyInverseTransforms(VP8LDecoder* const dec, ++ int start_row, int num_rows, + const uint32_t* const rows) { + int n = dec->next_transform_; + const int cache_pixs = dec->width_ * num_rows; +- const int start_row = dec->last_row_; + const int end_row = start_row + num_rows; + const uint32_t* rows_in = rows; + uint32_t* const rows_out = dec->argb_cache_; +@@ -792,8 +793,7 @@ static void ProcessRows(VP8LDecoder* con + VP8Io* const io = dec->io_; + uint8_t* rows_data = (uint8_t*)dec->argb_cache_; + const int in_stride = io->width * sizeof(uint32_t); // in unit of RGBA +- +- ApplyInverseTransforms(dec, num_rows, rows); ++ ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows); + if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) { + // Nothing to output (this time). + } else { +@@ -951,7 +951,6 @@ static WEBP_INLINE void CopyBlock8b(uint + break; + default: + goto Copy; +- break; + } + CopySmallPattern8b(src, dst, length, pattern); + return; +@@ -1196,6 +1195,7 @@ static int DecodeImageData(VP8LDecoder* + VP8LFillBitWindow(br); + dist_code = GetCopyDistance(dist_symbol, br); + dist = PlaneCodeToDistance(width, dist_code); ++ + if (VP8LIsEndOfStream(br)) break; + if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) { + goto Error; +@@ -1357,7 +1357,7 @@ static void ClearMetadata(VP8LMetadata* + assert(hdr != NULL); + + WebPSafeFree(hdr->huffman_image_); +- WebPSafeFree(hdr->huffman_tables_); ++ VP8LHuffmanTablesDeallocate(&hdr->huffman_tables_); + VP8LHtreeGroupsFree(hdr->htree_groups_); + VP8LColorCacheClear(&hdr->color_cache_); + VP8LColorCacheClear(&hdr->saved_color_cache_); +@@ -1556,7 +1556,7 @@ static void ExtractAlphaRows(VP8LDecoder + const int cache_pixs = width * num_rows_to_process; + uint8_t* const dst = output + width * cur_row; + const uint32_t* const src = dec->argb_cache_; +- ApplyInverseTransforms(dec, num_rows_to_process, in); ++ ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in); + WebPExtractGreen(src, dst, cache_pixs); + AlphaApplyFilter(alph_dec, + cur_row, cur_row + num_rows_to_process, dst, width); +@@ -1673,7 +1673,7 @@ int VP8LDecodeImage(VP8LDecoder* const d + // Sanity checks. + if (dec == NULL) return 0; + +- assert(dec->hdr_.huffman_tables_ != NULL); ++ assert(dec->hdr_.huffman_tables_.root.start != NULL); + assert(dec->hdr_.htree_groups_ != NULL); + assert(dec->hdr_.num_htree_groups_ > 0); + +diff -up libwebp-1.0.0/src/dec/vp8li_dec.h.old libwebp-1.0.0/src/dec/vp8li_dec.h +--- libwebp-1.0.0/src/dec/vp8li_dec.h.old 2023-09-15 11:07:13.032063220 +0200 ++++ libwebp-1.0.0/src/dec/vp8li_dec.h 2023-09-15 10:54:47.046025885 +0200 +@@ -37,7 +37,7 @@ struct VP8LTransform { + int bits_; // subsampling bits defining transform window. + int xsize_; // transform window X index. + int ysize_; // transform window Y index. +- uint32_t *data_; // transform data. ++ uint32_t* data_; // transform data. + }; + + typedef struct { +@@ -48,23 +48,23 @@ typedef struct { + int huffman_mask_; + int huffman_subsample_bits_; + int huffman_xsize_; +- uint32_t *huffman_image_; ++ uint32_t* huffman_image_; + int num_htree_groups_; +- HTreeGroup *htree_groups_; +- HuffmanCode *huffman_tables_; ++ HTreeGroup* htree_groups_; ++ HuffmanTables huffman_tables_; + } VP8LMetadata; + + typedef struct VP8LDecoder VP8LDecoder; + struct VP8LDecoder { + VP8StatusCode status_; + VP8LDecodeState state_; +- VP8Io *io_; ++ VP8Io* io_; + +- const WebPDecBuffer *output_; // shortcut to io->opaque->output ++ const WebPDecBuffer* output_; // shortcut to io->opaque->output + +- uint32_t *pixels_; // Internal data: either uint8_t* for alpha ++ uint32_t* pixels_; // Internal data: either uint8_t* for alpha + // or uint32_t* for BGRA. +- uint32_t *argb_cache_; // Scratch buffer for temporary BGRA storage. ++ uint32_t* argb_cache_; // Scratch buffer for temporary BGRA storage. + + VP8LBitReader br_; + int incremental_; // if true, incremental decoding is expected +@@ -86,8 +86,8 @@ struct VP8LDecoder { + // or'd bitset storing the transforms types. + uint32_t transforms_seen_; + +- uint8_t *rescaler_memory; // Working memory for rescaling work. +- WebPRescaler *rescaler; // Common rescaler for all channels. ++ uint8_t* rescaler_memory; // Working memory for rescaling work. ++ WebPRescaler* rescaler; // Common rescaler for all channels. + }; + + //------------------------------------------------------------------------------ +@@ -132,4 +132,4 @@ void VP8LDelete(VP8LDecoder* const dec); + } // extern "C" + #endif + +-#endif /* WEBP_DEC_VP8LI_DEC_H_ */ ++#endif // WEBP_DEC_VP8LI_DEC_H_ +diff -up libwebp-1.0.0/src/utils/huffman_utils.c.old libwebp-1.0.0/src/utils/huffman_utils.c +--- libwebp-1.0.0/src/utils/huffman_utils.c.old 2018-04-21 05:04:55.000000000 +0200 ++++ libwebp-1.0.0/src/utils/huffman_utils.c 2023-09-15 10:54:47.047025920 +0200 +@@ -91,7 +91,8 @@ static int BuildHuffmanTable(HuffmanCode + + assert(code_lengths_size != 0); + assert(code_lengths != NULL); +- assert(root_table != NULL); ++ assert((root_table != NULL && sorted != NULL) || ++ (root_table == NULL && sorted == NULL)); + assert(root_bits > 0); + + // Build histogram of code lengths. +@@ -120,16 +121,22 @@ static int BuildHuffmanTable(HuffmanCode + for (symbol = 0; symbol < code_lengths_size; ++symbol) { + const int symbol_code_length = code_lengths[symbol]; + if (code_lengths[symbol] > 0) { +- sorted[offset[symbol_code_length]++] = symbol; ++ if (sorted != NULL) { ++ sorted[offset[symbol_code_length]++] = symbol; ++ } else { ++ offset[symbol_code_length]++; ++ } + } + } + + // Special case code with only one value. + if (offset[MAX_ALLOWED_CODE_LENGTH] == 1) { +- HuffmanCode code; +- code.bits = 0; +- code.value = (uint16_t)sorted[0]; +- ReplicateValue(table, 1, total_size, code); ++ if (sorted != NULL) { ++ HuffmanCode code; ++ code.bits = 0; ++ code.value = (uint16_t)sorted[0]; ++ ReplicateValue(table, 1, total_size, code); ++ } + return total_size; + } + +@@ -151,6 +158,7 @@ static int BuildHuffmanTable(HuffmanCode + if (num_open < 0) { + return 0; + } ++ if (root_table == NULL) continue; + for (; count[len] > 0; --count[len]) { + HuffmanCode code; + code.bits = (uint8_t)len; +@@ -172,17 +180,21 @@ static int BuildHuffmanTable(HuffmanCode + for (; count[len] > 0; --count[len]) { + HuffmanCode code; + if ((key & mask) != low) { +- table += table_size; ++ if (root_table != NULL) table += table_size; + table_bits = NextTableBitSize(count, len, root_bits); + table_size = 1 << table_bits; + total_size += table_size; + low = key & mask; +- root_table[low].bits = (uint8_t)(table_bits + root_bits); +- root_table[low].value = (uint16_t)((table - root_table) - low); ++ if (root_table != NULL) { ++ root_table[low].bits = (uint8_t)(table_bits + root_bits); ++ root_table[low].value = (uint16_t)((table - root_table) - low); ++ } ++ } ++ if (root_table != NULL) { ++ code.bits = (uint8_t)(len - root_bits); ++ code.value = (uint16_t)sorted[symbol++]; ++ ReplicateValue(&table[key >> root_bits], step, table_size, code); + } +- code.bits = (uint8_t)(len - root_bits); +- code.value = (uint16_t)sorted[symbol++]; +- ReplicateValue(&table[key >> root_bits], step, table_size, code); + key = GetNextKey(key, len); + } + } +@@ -202,22 +214,83 @@ static int BuildHuffmanTable(HuffmanCode + ((1 << MAX_CACHE_BITS) + NUM_LITERAL_CODES + NUM_LENGTH_CODES) + // Cut-off value for switching between heap and stack allocation. + #define SORTED_SIZE_CUTOFF 512 +-int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits, ++int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits, + const int code_lengths[], int code_lengths_size) { +- int total_size; ++ const int total_size = ++ BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL); + assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE); ++ if (total_size == 0 || root_table == NULL) return total_size; ++ ++ if (root_table->curr_segment->curr_table + total_size >= ++ root_table->curr_segment->start + root_table->curr_segment->size) { ++ // If 'root_table' does not have enough memory, allocate a new segment. ++ // The available part of root_table->curr_segment is left unused because we ++ // need a contiguous buffer. ++ const int segment_size = root_table->curr_segment->size; ++ struct HuffmanTablesSegment* next = ++ (HuffmanTablesSegment*)WebPSafeMalloc(1, sizeof(*next)); ++ if (next == NULL) return 0; ++ // Fill the new segment. ++ // We need at least 'total_size' but if that value is small, it is better to ++ // allocate a big chunk to prevent more allocations later. 'segment_size' is ++ // therefore chosen (any other arbitrary value could be chosen). ++ next->size = total_size > segment_size ? total_size : segment_size; ++ next->start = ++ (HuffmanCode*)WebPSafeMalloc(next->size, sizeof(*next->start)); ++ if (next->start == NULL) { ++ WebPSafeFree(next); ++ return 0; ++ } ++ next->curr_table = next->start; ++ next->next = NULL; ++ // Point to the new segment. ++ root_table->curr_segment->next = next; ++ root_table->curr_segment = next; ++ } + if (code_lengths_size <= SORTED_SIZE_CUTOFF) { + // use local stack-allocated array. + uint16_t sorted[SORTED_SIZE_CUTOFF]; +- total_size = BuildHuffmanTable(root_table, root_bits, +- code_lengths, code_lengths_size, sorted); +- } else { // rare case. Use heap allocation. ++ BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits, ++ code_lengths, code_lengths_size, sorted); ++ } else { // rare case. Use heap allocation. + uint16_t* const sorted = + (uint16_t*)WebPSafeMalloc(code_lengths_size, sizeof(*sorted)); + if (sorted == NULL) return 0; +- total_size = BuildHuffmanTable(root_table, root_bits, +- code_lengths, code_lengths_size, sorted); ++ BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits, ++ code_lengths, code_lengths_size, sorted); + WebPSafeFree(sorted); + } + return total_size; + } ++ ++int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) { ++ // Have 'segment' point to the first segment for now, 'root'. ++ HuffmanTablesSegment* const root = &huffman_tables->root; ++ huffman_tables->curr_segment = root; ++ // Allocate root. ++ root->start = (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start)); ++ if (root->start == NULL) return 0; ++ root->curr_table = root->start; ++ root->next = NULL; ++ root->size = size; ++ return 1; ++} ++ ++void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) { ++ HuffmanTablesSegment *current, *next; ++ if (huffman_tables == NULL) return; ++ // Free the root node. ++ current = &huffman_tables->root; ++ next = current->next; ++ WebPSafeFree(current->start); ++ current->start = NULL; ++ current->next = NULL; ++ current = next; ++ // Free the following nodes. ++ while (current != NULL) { ++ next = current->next; ++ WebPSafeFree(current->start); ++ WebPSafeFree(current); ++ current = next; ++ } ++} +diff -up libwebp-1.0.0/src/utils/huffman_utils.h.old libwebp-1.0.0/src/utils/huffman_utils.h +--- libwebp-1.0.0/src/utils/huffman_utils.h.old 2018-04-21 05:04:55.000000000 +0200 ++++ libwebp-1.0.0/src/utils/huffman_utils.h 2023-09-15 10:54:47.047025920 +0200 +@@ -43,6 +43,29 @@ typedef struct { + // or non-literal symbol otherwise + } HuffmanCode32; + ++// Contiguous memory segment of HuffmanCodes. ++typedef struct HuffmanTablesSegment { ++ HuffmanCode* start; ++ // Pointer to where we are writing into the segment. Starts at 'start' and ++ // cannot go beyond 'start' + 'size'. ++ HuffmanCode* curr_table; ++ // Pointer to the next segment in the chain. ++ struct HuffmanTablesSegment* next; ++ int size; ++} HuffmanTablesSegment; ++ ++// Chained memory segments of HuffmanCodes. ++typedef struct HuffmanTables { ++ HuffmanTablesSegment root; ++ // Currently processed segment. At first, this is 'root'. ++ HuffmanTablesSegment* curr_segment; ++} HuffmanTables; ++ ++// Allocates a HuffmanTables with 'size' contiguous HuffmanCodes. Returns 0 on ++// memory allocation error, 1 otherwise. ++int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables); ++void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables); ++ + #define HUFFMAN_PACKED_BITS 6 + #define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS) + +@@ -78,7 +101,7 @@ void VP8LHtreeGroupsFree(HTreeGroup* con + // the huffman table. + // Returns built table size or 0 in case of error (invalid tree or + // memory error). +-int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits, ++int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits, + const int code_lengths[], int code_lengths_size); + + #ifdef __cplusplus diff --git a/SPECS/libwebp.spec b/SPECS/libwebp.spec index 363737f..bef464b 100644 --- a/SPECS/libwebp.spec +++ b/SPECS/libwebp.spec @@ -2,7 +2,7 @@ Name: libwebp Version: 1.0.0 -Release: 8%{?dist} +Release: 8%{?dist}.1 URL: http://webmproject.org/ Summary: Library and tools for the WebP graphics format # Additional IPR is licensed as well. See PATENTS file for details @@ -17,6 +17,7 @@ Patch4: rhbz-1956856.patch Patch5: rhbz-1956917.patch Patch6: rhbz-1956868.patch Patch7: mozilla-1819244.patch +Patch8: 4619a48fc-1.0.0.patch BuildRequires: libjpeg-devel BuildRequires: libpng-devel @@ -149,9 +150,15 @@ cp swig/*.jar swig/*.so %{buildroot}/%{_libdir}/%{name}-java/ %changelog -* Wed Apr 26 2023 Martin Stransky - 1.0.0-8 +* Fri Sep 15 2023 Tomas Popela - 1.0.0-8.el8_8.1 +- Bump the release to fix upgrade path + +* Fri Sep 15 2023 Tomas Popela - 1.0.0-5.el8_8.2 - Added fix for mzbz#1819244 +* Fri Sep 15 2023 Martin Stransky - 1.0.0-5.el8_8.1 +- Added fix for CVE-2023-4863 + * Thu May 27 2021 Martin Stransky - 1.0.0-5 - Added fixes for rhbz#1956853, rhbz#1956856, rhbz#1956868, rhbz#1956917