Merge commit '45bde93eefa78c1bdb0936109fbd2e2fb27fbfe7'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 17 Nov 2013 11:02:09 +0000 (12:02 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 17 Nov 2013 11:06:34 +0000 (12:06 +0100)
* commit '45bde93eefa78c1bdb0936109fbd2e2fb27fbfe7':
  sunrastenc: use the AVFrame API properly.
  targaenc: use the AVFrame API properly.
  tiffenc: use the AVFrame API properly.
  pngenc: use the AVFrame API properly.

Conflicts:
libavcodec/pngenc.c
libavcodec/sunrastenc.c
libavcodec/targaenc.c
libavcodec/tiffenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/pngenc.c
libavcodec/sunrastenc.c
libavcodec/targaenc.c
libavcodec/tiffenc.c

@@@ -218,31 -230,19 +217,27 @@@ static int encode_frame(AVCodecContext 
                          const AVFrame *pict, int *got_packet)
  {
      PNGEncContext *s = avctx->priv_data;
-     AVFrame * const p= &s->picture;
+     const AVFrame * const p = pict;
      int bit_depth, color_type, y, len, row_size, ret, is_progressive;
 -    int bits_per_pixel, pass_row_size, enc_row_size, max_packet_size;
 +    int bits_per_pixel, pass_row_size, enc_row_size;
 +    int64_t max_packet_size;
      int compression_level;
      uint8_t *ptr, *top;
      uint8_t *crow_base = NULL, *crow_buf, *crow;
      uint8_t *progressive_buf = NULL;
 -    uint8_t *rgba_buf = NULL;
      uint8_t *top_buf = NULL;
  
-     *p = *pict;
-     p->pict_type= AV_PICTURE_TYPE_I;
-     p->key_frame= 1;
      is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
      switch(avctx->pix_fmt) {
 -    case AV_PIX_FMT_RGB32:
 +    case AV_PIX_FMT_RGBA64BE:
 +        bit_depth = 16;
 +        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 +        break;
 +    case AV_PIX_FMT_RGB48BE:
 +        bit_depth = 16;
 +        color_type = PNG_COLOR_TYPE_RGB;
 +        break;
 +    case AV_PIX_FMT_RGBA:
          bit_depth = 8;
          color_type = PNG_COLOR_TYPE_RGB_ALPHA;
          break;
  static av_cold int png_enc_init(AVCodecContext *avctx){
      PNGEncContext *s = avctx->priv_data;
  
-     avcodec_get_frame_defaults(&s->picture);
-     avctx->coded_frame= &s->picture;
 +    switch(avctx->pix_fmt) {
 +    case AV_PIX_FMT_RGBA:
 +        avctx->bits_per_coded_sample = 32;
 +        break;
 +    case AV_PIX_FMT_RGB24:
 +        avctx->bits_per_coded_sample = 24;
 +        break;
 +    case AV_PIX_FMT_GRAY8:
 +        avctx->bits_per_coded_sample = 0x28;
 +        break;
 +    case AV_PIX_FMT_MONOBLACK:
 +        avctx->bits_per_coded_sample = 1;
 +        break;
 +    case AV_PIX_FMT_PAL8:
 +        avctx->bits_per_coded_sample = 8;
 +    }
 +
+     avctx->coded_frame = av_frame_alloc();
+     if (!avctx->coded_frame)
+         return AVERROR(ENOMEM);
+     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
+     avctx->coded_frame->key_frame = 1;
      ff_dsputil_init(&s->dsp, avctx);
  
      s->filter_type = av_clip(avctx->prediction_method, PNG_FILTER_VALUE_NONE, PNG_FILTER_VALUE_MIXED);
      return 0;
  }
  
+ static av_cold int png_enc_close(AVCodecContext *avctx)
+ {
+     av_frame_free(&avctx->coded_frame);
+     return 0;
+ }
 +#define OFFSET(x) offsetof(PNGEncContext, x)
 +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption options[] = {
 +    {"dpi", "Set image resolution (in dots per inch)",  OFFSET(dpi), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 0x10000, VE},
 +    {"dpm", "Set image resolution (in dots per meter)", OFFSET(dpm), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 0x10000, VE},
 +    { NULL }
 +};
 +
 +static const AVClass pngenc_class = {
 +    .class_name = "PNG encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_png_encoder = {
      .name           = "png",
      .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
      .id             = AV_CODEC_ID_PNG,
      .priv_data_size = sizeof(PNGEncContext),
      .init           = png_enc_init,
+     .close          = png_enc_close,
      .encode2        = encode_frame,
 +    .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
      .pix_fmts       = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8,
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
 +        AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
 +        AV_PIX_FMT_PAL8,
 +        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
          AV_PIX_FMT_GRAY16BE,
          AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
      },
Simple merge
@@@ -175,9 -171,11 +193,11 @@@ AVCodec ff_targa_encoder = 
      .long_name      = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_TARGA,
+     .init           = targa_encode_init,
+     .close          = targa_encode_close,
      .encode2        = targa_encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_GRAY8,
 +        AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
          AV_PIX_FMT_NONE
      },
  };
@@@ -226,34 -203,25 +225,20 @@@ static void pack_yuv(TiffEncoderContex
  static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                          const AVFrame *pict, int *got_packet)
  {
 +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
      TiffEncoderContext *s = avctx->priv_data;
-     AVFrame *const p = &s->picture;
+     const AVFrame *const p = pict;
      int i;
      uint8_t *ptr;
      uint8_t *offset;
      uint32_t strips;
 -    uint32_t *strip_sizes   = NULL;
 -    uint32_t *strip_offsets = NULL;
      int bytes_per_row;
 -    uint32_t res[2]    = { 72, 1 };     // image resolution (72/1)
 -    uint16_t bpp_tab[] = { 8, 8, 8, 8 };
 -    int ret;
 -    int is_yuv = 0;
 -    uint8_t *yuv_line = NULL;
 +    uint32_t res[2] = { s->dpi, 1 };    // image resolution (72/1)
 +    uint16_t bpp_tab[4];
 +    int ret = -1;
 +    int is_yuv = 0, alpha = 0;
      int shift_h, shift_v;
 -    const AVPixFmtDescriptor *pfd;
 -
 -    s->avctx = avctx;
  
-     *p = *pict;
      s->width          = avctx->width;
      s->height         = avctx->height;
      s->subsampling[0] = 1;
          zn               = 0;
          for (j = 0; j < s->rps; j++) {
              if (is_yuv) {
-                 pack_yuv(s, s->yuv_line, j);
 -                pack_yuv(s, p, yuv_line, j);
 -                memcpy(zbuf + zn, yuv_line, bytes_per_row);
++                pack_yuv(s, p, s->yuv_line, j);
 +                memcpy(zbuf + zn, s->yuv_line, bytes_per_row);
                  j += s->subsampling[1] - 1;
              } else
                  memcpy(zbuf + j * bytes_per_row,
                                     s->buf_size - (*s->buf - s->buf_start),
                                     12, FF_LZW_TIFF, put_bits);
              }
 -            strip_offsets[i / s->rps] = ptr - pkt->data;
 +            s->strip_offsets[i / s->rps] = ptr - pkt->data;
          }
          if (is_yuv) {
-             pack_yuv(s, s->yuv_line, i);
 -            pack_yuv(s, p, yuv_line, i);
 -            ret = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
++            pack_yuv(s, p, s->yuv_line, i);
 +            ret = encode_strip(s, s->yuv_line, ptr, bytes_per_row, s->compr);
              i  += s->subsampling[1] - 1;
          } else
              ret = encode_strip(s, p->data[0] + i * p->linesize[0],
      *got_packet = 1;
  
  fail:
 -    av_free(strip_sizes);
 -    av_free(strip_offsets);
 -    av_free(yuv_line);
 -    return ret;
 +    return ret < 0 ? ret : 0;
  }
  
+ static av_cold int encode_init(AVCodecContext *avctx)
+ {
++    TiffEncoderContext *s = avctx->priv_data;
++
+     avctx->coded_frame = av_frame_alloc();
+     if (!avctx->coded_frame)
+         return AVERROR(ENOMEM);
+     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
+     avctx->coded_frame->key_frame = 1;
++    s->avctx = avctx;
+     return 0;
+ }
  static av_cold int encode_close(AVCodecContext *avctx)
  {
 +    TiffEncoderContext *s = avctx->priv_data;
 +
+     av_frame_free(&avctx->coded_frame);
 +    av_freep(&s->strip_sizes);
 +    av_freep(&s->strip_offsets);
 +    av_freep(&s->yuv_line);
 +
      return 0;
  }
  
@@@ -536,15 -509,14 +537,15 @@@ AVCodec ff_tiff_encoder = 
      .id             = AV_CODEC_ID_TIFF,
      .priv_data_size = sizeof(TiffEncoderContext),
      .init           = encode_init,
-     .encode2        = encode_frame,
      .close          = encode_close,
+     .encode2        = encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]) {
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_PAL8,
 -        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16LE,
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8,
 +        AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16LE,
          AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE,
 -        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
 -        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
 +        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
 +        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_RGB48LE,
 +        AV_PIX_FMT_RGBA, AV_PIX_FMT_RGBA64LE,
          AV_PIX_FMT_NONE
      },
      .priv_class     = &tiffenc_class,