Merge commit '7950e519bb094897f957b9a9531cc60ba46cbc91'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 3 Aug 2013 08:08:30 +0000 (10:08 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 3 Aug 2013 08:08:30 +0000 (10:08 +0200)
* commit '7950e519bb094897f957b9a9531cc60ba46cbc91':
  Disable deprecation warnings for cases where a replacement is available

Conflicts:
libavcodec/avpacket.c
libavcodec/pthread.c
libavcodec/utils.c
libavdevice/v4l2.c
libavfilter/avfiltergraph.c
libavfilter/buffersrc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
20 files changed:
1  2 
libavcodec/avpacket.c
libavcodec/mlp_parser.c
libavcodec/mlpdec.c
libavcodec/options_table.h
libavcodec/pthread.c
libavcodec/utils.c
libavdevice/v4l2.c
libavfilter/avfilter.c
libavfilter/avfiltergraph.c
libavfilter/buffersink.c
libavfilter/buffersrc.c
libavfilter/internal.h
libavformat/asfdec.c
libavformat/avidec.c
libavformat/mux.c
libavformat/mxg.c
libavformat/psxstr.c
libavformat/rmdec.c
libavformat/utils.c
libavutil/pixdesc.c

  
  #include "libavutil/avassert.h"
  #include "libavutil/common.h"
+ #include "libavutil/internal.h"
  #include "libavutil/mem.h"
  #include "avcodec.h"
 +#include "bytestream.h"
 +#include "internal.h"
 +
 +void ff_packet_free_side_data(AVPacket *pkt)
 +{
 +    int i;
 +    for (i = 0; i < pkt->side_data_elems; i++)
 +        av_free(pkt->side_data[i].data);
 +    av_freep(&pkt->side_data);
 +    pkt->side_data_elems = 0;
 +}
  
  #if FF_API_DESTRUCT_PACKET
  void av_destruct_packet(AVPacket *pkt)
@@@ -179,57 -177,6 +188,59 @@@ do 
          dst = data;                                                     \
      } while (0)
  
 +/* Makes duplicates of data, side_data, but does not copy any other fields */
 +static int copy_packet_data(AVPacket *pkt, AVPacket *src, int dup)
 +{
 +    pkt->data      = NULL;
 +    pkt->side_data = NULL;
 +    if (pkt->buf) {
 +        AVBufferRef *ref = av_buffer_ref(src->buf);
 +        if (!ref)
 +            return AVERROR(ENOMEM);
 +        pkt->buf  = ref;
 +        pkt->data = ref->data;
 +    } else {
 +        DUP_DATA(pkt->data, src->data, pkt->size, 1, ALLOC_BUF);
 +    }
 +#if FF_API_DESTRUCT_PACKET
++FF_DISABLE_DEPRECATION_WARNINGS
 +    pkt->destruct = dummy_destruct_packet;
++FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
 +    if (pkt->side_data_elems && dup)
 +        pkt->side_data = src->side_data;
 +    if (pkt->side_data_elems && !dup) {
 +        return av_copy_packet_side_data(pkt, src);
 +    }
 +    return 0;
 +
 +failed_alloc:
 +    av_destruct_packet(pkt);
 +    return AVERROR(ENOMEM);
 +}
 +
 +int av_copy_packet_side_data(AVPacket *pkt, AVPacket *src)
 +{
 +    if (src->side_data_elems) {
 +        int i;
 +        DUP_DATA(pkt->side_data, src->side_data,
 +                src->side_data_elems * sizeof(*src->side_data), 0, ALLOC_MALLOC);
 +        memset(pkt->side_data, 0,
 +                src->side_data_elems * sizeof(*src->side_data));
 +        for (i = 0; i < src->side_data_elems; i++) {
 +            DUP_DATA(pkt->side_data[i].data, src->side_data[i].data,
 +                    src->side_data[i].size, 1, ALLOC_MALLOC);
 +            pkt->side_data[i].size = src->side_data[i].size;
 +            pkt->side_data[i].type = src->side_data[i].type;
 +        }
 +    }
 +    return 0;
 +
 +failed_alloc:
 +    av_destruct_packet(pkt);
 +    return AVERROR(ENOMEM);
 +}
 +
  int av_dup_packet(AVPacket *pkt)
  {
      AVPacket tmp_pkt;
@@@ -239,16 -187,38 +251,17 @@@ FF_DISABLE_DEPRECATION_WARNING
          && !pkt->destruct
  #endif
          ) {
+ FF_ENABLE_DEPRECATION_WARNINGS
          tmp_pkt = *pkt;
 -
 -        pkt->data      = NULL;
 -        pkt->side_data = NULL;
 -        DUP_DATA(pkt->data, tmp_pkt.data, pkt->size, 1, ALLOC_BUF);
 -#if FF_API_DESTRUCT_PACKET
 -FF_DISABLE_DEPRECATION_WARNINGS
 -        pkt->destruct = dummy_destruct_packet;
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif
 -
 -        if (pkt->side_data_elems) {
 -            int i;
 -
 -            DUP_DATA(pkt->side_data, tmp_pkt.side_data,
 -                     pkt->side_data_elems * sizeof(*pkt->side_data), 0, ALLOC_MALLOC);
 -            memset(pkt->side_data, 0,
 -                   pkt->side_data_elems * sizeof(*pkt->side_data));
 -            for (i = 0; i < pkt->side_data_elems; i++) {
 -                DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data,
 -                         tmp_pkt.side_data[i].size, 1, ALLOC_MALLOC);
 -                pkt->side_data[i].size = tmp_pkt.side_data[i].size;
 -                pkt->side_data[i].type = tmp_pkt.side_data[i].type;
 -            }
 -        }
 +        return copy_packet_data(pkt, &tmp_pkt, 1);
      }
      return 0;
 +}
  
 -failed_alloc:
 -    av_free_packet(pkt);
 -    return AVERROR(ENOMEM);
 +int av_copy_packet(AVPacket *dst, AVPacket *src)
 +{
 +    *dst = *src;
 +    return copy_packet_data(dst, src, 0);
  }
  
  void av_free_packet(AVPacket *pkt)
