lavc/htmlsubtitles: handle colors starting with many '#'
[ffmpeg.git] / libavcodec / vp9_raw_reorder_bsf.c
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 #include "libavutil/opt.h"
24
25 #include "bsf.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->data[in->size - 1] & 0xe0 == 0xc0) {
296             av_log(bsf, AV_LOG_ERROR, "Input in superframes is not "
297                    "supported.\n");
298             av_packet_free(&in);
299             return AVERROR(ENOSYS);
300         }
301
302         frame = av_mallocz(sizeof(*frame));
303         if (!frame) {
304             av_packet_free(&in);
305             return AVERROR(ENOMEM);
306         }
307
308         frame->packet   = in;
309         frame->pts      = in->pts;
310         frame->sequence = ++ctx->sequence;
311         err = vp9_raw_reorder_frame_parse(bsf, frame);
312         if (err) {
313             av_log(bsf, AV_LOG_ERROR, "Failed to parse input "
314                    "frame: %d.\n", err);
315             goto fail;
316         }
317
318         frame->needs_output  = 1;
319         frame->needs_display = frame->pts != AV_NOPTS_VALUE;
320
321         if (frame->show_existing_frame)
322             av_log(bsf, AV_LOG_DEBUG, "Show frame %"PRId64" "
323                    "(%"PRId64"): show %u.\n", frame->sequence,
324                    frame->pts, frame->frame_to_show);
325         else
326             av_log(bsf, AV_LOG_DEBUG, "New frame %"PRId64" "
327                    "(%"PRId64"): type %u show %u refresh %02x.\n",
328                    frame->sequence, frame->pts, frame->frame_type,
329                    frame->show_frame, frame->refresh_frame_flags);
330
331         ctx->next_frame = frame;
332     }
333
334     for (s = 0; s < FRAME_SLOTS; s++) {
335         if (!(frame->refresh_frame_flags & (1 << s)))
336             continue;
337         if (ctx->slot[s] && ctx->slot[s]->needs_display &&
338             ctx->slot[s]->slots == (1 << s)) {
339             // We are overwriting this slot, which is last reference
340             // to the frame previously present in it.  In order to be
341             // a valid stream, that frame must already have been
342             // displayed before the pts of the current frame.
343             err = vp9_raw_reorder_make_output(bsf, out, ctx->slot[s]);
344             if (err < 0) {
345                 av_log(bsf, AV_LOG_ERROR, "Failed to create "
346                        "output overwriting slot %d: %d.\n",
347                        s, err);
348                 // Clear the slot anyway, so we don't end up
349                 // in an infinite loop.
350                 vp9_raw_reorder_clear_slot(ctx, s);
351                 return AVERROR_INVALIDDATA;
352             }
353             return 0;
354         }
355         vp9_raw_reorder_clear_slot(ctx, s);
356     }
357
358     for (s = 0; s < FRAME_SLOTS; s++) {
359         if (!(frame->refresh_frame_flags & (1 << s)))
360             continue;
361         ctx->slot[s] = frame;
362     }
363     frame->slots = frame->refresh_frame_flags;
364
365     if (!frame->refresh_frame_flags) {
366         err = vp9_raw_reorder_make_output(bsf, out, frame);
367         if (err < 0) {
368             av_log(bsf, AV_LOG_ERROR, "Failed to create output "
369                    "for transient frame.\n");
370             ctx->next_frame = NULL;
371             return AVERROR_INVALIDDATA;
372         }
373         if (!frame->needs_display) {
374             vp9_raw_reorder_frame_free(&frame);
375             ctx->next_frame = NULL;
376         }
377         return 0;
378     }
379
380     ctx->next_frame = NULL;
381     return AVERROR(EAGAIN);
382
383 fail:
384     vp9_raw_reorder_frame_free(&frame);
385     return err;
386 }
387
388 static void vp9_raw_reorder_close(AVBSFContext *bsf)
389 {
390     VP9RawReorderContext *ctx = bsf->priv_data;
391     int s;
392
393     for (s = 0; s < FRAME_SLOTS; s++)
394         vp9_raw_reorder_clear_slot(ctx, s);
395 }
396
397 static const enum AVCodecID vp9_raw_reorder_codec_ids[] = {
398     AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
399 };
400
401 const AVBitStreamFilter ff_vp9_raw_reorder_bsf = {
402     .name           = "vp9_raw_reorder",
403     .priv_data_size = sizeof(VP9RawReorderContext),
404     .close          = &vp9_raw_reorder_close,
405     .filter         = &vp9_raw_reorder_filter,
406     .codec_ids      = vp9_raw_reorder_codec_ids,
407 };