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 "bsf.h"
  25 #include "get_bits.h"
  26
  27 #define MAX_CACHE 8
  28 typedef struct VP9BSFContext {
  29     int n_cache;
  30     AVPacket *cache[MAX_CACHE];
  31 } VP9BSFContext;
  32
  33 static void stats(AVPacket * const *in, int n_in,
  34                   unsigned *_max, unsigned *_sum)
  35 {
  36     int n;
  37     unsigned max = 0, sum = 0;
  38
  39     for (n = 0; n < n_in; n++) {
  40         unsigned sz = in[n]->size;
  41
  42         if (sz > max)
  43             max = sz;
  44         sum += sz;
  45     }
  46
  47     *_max = max;
  48     *_sum = sum;
  49 }
  50
  51 static int merge_superframe(AVPacket * const *in, int n_in, AVPacket *out)
  52 {
  53     unsigned max, sum, mag, marker, n, sz;
  54     uint8_t *ptr;
  55     int res;
  56
  57     stats(in, n_in, &max, &sum);
  58     mag = av_log2(max) >> 3;
  59     marker = 0xC0 + (mag << 3) + (n_in - 1);
  60     sz = sum + 2 + (mag + 1) * n_in;
  61     res = av_new_packet(out, sz);
  62     if (res < 0)
  63         return res;
  64     ptr = out->data;
  65     for (n = 0; n < n_in; n++) {
  66         memcpy(ptr, in[n]->data, in[n]->size);
  67         ptr += in[n]->size;
  68     }
  69
  70 #define wloop(mag, wr) \
  71     do { \
  72         for (n = 0; n < n_in; n++) { \
  73             wr; \
  74             ptr += mag + 1; \
  75         } \
  76     } while (0)
  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 == &out->data[out->size]);
  96
  97     return 0;
  98 }
  99
 100 static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *pkt)
 101 {
 102     GetBitContext gb;
 103     VP9BSFContext *s = ctx->priv_data;
 104     int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
 105
 106     res = ff_bsf_get_packet_ref(ctx, pkt);
 107     if (res < 0)
 108         return res;
 109
 110     marker = pkt->data[pkt->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 = pkt->size >= idx_sz && pkt->data[pkt->size - idx_sz] == marker;
 116     }
 117
 118     if ((res = init_get_bits8(&gb, pkt->data, pkt->size)) < 0)
 119         goto done;
 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 && s->n_cache > 0) {
 134         av_log(ctx, AV_LOG_ERROR,
 135                "Mixing of superframe syntax and naked VP9 frames not supported\n");
 136         res = AVERROR(ENOSYS);
 137         goto done;
 138     } else if ((!invisible || uses_superframe_syntax) && !s->n_cache) {
 139         // passthrough
 140         return 0;
 141     } else if (s->n_cache + 1 >= MAX_CACHE) {
 142         av_log(ctx, AV_LOG_ERROR,
 143                "Too many invisible frames\n");
 144         res = AVERROR_INVALIDDATA;
 145         goto done;
 146     }
 147
 148     av_packet_move_ref(s->cache[s->n_cache++], pkt);
 149
 150     if (invisible) {
 151         return AVERROR(EAGAIN);
 152     }
 153     av_assert0(s->n_cache > 0);
 154
 155     // build superframe
 156     if ((res = merge_superframe(s->cache, s->n_cache, pkt)) < 0)
 157         goto done;
 158
 159     res = av_packet_copy_props(pkt, s->cache[s->n_cache - 1]);
 160     if (res < 0)
 161         goto done;
 162
 163     for (n = 0; n < s->n_cache; n++)
 164         av_packet_unref(s->cache[n]);
 165     s->n_cache = 0;
 166
 167 done:
 168     if (res < 0)
 169         av_packet_unref(pkt);
 170     return res;
 171 }
 172
 173 static int vp9_superframe_init(AVBSFContext *ctx)
 174 {
 175     VP9BSFContext *s = ctx->priv_data;
 176     int n;
 177
 178     // alloc cache packets
 179     for (n = 0; n < MAX_CACHE; n++) {
 180         s->cache[n] = av_packet_alloc();
 181         if (!s->cache[n])
 182             return AVERROR(ENOMEM);
 183     }
 184
 185     return 0;
 186 }
 187
 188 static void vp9_superframe_flush(AVBSFContext *ctx)
 189 {
 190     VP9BSFContext *s = ctx->priv_data;
 191     int n;
 192
 193     // unref cached data
 194     for (n = 0; n < s->n_cache; n++)
 195         av_packet_unref(s->cache[n]);
 196     s->n_cache = 0;
 197 }
 198
 199 static void vp9_superframe_close(AVBSFContext *ctx)
 200 {
 201     VP9BSFContext *s = ctx->priv_data;
 202     int n;
 203
 204     // free cached data
 205     for (n = 0; n < MAX_CACHE; n++)
 206         av_packet_free(&s->cache[n]);
 207 }
 208
 209 static const enum AVCodecID codec_ids[] = {
 210     AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
 211 };
 212
 213 const AVBitStreamFilter ff_vp9_superframe_bsf = {
 214     .name           = "vp9_superframe",
 215     .priv_data_size = sizeof(VP9BSFContext),
 216     .filter         = vp9_superframe_filter,
 217     .init           = vp9_superframe_init,
 218     .flush          = vp9_superframe_flush,
 219     .close          = vp9_superframe_close,
 220     .codec_ids      = codec_ids,
 221 };