Merge commit 'd48c20630214a4effcc920e93a5044bee4e2002e'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 17 Nov 2013 02:31:32 +0000 (03:31 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 17 Nov 2013 02:31:32 +0000 (03:31 +0100)
* commit 'd48c20630214a4effcc920e93a5044bee4e2002e':
  qtrleenc: use the AVFrame API properly.
  ulti: use the AVFrame API properly.
  vc1: use the AVFrame API properly.
  flashsv: use the AVFrame API properly.

Conflicts:
libavcodec/flashsv.c
libavcodec/qtrleenc.c
libavcodec/ulti.c
libavcodec/vc1dec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/flashsv.c
libavcodec/qtrleenc.c
libavcodec/ulti.c
libavcodec/vc1.h
libavcodec/vc1dec.c

@@@ -99,6 -99,19 +99,19 @@@ static int decode_hybrid(const uint8_t 
      return sptr - orig_src;
  }
  
 -    av_free(s->tmpblock);
+ static av_cold int flashsv_decode_end(AVCodecContext *avctx)
+ {
+     FlashSVContext *s = avctx->priv_data;
+     inflateEnd(&s->zstream);
+     /* release the frame if needed */
+     av_frame_free(&s->frame);
+     /* free the tmpblock */
++    av_freep(&s->tmpblock);
+     return 0;
+ }
  static av_cold int flashsv_decode_init(AVCodecContext *avctx)
  {
      FlashSVContext *s = avctx->priv_data;
@@@ -344,8 -351,10 +362,8 @@@ static int flashsv_decode_frame(AVCodec
              s->image_width, s->image_height, s->block_width, s->block_height,
              h_blocks, v_blocks, h_part, v_part);
  
-     if ((ret = ff_reget_buffer(avctx, &s->frame)) < 0)
 -    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
++    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
          return ret;
 -    }
  
      /* loop over all block columns */
      for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
@@@ -90,25 -95,31 +102,31 @@@ static av_cold int qtrle_encode_init(AV
          av_log(avctx, AV_LOG_ERROR, "Unsupported colorspace.\n");
          break;
      }
 -    avctx->bits_per_coded_sample = s->pixel_size*8;
 +    avctx->bits_per_coded_sample = avctx->pix_fmt == AV_PIX_FMT_GRAY8 ? 40 : s->pixel_size*8;
  
 -    s->rlecode_table = av_mallocz(s->avctx->width);
 -    s->skip_table    = av_mallocz(s->avctx->width);
 -    s->length_table  = av_mallocz((s->avctx->width + 1)*sizeof(int));
 +    s->rlecode_table = av_mallocz(s->logical_width);
 +    s->skip_table    = av_mallocz(s->logical_width);
 +    s->length_table  = av_mallocz((s->logical_width + 1)*sizeof(int));
      if (!s->skip_table || !s->length_table || !s->rlecode_table) {
          av_log(avctx, AV_LOG_ERROR, "Error allocating memory.\n");
 -        return -1;
 +        return AVERROR(ENOMEM);
      }
 -    if (avpicture_alloc(&s->previous_frame, avctx->pix_fmt, avctx->width, avctx->height) < 0) {
 +    if ((ret = avpicture_alloc(&s->previous_frame, avctx->pix_fmt, avctx->width, avctx->height)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "Error allocating picture\n");
 -        return -1;
 +        return ret;
      }
  
 -    s->max_buf_size = s->avctx->width*s->avctx->height*s->pixel_size*2 /* image base material */
 -                      + 15                                           /* header + footer */
 -                      + s->avctx->height*2                           /* skip code+rle end */
 -                      + s->avctx->width/MAX_RLE_BULK + 1             /* rle codes */;
 +    s->max_buf_size = s->logical_width*s->avctx->height*s->pixel_size*2 /* image base material */
 +                      + 15                                            /* header + footer */
 +                      + s->avctx->height*2                            /* skip code+rle end */
 +                      + s->logical_width/MAX_RLE_BULK + 1             /* rle codes */;
-     avctx->coded_frame = &s->frame;
+     avctx->coded_frame = av_frame_alloc();
+     if (!avctx->coded_frame) {
+         qtrle_encode_end(avctx);
+         return AVERROR(ENOMEM);
+     }
      return 0;
  }
  
@@@ -146,58 -157,9 +164,58 @@@ static void qtrle_encode_line(QtrleEncC
      s->length_table[width] = 0;
      skipcount = 0;
  
 +    /* Initial values */
 +    lowest_bulk_cost = INT_MAX / 2;
 +    lowest_bulk_cost_index = width;
 +    sec_lowest_bulk_cost = INT_MAX / 2;
 +    sec_lowest_bulk_cost_index = width;
 +
 +    base_bulk_cost = 1 + s->pixel_size;
 +
      for (i = width - 1; i >= 0; i--) {
  
-         if (!s->frame.key_frame && !memcmp(this_line, prev_line, s->pixel_size))
 +        int prev_bulk_cost;
 +
 +        /* If our lowest bulk cost index is too far away, replace it
 +         * with the next lowest bulk cost */
 +        if (FFMIN(width, i + MAX_RLE_BULK) < lowest_bulk_cost_index) {
 +            lowest_bulk_cost = sec_lowest_bulk_cost;
 +            lowest_bulk_cost_index = sec_lowest_bulk_cost_index;
 +
 +            sec_lowest_bulk_cost = INT_MAX / 2;
 +            sec_lowest_bulk_cost_index = width;
 +        }
 +
 +        /* Deal with the first pixel's bulk cost */
 +        if (!i) {
 +            base_bulk_cost++;
 +            lowest_bulk_cost++;
 +            sec_lowest_bulk_cost++;
 +        }
 +
 +        /* Look at the bulk cost of the previous loop and see if it is
 +         * a new lower bulk cost */
 +        prev_bulk_cost = s->length_table[i + 1] + base_bulk_cost;
 +        if (prev_bulk_cost <= sec_lowest_bulk_cost) {
 +            /* If it's lower than the 2nd lowest, then it may be lower
 +             * than the lowest */
 +            if (prev_bulk_cost <= lowest_bulk_cost) {
 +
 +                /* If we have found a new lowest bulk cost,
 +                 * then the 2nd lowest bulk cost is now farther than the
 +                 * lowest bulk cost, and will never be used */
 +                sec_lowest_bulk_cost = INT_MAX / 2;
 +
 +                lowest_bulk_cost = prev_bulk_cost;
 +                lowest_bulk_cost_index = i + 1;
 +            } else {
 +                /* Then it must be the 2nd lowest bulk cost */
 +                sec_lowest_bulk_cost = prev_bulk_cost;
 +                sec_lowest_bulk_cost_index = i + 1;
 +            }
 +        }
 +
+         if (!s->avctx->coded_frame->key_frame && !memcmp(this_line, prev_line, s->pixel_size))
              skipcount = FFMIN(skipcount + 1, MAX_RLE_SKIP);
          else
              skipcount = 0;
@@@ -308,8 -263,8 +326,8 @@@ static int encode_frame(QtrleEncContex
      int end_line = s->avctx->height;
      uint8_t *orig_buf = buf;
  
-     if (!s->frame.key_frame) {
+     if (!s->avctx->coded_frame->key_frame) {
 -        unsigned line_size = s->avctx->width * s->pixel_size;
 +        unsigned line_size = s->logical_width * s->pixel_size;
          for (start_line = 0; start_line < s->avctx->height; start_line++)
              if (memcmp(p->data[0] + start_line*p->linesize[0],
                         s->previous_frame.data[0] + start_line*s->previous_frame.linesize[0],
@@@ -346,13 -301,14 +364,11 @@@ static int qtrle_encode_frame(AVCodecCo
                                const AVFrame *pict, int *got_packet)
  {
      QtrleEncContext * const s = avctx->priv_data;
-     AVFrame * const p = &s->frame;
+     AVFrame * const p = avctx->coded_frame;
      int ret;
  
-     *p = *pict;
 -    if ((ret = ff_alloc_packet(pkt, s->max_buf_size)) < 0) {
 -        /* Upper bound check for compressed data */
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", s->max_buf_size);
 +    if ((ret = ff_alloc_packet2(avctx, pkt, s->max_buf_size)) < 0)
          return ret;
 -    }
  
      if (avctx->gop_size == 0 || (s->avctx->frame_number % avctx->gop_size) == 0) {
          /* I-Frame */
@@@ -227,8 -227,10 +227,8 @@@ static int ulti_decode_frame(AVCodecCon
      int skip;
      int tmp;
  
-     if ((ret = ff_reget_buffer(avctx, &s->frame)) < 0)
 -    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
++    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
          return ret;
 -    }
  
      bytestream2_init(&s->gb, buf, buf_size);
  
Simple merge
@@@ -5471,9 -5455,11 +5471,9 @@@ static int vc1_decode_sprites(VC1Contex
          v->two_sprites = 0;
      }
  
-     av_frame_unref(&v->sprite_output_frame);
-     if ((ret = ff_get_buffer(avctx, &v->sprite_output_frame, 0)) < 0)
+     av_frame_unref(v->sprite_output_frame);
 -    if (ff_get_buffer(avctx, v->sprite_output_frame, 0) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -        return -1;
 -    }
++    if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
 +        return ret;
  
      vc1_draw_sprites(v, &sd);