git.sesse.net Git - ffmpeg/blob - libavcodec/vp9_superframe_bsf.c

   1 /*
   2  * Vp9 invisible (alt-ref) frame to superframe merge bitstream filter
   3  * Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avassert.h"
  23 #include "avcodec.h"
  24 #include "get_bits.h"
  25
  26 #define MAX_CACHE 8
  27 typedef struct VP9BSFContext {
  28     int n_cache;
  29     struct CachedBuf {
  30         uint8_t *data;
  31         int size;
  32     } cache[MAX_CACHE];
  33 } VP9BSFContext;
  34
  35 static void stats(const struct CachedBuf *in, int n_in,
  36                   unsigned *_max, unsigned *_sum)
  37 {
  38     int n;
  39     unsigned max = 0, sum = 0;
  40
  41     for (n = 0; n < n_in; n++) {
  42         unsigned sz = in[n].size;
  43
  44         if (sz > max)
  45             max = sz;
  46         sum += sz;
  47     }
  48
  49     *_max = max;
  50     *_sum = sum;
  51 }
  52
  53 static int merge_superframe(const struct CachedBuf *in, int n_in,
  54                             uint8_t **poutbuf, int *poutbuf_size)
  55 {
  56     unsigned max, sum, mag, marker, n, sz;
  57     uint8_t *ptr;
  58
  59     stats(in, n_in, &max, &sum);
  60     mag = av_log2(max) >> 3;
  61     marker = 0xC0 + (mag << 3) + (n_in - 1);
  62     sz = *poutbuf_size = sum + 2 + (mag + 1) * n_in;
  63     ptr = *poutbuf = av_malloc(sz);
  64     if (!ptr)
  65         return AVERROR(ENOMEM);
  66
  67     for (n = 0; n < n_in; n++) {
  68         memcpy(ptr, in[n].data, in[n].size);
  69         ptr += in[n].size;
  70     }
  71
  72 #define wloop(mag, wr) \
  73     for (n = 0; n < n_in; n++) { \
  74         wr; \
  75         ptr += mag + 1; \
  76     }
  77
  78     // write superframe with marker 110[mag:2][nframes:3]
  79     *ptr++ = marker;
  80     switch (mag) {
  81     case 0:
  82         wloop(mag, *ptr = in[n].size);
  83         break;
  84     case 1:
  85         wloop(mag, AV_WL16(ptr, in[n].size));
  86         break;
  87     case 2:
  88         wloop(mag, AV_WL24(ptr, in[n].size));
  89         break;
  90     case 3:
  91         wloop(mag, AV_WL32(ptr, in[n].size));
  92         break;
  93     }
  94     *ptr++ = marker;
  95     av_assert0(ptr == &(*poutbuf)[*poutbuf_size]);
  96
  97     return 0;
  98 }
  99
 100 static int vp9_superframe_filter(AVBitStreamFilterContext *bsfc,
 101                                  AVCodecContext *avctx, const char *args,
 102                                  uint8_t  **poutbuf, int *poutbuf_size,
 103                                  const uint8_t *buf, int      buf_size,
 104                                  int keyframe)
 105 {
 106     GetBitContext gb;
 107     VP9BSFContext *ctx = bsfc->priv_data;
 108     int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
 109
 110     marker = buf[buf_size - 1];
 111     if ((marker & 0xe0) == 0xc0) {
 112         int nbytes = 1 + ((marker >> 3) & 0x3);
 113         int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
 114
 115         uses_superframe_syntax = buf_size >= idx_sz && buf[buf_size - idx_sz] == marker;
 116     }
 117
 118     if ((res = init_get_bits8(&gb, buf, buf_size)) < 0)
 119         return res;
 120
 121     get_bits(&gb, 2); // frame marker
 122     profile  = get_bits1(&gb);
 123     profile |= get_bits1(&gb) << 1;
 124     if (profile == 3) profile += get_bits1(&gb);
 125
 126     if (get_bits1(&gb)) {
 127         invisible = 0;
 128     } else {
 129         get_bits1(&gb); // keyframe
 130         invisible = !get_bits1(&gb);
 131     }
 132
 133     if (uses_superframe_syntax && ctx->n_cache > 0) {
 134         av_log(avctx, AV_LOG_ERROR,
 135                "Mixing of superframe syntax and naked VP9 frames not supported");
 136         return AVERROR_INVALIDDATA;
 137     } else if ((!invisible || uses_superframe_syntax) && !ctx->n_cache) {
 138         // passthrough
 139         *poutbuf = (uint8_t *) buf;
 140         *poutbuf_size = buf_size;
 141         return 0;
 142     } else if (ctx->n_cache + 1 >= MAX_CACHE) {
 143         av_log(avctx, AV_LOG_ERROR,
 144                "Too many invisible frames");
 145         return AVERROR_INVALIDDATA;
 146     }
 147
 148     ctx->cache[ctx->n_cache].size = buf_size;
 149     if (invisible && !uses_superframe_syntax) {
 150         ctx->cache[ctx->n_cache].data = av_malloc(buf_size);
 151         if (!ctx->cache[ctx->n_cache].data)
 152             return AVERROR(ENOMEM);
 153         memcpy(ctx->cache[ctx->n_cache++].data, buf, buf_size);
 154         *poutbuf = NULL;
 155         *poutbuf_size = 0;
 156         return 0;
 157     }
 158     av_assert0(ctx->n_cache > 0);
 159
 160     ctx->cache[ctx->n_cache].data = (uint8_t *) buf;
 161
 162     // build superframe
 163     if ((res = merge_superframe(ctx->cache, ctx->n_cache + 1,
 164                                 poutbuf, poutbuf_size)) < 0)
 165         return res;
 166
 167     for (n = 0; n < ctx->n_cache; n++)
 168         av_freep(&ctx->cache[n].data);
 169     ctx->n_cache = 0;
 170
 171     return 0;
 172 }
 173
 174 static void vp9_superframe_close(AVBitStreamFilterContext *bsfc)
 175 {
 176     VP9BSFContext *ctx = bsfc->priv_data;
 177     int n;
 178
 179     // free cached data
 180     for (n = 0; n < ctx->n_cache; n++)
 181         av_freep(&ctx->cache[n].data);
 182 }
 183
 184 AVBitStreamFilter ff_vp9_superframe_bsf = {
 185     .name           = "vp9_superframe",
 186     .priv_data_size = sizeof(VP9BSFContext),
 187     .filter         = vp9_superframe_filter,
 188     .close          = vp9_superframe_close,
 189 };