vp9: Add bsf to fix reordering in raw streams
[libav.git] / libavcodec / vp9_raw_reorder_bsf.c
1 /*
2 * This file is part of Libav.
3 *
4 * Libav is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * Libav is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with Libav; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "libavutil/avassert.h"
20 #include "libavutil/intmath.h"
21 #include "libavutil/log.h"
22 #include "libavutil/mem.h"
23 #include "libavutil/opt.h"
24
25 #include "bitstream.h"
26 #include "bsf.h"
27 #include "put_bits.h"
28
29 #define FRAME_SLOTS 8
30
31 typedef struct VP9RawReorderFrame {
32 AVPacket *packet;
33 int needs_output;
34 int needs_display;
35
36 int64_t pts;
37 int64_t sequence;
38 unsigned int slots;
39
40 unsigned int profile;
41
42 unsigned int show_existing_frame;
43 unsigned int frame_to_show;
44
45 unsigned int frame_type;
46 unsigned int show_frame;
47 unsigned int refresh_frame_flags;
48 } VP9RawReorderFrame;
49
50 typedef struct VP9RawReorderContext {
51 int64_t sequence;
52 VP9RawReorderFrame *slot[FRAME_SLOTS];
53 VP9RawReorderFrame *next_frame;
54 } VP9RawReorderContext;
55
56 static void vp9_raw_reorder_frame_free(VP9RawReorderFrame **frame)
57 {
58 if (*frame)
59 av_packet_free(&(*frame)->packet);
60 av_freep(frame);
61 }
62
63 static void vp9_raw_reorder_clear_slot(VP9RawReorderContext *ctx, int s)
64 {
65 if (ctx->slot[s]) {
66 ctx->slot[s]->slots &= ~(1 << s);
67 if (ctx->slot[s]->slots == 0)
68 vp9_raw_reorder_frame_free(&ctx->slot[s]);
69 else
70 ctx->slot[s] = NULL;
71 }
72 }
73
74 static int vp9_raw_reorder_frame_parse(AVBSFContext *bsf, VP9RawReorderFrame *frame)
75 {
76 BitstreamContext bc;
77 int err;
78
79 unsigned int frame_marker;
80 unsigned int profile_low_bit, profile_high_bit, reserved_zero;
81 unsigned int error_resilient_mode;
82 unsigned int frame_sync_code;
83
84 err = bitstream_init8(&bc, frame->packet->data, frame->packet->size);
85 if (err)
86 return err;
87
88 frame_marker = bitstream_read(&bc, 2);
89 if (frame_marker != 2) {
90 av_log(bsf, AV_LOG_ERROR, "Invalid frame marker: %u.\n",
91 frame_marker);
92 return AVERROR_INVALIDDATA;
93 }
94
95 profile_low_bit = bitstream_read_bit(&bc);
96 profile_high_bit = bitstream_read_bit(&bc);
97 frame->profile = (profile_high_bit << 1) | profile_low_bit;
98 if (frame->profile == 3) {
99 reserved_zero = bitstream_read_bit(&bc);
100 if (reserved_zero != 0) {
101 av_log(bsf, AV_LOG_ERROR, "Profile reserved_zero bit set: "
102 "unsupported profile or invalid bitstream.\n");
103 return AVERROR_INVALIDDATA;
104 }
105 }
106
107 frame->show_existing_frame = bitstream_read_bit(&bc);
108 if (frame->show_existing_frame) {
109 frame->frame_to_show = bitstream_read(&bc, 3);
110 return 0;
111 }
112
113 frame->frame_type = bitstream_read_bit(&bc);
114 frame->show_frame = bitstream_read_bit(&bc);
115 error_resilient_mode = bitstream_read_bit(&bc);
116
117 if (frame->frame_type == 0) {
118 frame_sync_code = bitstream_read(&bc, 24);
119 if (frame_sync_code != 0x498342) {
120 av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: %06x.\n",
121 frame_sync_code);
122 return AVERROR_INVALIDDATA;
123 }
124 frame->refresh_frame_flags = 0xff;
125 } else {
126 unsigned int intra_only;
127
128 if (frame->show_frame == 0)
129 intra_only = bitstream_read_bit(&bc);
130 else
131 intra_only = 0;
132 if (error_resilient_mode == 0) {
133 // reset_frame_context
134 bitstream_skip(&bc, 2);
135 }
136 if (intra_only) {
137 frame_sync_code = bitstream_read(&bc, 24);
138 if (frame_sync_code != 0x498342) {
139 av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: "
140 "%06x.\n", frame_sync_code);
141 return AVERROR_INVALIDDATA;
142 }
143 if (frame->profile > 0) {
144 unsigned int color_space;
145 if (frame->profile >= 2) {
146 // ten_or_twelve_bit
147 bitstream_skip(&bc, 1);
148 }
149 color_space = bitstream_read(&bc, 3);
150 if (color_space != 7 /* CS_RGB */) {
151 // color_range
152 bitstream_skip(&bc, 1);
153 if (frame->profile == 1 || frame->profile == 3) {
154 // subsampling
155 bitstream_skip(&bc, 3);
156 }
157 } else {
158 if (frame->profile == 1 || frame->profile == 3)
159 bitstream_skip(&bc, 1);
160 }
161 }
162 frame->refresh_frame_flags = bitstream_read(&bc, 8);
163 } else {
164 frame->refresh_frame_flags = bitstream_read(&bc, 8);
165 }
166 }
167
168 return 0;
169 }
170
171 static int vp9_raw_reorder_make_output(AVBSFContext *bsf,
172 AVPacket *out,
173 VP9RawReorderFrame *last_frame)
174 {
175 VP9RawReorderContext *ctx = bsf->priv_data;
176 VP9RawReorderFrame *next_output = last_frame,
177 *next_display = last_frame, *frame;
178 int s, err;
179
180 for (s = 0; s < FRAME_SLOTS; s++) {
181 frame = ctx->slot[s];
182 if (!frame)
183 continue;
184 if (frame->needs_output && (!next_output ||
185 frame->sequence < next_output->sequence))
186 next_output = frame;
187 if (frame->needs_display && (!next_display ||
188 frame->pts < next_display->pts))
189 next_display = frame;
190 }
191
192 if (!next_output && !next_display)
193 return AVERROR_EOF;
194
195 if (!next_display || (next_output &&
196 next_output->sequence < next_display->sequence))
197 frame = next_output;
198 else
199 frame = next_display;
200
201 if (frame->needs_output && frame->needs_display &&
202 next_output == next_display) {
203 av_log(bsf, AV_LOG_DEBUG, "Output and display frame "
204 "%"PRId64" (%"PRId64") in order.\n",
205 frame->sequence, frame->pts);
206
207 av_packet_move_ref(out, frame->packet);
208
209 frame->needs_output = frame->needs_display = 0;
210 } else if (frame->needs_output) {
211 if (frame->needs_display) {
212 av_log(bsf, AV_LOG_DEBUG, "Output frame %"PRId64" "
213 "(%"PRId64") for later display.\n",
214 frame->sequence, frame->pts);
215 } else {
216 av_log(bsf, AV_LOG_DEBUG, "Output unshown frame "
217 "%"PRId64" (%"PRId64") to keep order.\n",
218 frame->sequence, frame->pts);
219 }
220
221 av_packet_move_ref(out, frame->packet);
222 out->pts = out->dts;
223
224 frame->needs_output = 0;
225 } else {
226 PutBitContext pb;
227
228 av_assert0(!frame->needs_output && frame->needs_display);
229
230 if (frame->slots == 0) {
231 av_log(bsf, AV_LOG_ERROR, "Attempting to display frame "
232 "which is no longer available?\n");
233 frame->needs_display = 0;
234 return AVERROR_INVALIDDATA;
235 }
236
237 s = ff_ctz(frame->slots);
238 av_assert0(s < FRAME_SLOTS);
239
240 av_log(bsf, AV_LOG_DEBUG, "Display frame %"PRId64" "
241 "(%"PRId64") from slot %d.\n",
242 frame->sequence, frame->pts, s);
243
244 frame->packet = av_packet_alloc();
245 if (!frame->packet)
246 return AVERROR(ENOMEM);
247
248 err = av_new_packet(out, 2);
249 if (err < 0)
250 return err;
251
252 init_put_bits(&pb, out->data, 2);
253
254 // frame_marker
255 put_bits(&pb, 2, 2);
256 // profile_low_bit
257 put_bits(&pb, 1, frame->profile & 1);
258 // profile_high_bit
259 put_bits(&pb, 1, (frame->profile >> 1) & 1);
260 if (frame->profile == 3) {
261 // reserved_zero
262 put_bits(&pb, 1, 0);
263 }
264 // show_existing_frame
265 put_bits(&pb, 1, 1);
266 // frame_to_show_map_idx
267 put_bits(&pb, 3, s);
268
269 while (put_bits_count(&pb) < 16)
270 put_bits(&pb, 1, 0);
271
272 flush_put_bits(&pb);
273 out->pts = out->dts = frame->pts;
274
275 frame->needs_display = 0;
276 }
277
278 return 0;
279 }
280
281 static int vp9_raw_reorder_filter(AVBSFContext *bsf, AVPacket *out)
282 {
283 VP9RawReorderContext *ctx = bsf->priv_data;
284 VP9RawReorderFrame *frame;
285 AVPacket *in;
286 int err, s;
287
288 if (ctx->next_frame) {
289 frame = ctx->next_frame;
290
291 } else {
292 err = ff_bsf_get_packet(bsf, &in);
293 if (err < 0) {
294 if (err == AVERROR_EOF)
295 return vp9_raw_reorder_make_output(bsf, out, NULL);
296 return err;
297 }
298
299 if (in->data[in->size - 1] & 0xe0 == 0xc0) {
300 av_log(bsf, AV_LOG_ERROR, "Input in superframes is not "
301 "supported.\n");
302 av_packet_free(&in);
303 return AVERROR(ENOSYS);
304 }
305
306 frame = av_mallocz(sizeof(*frame));
307 if (!frame) {
308 av_packet_free(&in);
309 return AVERROR(ENOMEM);
310 }
311
312 frame->packet = in;
313 frame->pts = in->pts;
314 frame->sequence = ++ctx->sequence;
315 err = vp9_raw_reorder_frame_parse(bsf, frame);
316 if (err) {
317 av_log(bsf, AV_LOG_ERROR, "Failed to parse input "
318 "frame: %d.\n", err);
319 goto fail;
320 }
321
322 frame->needs_output = 1;
323 frame->needs_display = frame->pts != AV_NOPTS_VALUE;
324
325 if (frame->show_existing_frame)
326 av_log(bsf, AV_LOG_DEBUG, "Show frame %"PRId64" "
327 "(%"PRId64"): show %u.\n", frame->sequence,
328 frame->pts, frame->frame_to_show);
329 else
330 av_log(bsf, AV_LOG_DEBUG, "New frame %"PRId64" "
331 "(%"PRId64"): type %u show %u refresh %02x.\n",
332 frame->sequence, frame->pts, frame->frame_type,
333 frame->show_frame, frame->refresh_frame_flags);
334
335 ctx->next_frame = frame;
336 }
337
338 for (s = 0; s < FRAME_SLOTS; s++) {
339 if (!(frame->refresh_frame_flags & (1 << s)))
340 continue;
341 if (ctx->slot[s] && ctx->slot[s]->needs_display &&
342 ctx->slot[s]->slots == (1 << s)) {
343 // We are overwriting this slot, which is last reference
344 // to the frame previously present in it. In order to be
345 // a valid stream, that frame must already have been
346 // displayed before the pts of the current frame.
347 err = vp9_raw_reorder_make_output(bsf, out, ctx->slot[s]);
348 if (err < 0) {
349 av_log(bsf, AV_LOG_ERROR, "Failed to create "
350 "output overwriting slot %d: %d.\n",
351 s, err);
352 // Clear the slot anyway, so we don't end up
353 // in an infinite loop.
354 vp9_raw_reorder_clear_slot(ctx, s);
355 return AVERROR_INVALIDDATA;
356 }
357 return 0;
358 }
359 vp9_raw_reorder_clear_slot(ctx, s);
360 }
361
362 for (s = 0; s < FRAME_SLOTS; s++) {
363 if (!(frame->refresh_frame_flags & (1 << s)))
364 continue;
365 ctx->slot[s] = frame;
366 }
367 frame->slots = frame->refresh_frame_flags;
368
369 if (!frame->refresh_frame_flags) {
370 err = vp9_raw_reorder_make_output(bsf, out, frame);
371 if (err < 0) {
372 av_log(bsf, AV_LOG_ERROR, "Failed to create output "
373 "for transient frame.\n");
374 ctx->next_frame = NULL;
375 return AVERROR_INVALIDDATA;
376 }
377 if (!frame->needs_display) {
378 vp9_raw_reorder_frame_free(&frame);
379 ctx->next_frame = NULL;
380 }
381 return 0;
382 }
383
384 ctx->next_frame = NULL;
385 return AVERROR(EAGAIN);
386
387 fail:
388 vp9_raw_reorder_frame_free(&frame);
389 return err;
390 }
391
392 static void vp9_raw_reorder_close(AVBSFContext *bsf)
393 {
394 VP9RawReorderContext *ctx = bsf->priv_data;
395 int s;
396
397 for (s = 0; s < FRAME_SLOTS; s++)
398 vp9_raw_reorder_clear_slot(ctx, s);
399 }
400
401 static const enum AVCodecID vp9_raw_reorder_codec_ids[] = {
402 AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
403 };
404
405 const AVBitStreamFilter ff_vp9_raw_reorder_bsf = {
406 .name = "vp9_raw_reorder",
407 .priv_data_size = sizeof(VP9RawReorderContext),
408 .close = &vp9_raw_reorder_close,
409 .filter = &vp9_raw_reorder_filter,
410 .codec_ids = vp9_raw_reorder_codec_ids,
411 };