vp9: add superframe merging bitstream filter.
[libav.git] / 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_WB16(ptr, in[n].size));
86 break;
87 case 2:
88 wloop(mag, AV_WB24(ptr, in[n].size));
89 break;
90 case 3:
91 wloop(mag, AV_WB32(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 };