@@@ -313,95 -285,6 +328,97 @@@ uint8_t *av_packet_get_side_data(AVPack
      return NULL;
  }
  
 +#define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
 +
 +int av_packet_merge_side_data(AVPacket *pkt){
 +    if(pkt->side_data_elems){
 +        AVBufferRef *buf;
 +        int i;
 +        uint8_t *p;
 +        uint64_t size= pkt->size + 8LL + FF_INPUT_BUFFER_PADDING_SIZE;
 +        AVPacket old= *pkt;
 +        for (i=0; i<old.side_data_elems; i++) {
 +            size += old.side_data[i].size + 5LL;
 +        }
 +        if (size > INT_MAX)
 +            return AVERROR(EINVAL);
 +        buf = av_buffer_alloc(size);
 +        if (!buf)
 +            return AVERROR(ENOMEM);
 +        pkt->buf = buf;
 +        pkt->data = p = buf->data;
 +#if FF_API_DESTRUCT_PACKET
++FF_DISABLE_DEPRECATION_WARNINGS
 +        pkt->destruct = dummy_destruct_packet;
++FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
 +        pkt->size = size - FF_INPUT_BUFFER_PADDING_SIZE;
 +        bytestream_put_buffer(&p, old.data, old.size);
 +        for (i=old.side_data_elems-1; i>=0; i--) {
 +            bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);
 +            bytestream_put_be32(&p, old.side_data[i].size);
 +            *p++ = old.side_data[i].type | ((i==old.side_data_elems-1)*128);
 +        }
 +        bytestream_put_be64(&p, FF_MERGE_MARKER);
 +        av_assert0(p-pkt->data == pkt->size);
 +        memset(p, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 +        av_free_packet(&old);
 +        pkt->side_data_elems = 0;
 +        pkt->side_data = NULL;
 +        return 1;
 +    }
 +    return 0;
 +}
 +
 +int av_packet_split_side_data(AVPacket *pkt){
 +    if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
 +        int i;
 +        unsigned int size, orig_pktsize = pkt->size;
 +        uint8_t *p;
 +
 +        p = pkt->data + pkt->size - 8 - 5;
 +        for (i=1; ; i++){
 +            size = AV_RB32(p);
 +            if (size>INT_MAX || p - pkt->data < size)
 +                return 0;
 +            if (p[4]&128)
 +                break;
 +            p-= size+5;
 +        }
 +
 +        pkt->side_data = av_malloc(i * sizeof(*pkt->side_data));
 +        if (!pkt->side_data)
 +            return AVERROR(ENOMEM);
 +
 +        p= pkt->data + pkt->size - 8 - 5;
 +        for (i=0; ; i++){
 +            size= AV_RB32(p);
 +            av_assert0(size<=INT_MAX && p - pkt->data >= size);
 +            pkt->side_data[i].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 +            pkt->side_data[i].size = size;
 +            pkt->side_data[i].type = p[4]&127;
 +            if (!pkt->side_data[i].data)
 +                return AVERROR(ENOMEM);
 +            memcpy(pkt->side_data[i].data, p-size, size);
 +            pkt->size -= size + 5;
 +            if(p[4]&128)
 +                break;
 +            p-= size+5;
 +        }
 +        pkt->size -= 8;
 +        /* FFMIN() prevents overflow in case the packet wasn't allocated with
 +         * proper padding.
 +         * If the side data is smaller than the buffer padding size, the
 +         * remaining bytes should have already been filled with zeros by the
 +         * original packet allocation anyway. */
 +        memset(pkt->data + pkt->size, 0,
 +               FFMIN(orig_pktsize - pkt->size, FF_INPUT_BUFFER_PADDING_SIZE));
 +        pkt->side_data_elems = i+1;
 +        return 1;
 +    }
 +    return 0;
 +}
 +
  int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                 int size)
  {
Simple merge
Simple merge
  
  #define AV_CODEC_DEFAULT_BITRATE 200*1000
  
+ FF_DISABLE_DEPRECATION_WARNINGS
  static const AVOption avcodec_options[] = {
 -{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, V|A|E},
 +{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, 0, INT_MAX, A|V|E},
 +{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = 128*1000 }, 0, INT_MAX, A|E},
  {"bt", "Set video bitrate tolerance (in bits/s). In 1-pass mode, bitrate tolerance specifies how far "
         "ratecontrol is willing to deviate from the target average bitrate value. This is not related "
         "to minimum/maximum bitrate. Lowering tolerance too much has an adverse effect on quality.",
@@@ -541,14 -514,14 +544,16 @@@ static int submit_packet(PerThreadConte
       * and it calls back to the client here.
       */
  
+ FF_DISABLE_DEPRECATION_WARNINGS
      if (!p->avctx->thread_safe_callbacks && (
 +         p->avctx->get_format != avcodec_default_get_format ||
  #if FF_API_GET_BUFFER
           p->avctx->get_buffer ||
  #endif
           p->avctx->get_buffer2 != avcodec_default_get_buffer2)) {
+ FF_ENABLE_DEPRECATION_WARNINGS
          while (p->state != STATE_SETUP_FINISHED && p->state != STATE_INPUT_READY) {
 +            int call_done = 1;
              pthread_mutex_lock(&p->progress_mutex);
              while (p->state == STATE_SETTING_UP)
                  pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
@@@ -946,15 -883,15 +951,17 @@@ static int thread_get_buffer_internal(A
      }
  
      pthread_mutex_lock(&p->parent->buffer_mutex);
 +
+ FF_DISABLE_DEPRECATION_WARNINGS
      if (avctx->thread_safe_callbacks || (
  #if FF_API_GET_BUFFER
          !avctx->get_buffer &&
  #endif
          avctx->get_buffer2 == avcodec_default_get_buffer2)) {
+ FF_ENABLE_DEPRECATION_WARNINGS
          err = ff_get_buffer(avctx, f->f, flags);
      } else {
 +        pthread_mutex_lock(&p->progress_mutex);
          p->requested_frame = f->f;
          p->requested_flags = flags;
          p->state = STATE_GET_BUFFER;
@@@ -692,54 -592,21 +695,57 @@@ int ff_init_buffer_info(AVCodecContext 
                             avctx->channels);
                      return AVERROR(ENOSYS);
                  }
 -
 -                frame->channel_layout = av_get_default_channel_layout(avctx->channels);
 -                if (!frame->channel_layout)
 -                    frame->channel_layout = (1ULL << avctx->channels) - 1;
              }
          }
 +        av_frame_set_channels(frame, avctx->channels);
          break;
 -    default: return AVERROR(EINVAL);
      }
 +    return 0;
 +}
  
 -    frame->pkt_pts = avctx->pkt ? avctx->pkt->pts : AV_NOPTS_VALUE;
 -    frame->reordered_opaque = avctx->reordered_opaque;
 +#if FF_API_GET_BUFFER
++FF_DISABLE_DEPRECATION_WARNINGS
 +int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
 +{
 +    return avcodec_default_get_buffer2(avctx, frame, 0);
 +}
 +
 +typedef struct CompatReleaseBufPriv {
 +    AVCodecContext avctx;
 +    AVFrame frame;
 +} CompatReleaseBufPriv;
 +
 +static void compat_free_buffer(void *opaque, uint8_t *data)
 +{
 +    CompatReleaseBufPriv *priv = opaque;
 +    if (priv->avctx.release_buffer)
 +        priv->avctx.release_buffer(&priv->avctx, &priv->frame);
 +    av_freep(&priv);
 +}
 +
 +static void compat_release_buffer(void *opaque, uint8_t *data)
 +{
 +    AVBufferRef *buf = opaque;
 +    av_buffer_unref(&buf);
 +}
++FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
 +
 +static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
 +{
 +    int ret;
 +
 +    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 +        if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0 || avctx->pix_fmt<0) {
 +            av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    if ((ret = ff_init_buffer_info(avctx, frame)) < 0)
 +        return ret;
  
  #if FF_API_GET_BUFFER
+ FF_DISABLE_DEPRECATION_WARNINGS
      /*
       * Wrap an old get_buffer()-allocated buffer in an bunch of AVBuffers.
       * We wrap each plane in its own AVBuffer. Each of those has a reference to
@@@ -1446,13 -1102,13 +1453,15 @@@ int ff_alloc_packet2(AVCodecContext *av
      if (avpkt->data) {
          AVBufferRef *buf = avpkt->buf;
  #if FF_API_DESTRUCT_PACKET
+ FF_DISABLE_DEPRECATION_WARNINGS
          void *destruct = avpkt->destruct;
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 -        if (avpkt->size < size)
 +        if (avpkt->size < size) {
 +            av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %d)\n", avpkt->size, size);
              return AVERROR(EINVAL);
 +        }
  
          av_init_packet(avpkt);
  #if FF_API_DESTRUCT_PACKET
@@@ -2998,9 -2053,10 +3009,10 @@@ int ff_match_2uint16(const uint16_t(*ta
  }
  
  #if FF_API_MISSING_SAMPLE
+ FF_DISABLE_DEPRECATION_WARNINGS
  void av_log_missing_feature(void *avc, const char *feature, int want_sample)
  {
 -    av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your Libav "
 +    av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your FFmpeg "
              "version to the newest one from Git. If the problem still "
              "occurs, it means that your file has a feature which has not "
              "been implemented.\n", feature);
Simple merge
@@@ -24,8 -22,8 +24,9 @@@
  #include "libavutil/avstring.h"
  #include "libavutil/channel_layout.h"
  #include "libavutil/common.h"
 +#include "libavutil/eval.h"
  #include "libavutil/imgutils.h"
+ #include "libavutil/internal.h"
  #include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
  #include "libavutil/rational.h"
  
  #include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
  #include "libavutil/channel_layout.h"
 -#include "libavutil/common.h"
+ #include "libavutil/internal.h"
 -#include "libavutil/log.h"
  #include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavcodec/avcodec.h" // avcodec_find_best_pix_fmt_of_2()
  
  #include "avfilter.h"
  #include "formats.h"
@@@ -136,7 -128,9 +137,9 @@@ int avfilter_graph_add_filter(AVFilterG
      graph->filters[graph->nb_filters++] = filter;
  
  #if FF_API_FOO_COUNT
 -    graph->filter_count = graph->nb_filters;
+ FF_DISABLE_DEPRECATION_WARNINGS
 +    graph->filter_count_unused = graph->nb_filters;
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
      filter->graph = graph;
@@@ -201,7 -190,9 +204,9 @@@ AVFilterContext *avfilter_graph_alloc_f
      graph->filters[graph->nb_filters++] = s;
  
  #if FF_API_FOO_COUNT
 -    graph->filter_count = graph->nb_filters;
+ FF_DISABLE_DEPRECATION_WARNINGS
 +    graph->filter_count_unused = graph->nb_filters;
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
      s->graph = graph;
@@@ -27,8 -27,8 +27,9 @@@
  #include "libavutil/avassert.h"
  #include "libavutil/channel_layout.h"
  #include "libavutil/common.h"
+ #include "libavutil/internal.h"
  #include "libavutil/mathematics.h"
 +#include "libavutil/opt.h"
  
  #include "audio.h"
  #include "avfilter.h"
@@@ -219,50 -137,8 +220,51 @@@ int attribute_align_arg av_buffersink_g
      return ret;
  }
  
 +AVBufferSinkParams *av_buffersink_params_alloc(void)
 +{
 +    static const int pixel_fmts[] = { AV_PIX_FMT_NONE };
 +    AVBufferSinkParams *params = av_malloc(sizeof(AVBufferSinkParams));
 +    if (!params)
 +        return NULL;
 +
 +    params->pixel_fmts = pixel_fmts;
 +    return params;
 +}
 +
 +AVABufferSinkParams *av_abuffersink_params_alloc(void)
 +{
 +    AVABufferSinkParams *params = av_mallocz(sizeof(AVABufferSinkParams));
 +
 +    if (!params)
 +        return NULL;
 +    return params;
 +}
 +
 +#define FIFO_INIT_SIZE 8
 +
 +static av_cold int common_init(AVFilterContext *ctx)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +
 +    buf->fifo = av_fifo_alloc(FIFO_INIT_SIZE*sizeof(AVFilterBufferRef *));
 +    if (!buf->fifo) {
 +        av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo\n");
 +        return AVERROR(ENOMEM);
 +    }
 +    buf->warning_limit = 100;
 +    return 0;
 +}
 +
 +void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
 +{
 +    AVFilterLink *inlink = ctx->inputs[0];
 +
 +    inlink->min_samples = inlink->max_samples =
 +    inlink->partial_buf_size = frame_size;
 +}
 +
  #if FF_API_AVFILTERBUFFER
+ FF_DISABLE_DEPRECATION_WARNINGS
  static void compat_free_buffer(AVFilterBuffer *buf)
  {
      AVFrame *frame = buf->priv;
@@@ -332,233 -206,11 +334,234 @@@ int attribute_align_arg av_buffersink_r
  int attribute_align_arg av_buffersink_read_samples(AVFilterContext *ctx, AVFilterBufferRef **buf,
                                                     int nb_samples)
  {
 -    return compat_read(ctx, buf, nb_samples);
 +    return compat_read(ctx, buf, nb_samples, 0);
 +}
 +
 +int attribute_align_arg av_buffersink_get_buffer_ref(AVFilterContext *ctx,
 +                                                     AVFilterBufferRef **bufref, int flags)
 +{
 +    *bufref = NULL;
 +
 +    av_assert0(    !strcmp(ctx->filter->name, "buffersink")
 +                || !strcmp(ctx->filter->name, "abuffersink")
 +                || !strcmp(ctx->filter->name, "ffbuffersink")
 +                || !strcmp(ctx->filter->name, "ffabuffersink"));
 +
 +    return compat_read(ctx, bufref, 0, flags);
  }
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 +AVRational av_buffersink_get_frame_rate(AVFilterContext *ctx)
 +{
 +    av_assert0(   !strcmp(ctx->filter->name, "buffersink")
 +               || !strcmp(ctx->filter->name, "ffbuffersink"));
 +
 +    return ctx->inputs[0]->frame_rate;
 +}
 +
 +int attribute_align_arg av_buffersink_poll_frame(AVFilterContext *ctx)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +    AVFilterLink *inlink = ctx->inputs[0];
 +
 +    av_assert0(   !strcmp(ctx->filter->name, "buffersink")
 +               || !strcmp(ctx->filter->name, "abuffersink")
 +               || !strcmp(ctx->filter->name, "ffbuffersink")
 +               || !strcmp(ctx->filter->name, "ffabuffersink"));
 +
 +    return av_fifo_size(buf->fifo)/sizeof(AVFilterBufferRef *) + ff_poll_frame(inlink);
 +}
 +
 +static av_cold int vsink_init(AVFilterContext *ctx, void *opaque)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +    AVBufferSinkParams *params = opaque;
 +    int ret;
 +
 +    if (params) {
 +        if ((ret = av_opt_set_int_list(buf, "pix_fmts", params->pixel_fmts, AV_PIX_FMT_NONE, 0)) < 0)
 +            return ret;
 +    }
 +
 +    return common_init(ctx);
 +}
 +
 +#define CHECK_LIST_SIZE(field) \
 +        if (buf->field ## _size % sizeof(*buf->field)) { \
 +            av_log(ctx, AV_LOG_ERROR, "Invalid size for " #field ": %d, " \
 +                   "should be multiple of %d\n", \
 +                   buf->field ## _size, (int)sizeof(*buf->field)); \
 +            return AVERROR(EINVAL); \
 +        }
 +static int vsink_query_formats(AVFilterContext *ctx)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +    AVFilterFormats *formats = NULL;
 +    unsigned i;
 +    int ret;
 +
 +    CHECK_LIST_SIZE(pixel_fmts)
 +    if (buf->pixel_fmts_size) {
 +        for (i = 0; i < NB_ITEMS(buf->pixel_fmts); i++)
 +            if ((ret = ff_add_format(&formats, buf->pixel_fmts[i])) < 0) {
 +                ff_formats_unref(&formats);
 +                return ret;
 +            }
 +        ff_set_common_formats(ctx, formats);
 +    } else {
 +        ff_default_query_formats(ctx);
 +    }
 +
 +    return 0;
 +}
 +
 +static av_cold int asink_init(AVFilterContext *ctx, void *opaque)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +    AVABufferSinkParams *params = opaque;
 +    int ret;
 +
 +    if (params) {
 +        if ((ret = av_opt_set_int_list(buf, "sample_fmts",     params->sample_fmts,  AV_SAMPLE_FMT_NONE, 0)) < 0 ||
 +            (ret = av_opt_set_int_list(buf, "sample_rates",    params->sample_rates,    -1, 0)) < 0 ||
 +            (ret = av_opt_set_int_list(buf, "channel_layouts", params->channel_layouts, -1, 0)) < 0 ||
 +            (ret = av_opt_set_int_list(buf, "channel_counts",  params->channel_counts,  -1, 0)) < 0 ||
 +            (ret = av_opt_set_int(buf, "all_channel_counts", params->all_channel_counts, 0)) < 0)
 +            return ret;
 +    }
 +    return common_init(ctx);
 +}
 +
 +static int asink_query_formats(AVFilterContext *ctx)
 +{
 +    BufferSinkContext *buf = ctx->priv;
 +    AVFilterFormats *formats = NULL;
 +    AVFilterChannelLayouts *layouts = NULL;
 +    unsigned i;
 +    int ret;
 +
 +    CHECK_LIST_SIZE(sample_fmts)
 +    CHECK_LIST_SIZE(sample_rates)
 +    CHECK_LIST_SIZE(channel_layouts)
 +    CHECK_LIST_SIZE(channel_counts)
 +
 +    if (buf->sample_fmts_size) {
 +        for (i = 0; i < NB_ITEMS(buf->sample_fmts); i++)
 +            if ((ret = ff_add_format(&formats, buf->sample_fmts[i])) < 0) {
 +                ff_formats_unref(&formats);
 +                return ret;
 +            }
 +        ff_set_common_formats(ctx, formats);
 +    }
 +
 +    if (buf->channel_layouts_size || buf->channel_counts_size ||
 +        buf->all_channel_counts) {
 +        for (i = 0; i < NB_ITEMS(buf->channel_layouts); i++)
 +            if ((ret = ff_add_channel_layout(&layouts, buf->channel_layouts[i])) < 0) {
 +                ff_channel_layouts_unref(&layouts);
 +                return ret;
 +            }
 +        for (i = 0; i < NB_ITEMS(buf->channel_counts); i++)
 +            if ((ret = ff_add_channel_layout(&layouts, FF_COUNT2LAYOUT(buf->channel_counts[i]))) < 0) {
 +                ff_channel_layouts_unref(&layouts);
 +                return ret;
 +            }
 +        if (buf->all_channel_counts) {
 +            if (layouts)
 +                av_log(ctx, AV_LOG_WARNING,
 +                       "Conflicting all_channel_counts and list in options\n");
 +            else if (!(layouts = ff_all_channel_counts()))
 +                return AVERROR(ENOMEM);
 +        }
 +        ff_set_common_channel_layouts(ctx, layouts);
 +    }
 +
 +    if (buf->sample_rates_size) {
 +        formats = NULL;
 +        for (i = 0; i < NB_ITEMS(buf->sample_rates); i++)
 +            if ((ret = ff_add_format(&formats, buf->sample_rates[i])) < 0) {
 +                ff_formats_unref(&formats);
 +                return ret;
 +            }
 +        ff_set_common_samplerates(ctx, formats);
 +    }
 +
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(BufferSinkContext, x)
 +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 +static const AVOption buffersink_options[] = {
 +    { "pix_fmts", "set the supported pixel formats", OFFSET(pixel_fmts), AV_OPT_TYPE_BINARY, .flags = FLAGS },
 +    { NULL },
 +};
 +#undef FLAGS
 +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 +static const AVOption abuffersink_options[] = {
 +    { "sample_fmts",     "set the supported sample formats",  OFFSET(sample_fmts),     AV_OPT_TYPE_BINARY, .flags = FLAGS },
 +    { "sample_rates",    "set the supported sample rates",    OFFSET(sample_rates),    AV_OPT_TYPE_BINARY, .flags = FLAGS },
 +    { "channel_layouts", "set the supported channel layouts", OFFSET(channel_layouts), AV_OPT_TYPE_BINARY, .flags = FLAGS },
 +    { "channel_counts",  "set the supported channel counts",  OFFSET(channel_counts),  AV_OPT_TYPE_BINARY, .flags = FLAGS },
 +    { "all_channel_counts", "accept all channel counts", OFFSET(all_channel_counts), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, FLAGS },
 +    { NULL },
 +};
 +#undef FLAGS
 +
 +AVFILTER_DEFINE_CLASS(buffersink);
 +AVFILTER_DEFINE_CLASS(abuffersink);
 +
 +#if FF_API_AVFILTERBUFFER
 +
 +#define ffbuffersink_options buffersink_options
 +#define ffabuffersink_options abuffersink_options
 +AVFILTER_DEFINE_CLASS(ffbuffersink);
 +AVFILTER_DEFINE_CLASS(ffabuffersink);
 +
 +static const AVFilterPad ffbuffersink_inputs[] = {
 +    {
 +        .name      = "default",
 +        .type      = AVMEDIA_TYPE_VIDEO,
 +        .filter_frame = filter_frame,
 +    },
 +    { NULL },
 +};
 +
 +AVFilter avfilter_vsink_ffbuffersink = {
 +    .name      = "ffbuffersink",
 +    .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
 +    .priv_size = sizeof(BufferSinkContext),
 +    .priv_class = &ffbuffersink_class,
 +    .init_opaque = vsink_init,
 +    .uninit    = uninit,
 +
 +    .query_formats = vsink_query_formats,
 +    .inputs        = ffbuffersink_inputs,
 +    .outputs       = NULL,
 +};
 +
 +static const AVFilterPad ffabuffersink_inputs[] = {
 +    {
 +        .name           = "default",
 +        .type           = AVMEDIA_TYPE_AUDIO,
 +        .filter_frame   = filter_frame,
 +    },
 +    { NULL },
 +};
 +
 +AVFilter avfilter_asink_ffabuffersink = {
 +    .name      = "ffabuffersink",
 +    .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them available to the end of the filter graph."),
 +    .init_opaque = asink_init,
 +    .uninit    = uninit,
 +    .priv_size = sizeof(BufferSinkContext),
 +    .priv_class = &ffabuffersink_class,
 +    .query_formats = asink_query_formats,
 +    .inputs        = ffabuffersink_inputs,
 +    .outputs       = NULL,
 +};
 +#endif /* FF_API_AVFILTERBUFFER */
 +
  static const AVFilterPad avfilter_vsink_buffer_inputs[] = {
      {
          .name         = "default",
@@@ -283,11 -237,7 +285,12 @@@ fail
  
      return ret;
  }
+ FF_ENABLE_DEPRECATION_WARNINGS
 +
 +int av_buffersrc_buffer(AVFilterContext *ctx, AVFilterBufferRef *buf)
 +{
 +    return av_buffersrc_add_ref(ctx, buf, 0);
 +}
  #endif
  
  static av_cold int init_video(AVFilterContext *ctx)
   * internal API functions
   */
  
+ #include "libavutil/internal.h"
  #include "avfilter.h"
 +#include "avfiltergraph.h"
 +#include "formats.h"
  #include "thread.h"
  #include "version.h"
 +#include "video.h"
 +
 +#define POOL_SIZE 32
 +typedef struct AVFilterPool {
 +    AVFilterBufferRef *pic[POOL_SIZE];
 +    int count;
 +    int refcount;
 +    int draining;
 +} AVFilterPool;
 +
 +typedef struct AVFilterCommand {
 +    double time;                ///< time expressed in seconds
 +    char *command;              ///< command
 +    char *arg;                  ///< optional argument for the command
 +    int flags;
 +    struct AVFilterCommand *next;
 +} AVFilterCommand;
 +
 +/**
 + * Update the position of a link in the age heap.
 + */
 +void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link);
  
  #if !FF_API_AVFILTERPAD_PUBLIC
  /**
Simple merge
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
  #include "libavutil/bswap.h"
 +#include "libavutil/opt.h"
  #include "libavutil/dict.h"
+ #include "libavutil/internal.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/mathematics.h"
  #include "avformat.h"
@@@ -1268,12 -1166,16 +1269,16 @@@ resync
          if (CONFIG_DV_DEMUXER && avi->dv_demux) {
              AVBufferRef *avbuf = pkt->buf;
  #if FF_API_DESTRUCT_PACKET
+ FF_DISABLE_DEPRECATION_WARNINGS
              dstr = pkt->destruct;
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
              size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
 -                                            pkt->data, pkt->size);
 +                                            pkt->data, pkt->size, pkt->pos);
  #if FF_API_DESTRUCT_PACKET
+ FF_DISABLE_DEPRECATION_WARNINGS
              pkt->destruct = dstr;
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
              pkt->buf    = avbuf;
              pkt->flags |= AV_PKT_FLAG_KEY;
@@@ -577,54 -449,27 +578,56 @@@ int ff_interleave_add_packet(AVFormatCo
                                int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
  {
      AVPacketList **next_point, *this_pktl;
 +    AVStream *st   = s->streams[pkt->stream_index];
 +    int chunked    = s->max_chunk_size || s->max_chunk_duration;
  
      this_pktl      = av_mallocz(sizeof(AVPacketList));
 +    if (!this_pktl)
 +        return AVERROR(ENOMEM);
      this_pktl->pkt = *pkt;
  #if FF_API_DESTRUCT_PACKET
+ FF_DISABLE_DEPRECATION_WARNINGS
      pkt->destruct  = NULL;           // do not free original but only the copy
+ FF_ENABLE_DEPRECATION_WARNINGS
  #endif
      pkt->buf       = NULL;
 -    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
 +    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-allocated memory
 +    av_copy_packet_side_data(&this_pktl->pkt, &this_pktl->pkt); // copy side data
  
      if (s->streams[pkt->stream_index]->last_in_packet_buffer) {
 -        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
 -    } else
 +        next_point = &(st->last_in_packet_buffer->next);
 +    } else {
          next_point = &s->packet_buffer;
 +    }
  
 +    if (chunked) {
 +        uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
 +        st->interleaver_chunk_size     += pkt->size;
 +        st->interleaver_chunk_duration += pkt->duration;
 +        if (   (s->max_chunk_size && st->interleaver_chunk_size > s->max_chunk_size)
 +            || (max && st->interleaver_chunk_duration           > max)) {
 +            st->interleaver_chunk_size      = 0;
 +            this_pktl->pkt.flags |= CHUNK_START;
 +            if (max && st->interleaver_chunk_duration > max) {
 +                int64_t syncoffset = (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
 +                int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
 +
 +                st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
 +            } else
 +                st->interleaver_chunk_duration = 0;
 +        }
 +    }
      if (*next_point) {
 +        if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
 +            goto next_non_null;
 +
          if (compare(s, &s->packet_buffer_end->pkt, pkt)) {
 -            while (!compare(s, &(*next_point)->pkt, pkt))
 +            while (   *next_point
 +                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
 +                       || !compare(s, &(*next_point)->pkt, pkt)))
                  next_point = &(*next_point)->next;
 -            goto next_non_null;
 +            if (*next_point)
 +                goto next_non_null;
          } else {
              next_point = &(s->packet_buffer_end->next);
          }
Simple merge
Simple merge
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
  #include "libavutil/channel_layout.h"
+ #include "libavutil/internal.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/dict.h"
  #include "avformat.h"
  #include "avio_internal.h"
  #include "internal.h"
  #include "libavcodec/internal.h"
 +#include "libavcodec/raw.h"
  #include "libavcodec/bytestream.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/opt.h"
  #include "libavutil/dict.h"
+ #include "libavutil/internal.h"
  #include "libavutil/pixdesc.h"
  #include "metadata.h"
  #include "id3v2.h"
@@@ -26,9 -25,8 +26,9 @@@
  #include "common.h"
  #include "pixfmt.h"
  #include "pixdesc.h"
+ #include "internal.h"
  #include "intreadwrite.h"
 +#include "avstring.h"
  
  void av_read_image_line(uint16_t *dst,
                          const uint8_t *data[4], const int linesize[4],