Update XZ Utils to 5.0.4 (third_party)

src/liblzma/simple/simple_coder.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       simple_coder.c
 /// \brief      Wrapper for simple filters
 ///
 /// Simple filters don't change the size of the data i.e. number of bytes
 /// in equals the number of bytes out.
 //
 //  Author:     Lasse Collin
 //
@@ skipping 17 matching lines @@
         if (coder->next.code == NULL) {
                 lzma_bufcpy(in, in_pos, in_size, out, out_pos, out_size);
 
                 // Check if end of stream was reached.
                 if (coder->is_encoder && action == LZMA_FINISH
                                 && *in_pos == in_size)
                         coder->end_was_reached = true;
 
         } else {
                 // Call the next coder in the chain to provide us some data.
-                // We don't care about uncompressed_size here, because
-                // the next filter in the chain will do it for us (since
-                // we don't change the size of the data).
                 const lzma_ret ret = coder->next.code(
                                 coder->next.coder, allocator,
                                 in, in_pos, in_size,
                                 out, out_pos, out_size, action);
 
                 if (ret == LZMA_STREAM_END) {
                         assert(!coder->is_encoder
                                         || action == LZMA_FINISH);
                         coder->end_was_reached = true;
 
@@ skipping 52 matching lines @@
 
         assert(!coder->end_was_reached);
 
         // If there is more output space left than there is unfiltered data
         // in coder->buffer[], flush coder->buffer[] to out[], and copy/code
         // more data to out[] hopefully filling it completely. Then filter
         // the data in out[]. This step is where most of the data gets
         // filtered if the buffer sizes used by the application are reasonable.
         const size_t out_avail = out_size - *out_pos;
         const size_t buf_avail = coder->size - coder->pos;
-        if (out_avail > buf_avail) {
+        if (out_avail > buf_avail || buf_avail == 0) {
                 // Store the old position so that we know from which byte
                 // to start filtering.
                 const size_t out_start = *out_pos;
 
                 // Flush data from coder->buffer[] to out[], but don't reset
                 // coder->pos and coder->size yet. This way the coder can be
                 // restarted if the next filter in the chain returns e.g.
                 // LZMA_MEM_ERROR.
                 memcpy(out + *out_pos, coder->buffer + coder->pos, buf_avail);
                 *out_pos += buf_avail;
@@ skipping 147 matching lines @@
         // Reset variables.
         next->coder->is_encoder = is_encoder;
         next->coder->end_was_reached = false;
         next->coder->pos = 0;
         next->coder->filtered = 0;
         next->coder->size = 0;
 
         return lzma_next_filter_init(
                         &next->coder->next, allocator, filters + 1);
 }