aarch64: vp9dsp: Fix vertical alignment in the init file

[ffmpeg] / libavcodec / bitstream_filter.c

diff --git a/libavcodec/bitstream_filter.c b/libavcodec/bitstream_filter.c
index b2d61da159267aa96fa54cf590a5d7787a74f99e..ab608a99cdb3ce9b6d34028c79ca02e82b783565 100644 (file)
--- a/libavcodec/bitstream_filter.c
+++ b/libavcodec/bitstream_filter.c
@@ -21,48 +21,143 @@
 #include <string.h>
 
 #include "avcodec.h"
+
+#include "libavutil/internal.h"
 #include "libavutil/mem.h"
 
-static AVBitStreamFilter *first_bitstream_filter= NULL;
+#if FF_API_OLD_BSF
+FF_DISABLE_DEPRECATION_WARNINGS
+
+AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f)
+{
+    const AVBitStreamFilter *filter = NULL;
+    void *opaque = NULL;
 
-AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f){
-    if(f) return f->next;
-    else  return first_bitstream_filter;
+    while (filter != f)
+        filter = av_bsf_next(&opaque);
+
+    return av_bsf_next(&opaque);
 }
 
-void av_register_bitstream_filter(AVBitStreamFilter *bsf){
-    bsf->next = first_bitstream_filter;
-    first_bitstream_filter= bsf;
+void av_register_bitstream_filter(AVBitStreamFilter *bsf)
+{
 }
 
-AVBitStreamFilterContext *av_bitstream_filter_init(const char *name){
-    AVBitStreamFilter *bsf= first_bitstream_filter;
+typedef struct BSFCompatContext {
+    AVBSFContext *ctx;
+} BSFCompatContext;
 
-    while(bsf){
-        if(!strcmp(name, bsf->name)){
-            AVBitStreamFilterContext *bsfc= av_mallocz(sizeof(AVBitStreamFilterContext));
-            bsfc->filter= bsf;
-            bsfc->priv_data = bsf->priv_data_size ? av_mallocz(bsf->priv_data_size) : NULL;
-            return bsfc;
-        }
-        bsf= bsf->next;
-    }
+AVBitStreamFilterContext *av_bitstream_filter_init(const char *name)
+{
+    AVBitStreamFilterContext *ctx = NULL;
+    BSFCompatContext         *priv = NULL;
+    const AVBitStreamFilter *bsf;
+
+    bsf = av_bsf_get_by_name(name);
+    if (!bsf)
+        return NULL;
+
+    ctx = av_mallocz(sizeof(*ctx));
+    if (!ctx)
+        return NULL;
+
+    priv = av_mallocz(sizeof(*priv));
+    if (!priv)
+        goto fail;
+
+
+    ctx->filter    = bsf;
+    ctx->priv_data = priv;
+
+    return ctx;
+
+fail:
+    if (priv)
+        av_bsf_free(&priv->ctx);
+    av_freep(&priv);
+    av_freep(&ctx);
     return NULL;
 }
 
-void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc){
-    if(bsfc->filter->close)
-        bsfc->filter->close(bsfc);
+void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc)
+{
+    BSFCompatContext *priv = bsfc->priv_data;
+
+    av_bsf_free(&priv->ctx);
     av_freep(&bsfc->priv_data);
-    av_parser_close(bsfc->parser);
     av_free(bsfc);
 }
 
 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
                                AVCodecContext *avctx, const char *args,
-                     uint8_t **poutbuf, int *poutbuf_size,
-                     const uint8_t *buf, int buf_size, int keyframe){
-    *poutbuf= (uint8_t *) buf;
-    *poutbuf_size= buf_size;
-    return bsfc->filter->filter(bsfc, avctx, args, poutbuf, poutbuf_size, buf, buf_size, keyframe);
+                               uint8_t **poutbuf, int *poutbuf_size,
+                               const uint8_t *buf, int buf_size, int keyframe)
+{
+    BSFCompatContext *priv = bsfc->priv_data;
+    AVPacket pkt = { 0 };
+    int ret;
+
+    if (!priv->ctx) {
+        ret = av_bsf_alloc(bsfc->filter, &priv->ctx);
+        if (ret < 0)
+            return ret;
+
+        ret = avcodec_parameters_from_context(priv->ctx->par_in, avctx);
+        if (ret < 0)
+            return ret;
+
+        priv->ctx->time_base_in = avctx->time_base;
+
+        ret = av_bsf_init(priv->ctx);
+        if (ret < 0)
+            return ret;
+
+        if (priv->ctx->par_out->extradata_size) {
+            av_freep(&avctx->extradata);
+            avctx->extradata_size = 0;
+            avctx->extradata = av_mallocz(priv->ctx->par_out->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!avctx->extradata)
+                return AVERROR(ENOMEM);
+            memcpy(avctx->extradata, priv->ctx->par_out->extradata,
+                   priv->ctx->par_out->extradata_size);
+            avctx->extradata_size = priv->ctx->par_out->extradata_size;
+        }
+    }
+
+    pkt.data = buf;
+    pkt.size = buf_size;
+
+    ret = av_bsf_send_packet(priv->ctx, &pkt);
+    if (ret < 0)
+        return ret;
+
+    *poutbuf      = NULL;
+    *poutbuf_size = 0;
+
+    ret = av_bsf_receive_packet(priv->ctx, &pkt);
+    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+        return 0;
+    else if (ret < 0)
+        return ret;
+
+    *poutbuf = av_malloc(pkt.size + AV_INPUT_BUFFER_PADDING_SIZE);
+    if (!*poutbuf) {
+        av_packet_unref(&pkt);
+        return AVERROR(ENOMEM);
+    }
+
+    *poutbuf_size = pkt.size;
+    memcpy(*poutbuf, pkt.data, pkt.size);
+
+    av_packet_unref(&pkt);
+
+    /* drain all the remaining packets we cannot return */
+    while (ret >= 0) {
+        ret = av_bsf_receive_packet(priv->ctx, &pkt);
+        av_packet_unref(&pkt);
+    }
+
+    return 1;
 }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif