FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vp9_raw_reorder_bsf.c
Date: 2022-07-05 19:52:29
Exec Total Coverage
Lines: 0 193 0.0%
Branches: 0 132 0.0%

Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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
24 #include "bsf.h"
25 #include "bsf_internal.h"
26 #include "get_bits.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 GetBitContext 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 = init_get_bits(&bc, frame->packet->data, 8 * frame->packet->size);
85 if (err)
86 return err;
87
88 frame_marker = get_bits(&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 = get_bits1(&bc);
96 profile_high_bit = get_bits1(&bc);
97 frame->profile = (profile_high_bit << 1) | profile_low_bit;
98 if (frame->profile == 3) {
99 reserved_zero = get_bits1(&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 = get_bits1(&bc);
108 if (frame->show_existing_frame) {
109 frame->frame_to_show = get_bits(&bc, 3);
110 return 0;
111 }
112
113 frame->frame_type = get_bits1(&bc);
114 frame->show_frame = get_bits1(&bc);
115 error_resilient_mode = get_bits1(&bc);
116
117 if (frame->frame_type == 0) {
118 frame_sync_code = get_bits(&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 = get_bits1(&bc);
130 else
131 intra_only = 0;
132 if (error_resilient_mode == 0) {
133 // reset_frame_context
134 skip_bits(&bc, 2);
135 }
136 if (intra_only) {
137 frame_sync_code = get_bits(&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 skip_bits(&bc, 1);
148 }
149 color_space = get_bits(&bc, 3);
150 if (color_space != 7 /* CS_RGB */) {
151 // color_range
152 skip_bits(&bc, 1);
153 if (frame->profile == 1 || frame->profile == 3) {
154 // subsampling
155 skip_bits(&bc, 3);
156 }
157 } else {
158 if (frame->profile == 1 || frame->profile == 3)
159 skip_bits(&bc, 1);
160 }
161 }
162 frame->refresh_frame_flags = get_bits(&bc, 8);
163 } else {
164 frame->refresh_frame_flags = get_bits(&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 err = av_new_packet(out, 2);
245 if (err < 0)
246 return err;
247
248 init_put_bits(&pb, out->data, 2);
249
250 // frame_marker
251 put_bits(&pb, 2, 2);
252 // profile_low_bit
253 put_bits(&pb, 1, frame->profile & 1);
254 // profile_high_bit
255 put_bits(&pb, 1, (frame->profile >> 1) & 1);
256 if (frame->profile == 3) {
257 // reserved_zero
258 put_bits(&pb, 1, 0);
259 }
260 // show_existing_frame
261 put_bits(&pb, 1, 1);
262 // frame_to_show_map_idx
263 put_bits(&pb, 3, s);
264
265 while (put_bits_count(&pb) < 16)
266 put_bits(&pb, 1, 0);
267
268 flush_put_bits(&pb);
269 out->pts = out->dts = frame->pts;
270
271 frame->needs_display = 0;
272 }
273
274 return 0;
275 }
276
277 static int vp9_raw_reorder_filter(AVBSFContext *bsf, AVPacket *out)
278 {
279 VP9RawReorderContext *ctx = bsf->priv_data;
280 VP9RawReorderFrame *frame;
281 AVPacket *in;
282 int err, s;
283
284 if (ctx->next_frame) {
285 frame = ctx->next_frame;
286
287 } else {
288 err = ff_bsf_get_packet(bsf, &in);
289 if (err < 0) {
290 if (err == AVERROR_EOF)
291 return vp9_raw_reorder_make_output(bsf, out, NULL);
292 return err;
293 }
294
295 if (!in->size) {
296 av_packet_free(&in);
297 return AVERROR_INVALIDDATA;
298 }
299
300 if ((in->data[in->size - 1] & 0xe0) == 0xc0) {
301 av_log(bsf, AV_LOG_ERROR, "Input in superframes is not "
302 "supported.\n");
303 av_packet_free(&in);
304 return AVERROR(ENOSYS);
305 }
306
307 frame = av_mallocz(sizeof(*frame));
308 if (!frame) {
309 av_packet_free(&in);
310 return AVERROR(ENOMEM);
311 }
312
313 frame->packet = in;
314 frame->pts = in->pts;
315 frame->sequence = ++ctx->sequence;
316 err = vp9_raw_reorder_frame_parse(bsf, frame);
317 if (err) {
318 av_log(bsf, AV_LOG_ERROR, "Failed to parse input "
319 "frame: %d.\n", err);
320 goto fail;
321 }
322
323 frame->needs_output = 1;
324 frame->needs_display = frame->pts != AV_NOPTS_VALUE;
325
326 if (frame->show_existing_frame)
327 av_log(bsf, AV_LOG_DEBUG, "Show frame %"PRId64" "
328 "(%"PRId64"): show %u.\n", frame->sequence,
329 frame->pts, frame->frame_to_show);
330 else
331 av_log(bsf, AV_LOG_DEBUG, "New frame %"PRId64" "
332 "(%"PRId64"): type %u show %u refresh %02x.\n",
333 frame->sequence, frame->pts, frame->frame_type,
334 frame->show_frame, frame->refresh_frame_flags);
335
336 ctx->next_frame = frame;
337 }
338
339 for (s = 0; s < FRAME_SLOTS; s++) {
340 if (!(frame->refresh_frame_flags & (1 << s)))
341 continue;
342 if (ctx->slot[s] && ctx->slot[s]->needs_display &&
343 ctx->slot[s]->slots == (1 << s)) {
344 // We are overwriting this slot, which is last reference
345 // to the frame previously present in it. In order to be
346 // a valid stream, that frame must already have been
347 // displayed before the pts of the current frame.
348 err = vp9_raw_reorder_make_output(bsf, out, ctx->slot[s]);
349 if (err < 0) {
350 av_log(bsf, AV_LOG_ERROR, "Failed to create "
351 "output overwriting slot %d: %d.\n",
352 s, err);
353 // Clear the slot anyway, so we don't end up
354 // in an infinite loop.
355 vp9_raw_reorder_clear_slot(ctx, s);
356 return AVERROR_INVALIDDATA;
357 }
358 return 0;
359 }
360 vp9_raw_reorder_clear_slot(ctx, s);
361 }
362
363 for (s = 0; s < FRAME_SLOTS; s++) {
364 if (!(frame->refresh_frame_flags & (1 << s)))
365 continue;
366 ctx->slot[s] = frame;
367 }
368 frame->slots = frame->refresh_frame_flags;
369
370 if (!frame->refresh_frame_flags) {
371 err = vp9_raw_reorder_make_output(bsf, out, frame);
372 if (err < 0) {
373 av_log(bsf, AV_LOG_ERROR, "Failed to create output "
374 "for transient frame.\n");
375 ctx->next_frame = NULL;
376 return AVERROR_INVALIDDATA;
377 }
378 if (!frame->needs_display) {
379 vp9_raw_reorder_frame_free(&frame);
380 ctx->next_frame = NULL;
381 }
382 return 0;
383 }
384
385 ctx->next_frame = NULL;
386 return AVERROR(EAGAIN);
387
388 fail:
389 vp9_raw_reorder_frame_free(&frame);
390 return err;
391 }
392
393 static av_cold void vp9_raw_reorder_flush_close(AVBSFContext *bsf)
394 {
395 VP9RawReorderContext *ctx = bsf->priv_data;
396
397 for (int s = 0; s < FRAME_SLOTS; s++)
398 vp9_raw_reorder_clear_slot(ctx, s);
399 vp9_raw_reorder_frame_free(&ctx->next_frame);
400 ctx->sequence = 0;
401 }
402
403 static const enum AVCodecID vp9_raw_reorder_codec_ids[] = {
404 AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
405 };
406
407 const FFBitStreamFilter ff_vp9_raw_reorder_bsf = {
408 .p.name = "vp9_raw_reorder",
409 .p.codec_ids = vp9_raw_reorder_codec_ids,
410 .priv_data_size = sizeof(VP9RawReorderContext),
411 .filter = &vp9_raw_reorder_filter,
412 .flush = &vp9_raw_reorder_flush_close,
413 .close = &vp9_raw_reorder_flush_close,
414 };
415