avcodec/flashsv2enc: Avoid opening and closing z_stream

Instead initialize a z_stream during init and reset it when needed.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>

configure

@@ -2812,7 +2812,7 @@ fic_decoder_select="golomb"
 flac_decoder_select="flacdsp"
 flac_encoder_select="bswapdsp flacdsp lpc"
 flashsv2_decoder_select="inflate_wrapper"
-flashsv2_encoder_deps="zlib"
+flashsv2_encoder_select="deflate_wrapper"
 flashsv_decoder_select="inflate_wrapper"
 flashsv_encoder_deps="zlib"
 flv_decoder_select="h263_decoder"

libavcodec/flashsv2enc.c

@@ -52,6 +52,7 @@
 #include "internal.h"
 #include "put_bits.h"
 #include "bytestream.h"
+#include "zlib_wrapper.h"
 
 #define HAS_IFRAME_IMAGE 0x02
 #define HAS_PALLET_INFO 0x01
@@ -112,6 +113,7 @@ typedef struct FlashSV2Context {
     uint8_t use_custom_palette;
     uint8_t palette_type;       ///< 0=>default, 1=>custom - changed when palette regenerated.
     Palette palette;
+    FFZStream zstream;
 #ifndef FLASHSV2_DUMB
     double tot_blocks;          ///< blocks encoded since last keyframe
     double diff_blocks;         ///< blocks that were different since last keyframe
@@ -136,6 +138,7 @@ static av_cold void cleanup(FlashSV2Context * s)
 
     av_freep(&s->frame_blocks);
     av_freep(&s->key_blocks);
+    ff_deflate_end(&s->zstream);
 }
 
 static void init_blocks(FlashSV2Context * s, Block * blocks,
@@ -234,7 +237,9 @@ static av_cold int flashsv2_encode_init(AVCodecContext * avctx)
     if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
         return ret;
 
-
+    ret = ff_deflate_init(&s->zstream, s->comp, avctx);
+    if (ret < 0)
+        return ret;
     s->last_key_frame = 0;
 
     s->image_width  = avctx->width;
@@ -357,41 +362,47 @@ static int write_block(Block * b, uint8_t * buf, int buf_size)
     return buf_pos;
 }
 
-static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
+static int encode_zlib(Block *b, uint8_t *buf, unsigned long *buf_size,
+                       z_stream *zstream)
 {
-    int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
+    int res;
-    return res == Z_OK ? 0 : -1;
+
+    if (deflateReset(zstream) != Z_OK)
+        return AVERROR_EXTERNAL;
+    zstream->next_out  = buf;
+    zstream->avail_out = *buf_size;
+    zstream->next_in   = b->sl_begin;
+    zstream->avail_in  = b->sl_end - b->sl_begin;
+    res = deflate(zstream, Z_FINISH);
+    if (res != Z_STREAM_END)
+        return AVERROR_EXTERNAL;
+    *buf_size -= zstream->avail_out;
+    return 0;
 }
 
 static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
-                            int *buf_size, int comp)
+                            int *buf_size, z_stream *zstream)
 {
-    z_stream s;
     int res;
-    s.zalloc = NULL;
-    s.zfree  = NULL;
-    s.opaque = NULL;
-    res = deflateInit(&s, comp);
-    if (res < 0)
-        return -1;
 
-    s.next_in  = prime->enc;
+    if (deflateReset(zstream) != Z_OK)
-    s.avail_in = prime->enc_size;
+        return AVERROR_EXTERNAL;
-    while (s.avail_in > 0) {
+    zstream->next_in  = prime->enc;
-        s.next_out  = buf;
+    zstream->avail_in = prime->enc_size;
-        s.avail_out = *buf_size;
+    while (zstream->avail_in > 0) {
-        res = deflate(&s, Z_SYNC_FLUSH);
+        zstream->next_out  = buf;
+        zstream->avail_out = *buf_size;
+        res = deflate(zstream, Z_SYNC_FLUSH);
         if (res < 0)
             return -1;
     }
 
-    s.next_in   = b->sl_begin;
+    zstream->next_in   = b->sl_begin;
-    s.avail_in  = b->sl_end - b->sl_begin;
+    zstream->avail_in  = b->sl_end - b->sl_begin;
-    s.next_out  = buf;
+    zstream->next_out  = buf;
-    s.avail_out = *buf_size;
+    zstream->avail_out = *buf_size;
-    res = deflate(&s, Z_FINISH);
+    res = deflate(zstream, Z_FINISH);
-    deflateEnd(&s);
+    *buf_size -= zstream->avail_out;
-    *buf_size -= s.avail_out;
     if (res != Z_STREAM_END)
         return -1;
     return 0;
@@ -559,7 +570,7 @@ static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
 }
 
 static int encode_block(FlashSV2Context *s, Palette * palette, Block * b,
-                        Block * prev, const uint8_t * src, int stride, int comp,
+                        Block *prev, const uint8_t *src, int stride,
                         int dist, int keyframe)
 {
     unsigned buf_size = b->width * b->height * 6;
@@ -574,12 +585,12 @@ static int encode_block(FlashSV2Context *s, Palette * palette, Block * b,
 
     if (b->len > 0) {
         b->data_size = buf_size;
-        res = encode_zlib(b, b->data, &b->data_size, comp);
+        res = encode_zlib(b, b->data, &b->data_size, &s->zstream.zstream);
         if (res)
             return res;
 
         if (!keyframe) {
-            res = encode_zlibprime(b, prev, buf, &buf_size, comp);
+            res = encode_zlibprime(b, prev, buf, &buf_size, &s->zstream.zstream);
             if (res)
                 return res;
 
@@ -656,7 +667,8 @@ static int encode_all_blocks(FlashSV2Context * s, int keyframe)
                 b->flags |= HAS_DIFF_BLOCKS;
             }
             data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
-            res = encode_block(s, &s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
+            res = encode_block(s, &s->palette, b, prev, data,
+                               s->image_width * 3, s->dist, keyframe);
 #ifndef FLASHSV2_DUMB
             if (b->dirty)
                 s->diff_blocks++;