vp9: add superframe merging bitstream filter.

Fixes ticket 4313.

ffmpeg.c

@@ -712,6 +712,7 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
      if(
         (avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&
         pkt->dts != AV_NOPTS_VALUE &&
+        !(avctx->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
         ost->last_mux_dts != AV_NOPTS_VALUE) {
       int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
       if (pkt->dts < max) {

libavcodec/Makefile

@@ -918,6 +918,7 @@ OBJS-$(CONFIG_MP3_HEADER_DECOMPRESS_BSF)  += mp3_header_decompress_bsf.o \
 OBJS-$(CONFIG_NOISE_BSF)                  += noise_bsf.o
 OBJS-$(CONFIG_REMOVE_EXTRADATA_BSF)       += remove_extradata_bsf.o
 OBJS-$(CONFIG_TEXT2MOVSUB_BSF)            += movsub_bsf.o
+OBJS-$(CONFIG_VP9_SUPERFRAME_BSF)         += vp9_superframe_bsf.o
 
 # thread libraries
 OBJS-$(HAVE_LIBC_MSVCRT)               += file_open.o

libavcodec/allcodecs.c

@@ -668,4 +668,5 @@ void avcodec_register_all(void)
     REGISTER_BSF(NOISE,                 noise);
     REGISTER_BSF(REMOVE_EXTRADATA,      remove_extradata);
     REGISTER_BSF(TEXT2MOVSUB,           text2movsub);
+    REGISTER_BSF(VP9_SUPERFRAME,        vp9_superframe);
 }

libavcodec/vp9_superframe_bsf.c

@@ -0,0 +1,189 @@
+/*
+ * Vp9 invisible (alt-ref) frame to superframe merge bitstream filter
+ * Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/avassert.h"
+#include "avcodec.h"
+#include "get_bits.h"
+
+#define MAX_CACHE 8
+typedef struct VP9BSFContext {
+    int n_cache;
+    struct CachedBuf {
+        uint8_t *data;
+        int size;
+    } cache[MAX_CACHE];
+} VP9BSFContext;
+
+static void stats(const struct CachedBuf *in, int n_in,
+                  unsigned *_max, unsigned *_sum)
+{
+    int n;
+    unsigned max = 0, sum = 0;
+
+    for (n = 0; n < n_in; n++) {
+        unsigned sz = in[n].size;
+
+        if (sz > max)
+            max = sz;
+        sum += sz;
+    }
+
+    *_max = max;
+    *_sum = sum;
+}
+
+static int merge_superframe(const struct CachedBuf *in, int n_in,
+                            uint8_t **poutbuf, int *poutbuf_size)
+{
+    unsigned max, sum, mag, marker, n, sz;
+    uint8_t *ptr;
+
+    stats(in, n_in, &max, &sum);
+    mag = av_log2(max) >> 3;
+    marker = 0xC0 + (mag << 3) + (n_in - 1);
+    sz = *poutbuf_size = sum + 2 + (mag + 1) * n_in;
+    ptr = *poutbuf = av_malloc(sz);
+    if (!ptr)
+        return AVERROR(ENOMEM);
+
+    for (n = 0; n < n_in; n++) {
+        memcpy(ptr, in[n].data, in[n].size);
+        ptr += in[n].size;
+    }
+
+#define wloop(mag, wr) \
+    for (n = 0; n < n_in; n++) { \
+        wr; \
+        ptr += mag + 1; \
+    }
+
+    // write superframe with marker 110[mag:2][nframes:3]
+    *ptr++ = marker;
+    switch (mag) {
+    case 0:
+        wloop(mag, *ptr = in[n].size);
+        break;
+    case 1:
+        wloop(mag, AV_WB16(ptr, in[n].size));
+        break;
+    case 2:
+        wloop(mag, AV_WB24(ptr, in[n].size));
+        break;
+    case 3:
+        wloop(mag, AV_WB32(ptr, in[n].size));
+        break;
+    }
+    *ptr++ = marker;
+    av_assert0(ptr == &(*poutbuf)[*poutbuf_size]);
+
+    return 0;
+}
+
+static int vp9_superframe_filter(AVBitStreamFilterContext *bsfc,
+                                 AVCodecContext *avctx, const char *args,
+                                 uint8_t  **poutbuf, int *poutbuf_size,
+                                 const uint8_t *buf, int      buf_size,
+                                 int keyframe)
+{
+    GetBitContext gb;
+    VP9BSFContext *ctx = bsfc->priv_data;
+    int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
+
+    marker = buf[buf_size - 1];
+    if ((marker & 0xe0) == 0xc0) {
+        int nbytes = 1 + ((marker >> 3) & 0x3);
+        int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
+
+        uses_superframe_syntax = buf_size >= idx_sz && buf[buf_size - idx_sz] == marker;
+    }
+
+    if ((res = init_get_bits8(&gb, buf, buf_size)) < 0)
+        return res;
+
+    get_bits(&gb, 2); // frame marker
+    profile  = get_bits1(&gb);
+    profile |= get_bits1(&gb) << 1;
+    if (profile == 3) profile += get_bits1(&gb);
+
+    if (get_bits1(&gb)) {
+        invisible = 0;
+    } else {
+        get_bits1(&gb); // keyframe
+        invisible = !get_bits1(&gb);
+    }
+
+    if (uses_superframe_syntax && ctx->n_cache > 0) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Mixing of superframe syntax and naked VP9 frames not supported");
+        return AVERROR_INVALIDDATA;
+    } else if ((!invisible || uses_superframe_syntax) && !ctx->n_cache) {
+        // passthrough
+        *poutbuf = (uint8_t *) buf;
+        *poutbuf_size = buf_size;
+        return 0;
+    } else if (ctx->n_cache + 1 >= MAX_CACHE) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Too many invisible frames");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ctx->cache[ctx->n_cache].size = buf_size;
+    if (invisible && !uses_superframe_syntax) {
+        ctx->cache[ctx->n_cache].data = av_malloc(buf_size);
+        if (!ctx->cache[ctx->n_cache].data)
+            return AVERROR(ENOMEM);
+        memcpy(ctx->cache[ctx->n_cache++].data, buf, buf_size);
+        *poutbuf = NULL;
+        *poutbuf_size = 0;
+        return 0;
+    }
+    av_assert0(ctx->n_cache > 0);
+
+    ctx->cache[ctx->n_cache].data = (uint8_t *) buf;
+
+    // build superframe
+    if ((res = merge_superframe(ctx->cache, ctx->n_cache + 1,
+                                poutbuf, poutbuf_size)) < 0)
+        return res;
+
+    for (n = 0; n < ctx->n_cache; n++)
+        av_freep(&ctx->cache[n].data);
+    ctx->n_cache = 0;
+
+    return 0;
+}
+
+static void vp9_superframe_close(AVBitStreamFilterContext *bsfc)
+{
+    VP9BSFContext *ctx = bsfc->priv_data;
+    int n;
+
+    // free cached data
+    for (n = 0; n < ctx->n_cache; n++)
+        av_freep(&ctx->cache[n].data);
+}
+
+AVBitStreamFilter ff_vp9_superframe_bsf = {
+    .name           = "vp9_superframe",
+    .priv_data_size = sizeof(VP9BSFContext),
+    .filter         = vp9_superframe_filter,
+    .close          = vp9_superframe_close,
+};

libavformat/ivfenc.c

@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "avformat.h"
+#include "internal.h"
 #include "libavutil/intreadwrite.h"
 
 typedef struct IVFEncContext {
@@ -85,6 +86,17 @@ static int ivf_write_trailer(AVFormatContext *s)
     return 0;
 }
 
+static int ivf_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
+{
+    int ret = 1;
+    AVStream *st = s->streams[pkt->stream_index];
+
+    if (st->codec->codec_id == AV_CODEC_ID_VP9)
+        ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
+
+    return ret;
+}
+
 AVOutputFormat ff_ivf_muxer = {
     .priv_data_size = sizeof(IVFEncContext),
     .name         = "ivf",
@@ -95,4 +107,5 @@ AVOutputFormat ff_ivf_muxer = {
     .write_header = ivf_write_header,
     .write_packet = ivf_write_packet,
     .write_trailer = ivf_write_trailer,
+    .check_bitstream = ivf_check_bitstream,
 };

libavformat/matroskaenc.c

@@ -2118,9 +2118,12 @@ static int mkv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
     int ret = 1;
     AVStream *st = s->streams[pkt->stream_index];
 
-    if (st->codec->codec_id == AV_CODEC_ID_AAC)
+    if (st->codec->codec_id == AV_CODEC_ID_AAC) {
         if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
             ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
+    } else if (st->codec->codec_id == AV_CODEC_ID_VP9) {
+        ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
+    }
 
     return ret;
 }