FFmpeg
vp9_raw_reorder_bsf.c
Go to the documentation of this file.
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 {
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;
49 
50 typedef struct VP9RawReorderContext {
51  int64_t sequence;
55 
57 {
58  if (*frame)
59  av_packet_free(&(*frame)->packet);
60  av_freep(frame);
61 }
62 
64 {
65  if (ctx->slot[s]) {
66  ctx->slot[s]->slots &= ~(1 << s);
67  if (ctx->slot[s]->slots == 0)
69  else
70  ctx->slot[s] = NULL;
71  }
72 }
73 
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",
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 
172  AVPacket *out,
173  VP9RawReorderFrame *last_frame)
174 {
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);
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 
278 {
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;
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.
356  return AVERROR_INVALIDDATA;
357  }
358  return 0;
359  }
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) {
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) {
380  ctx->next_frame = NULL;
381  }
382  return 0;
383  }
384 
385  ctx->next_frame = NULL;
386  return AVERROR(EAGAIN);
387 
388 fail:
390  return err;
391 }
392 
394 {
396 
397  for (int s = 0; s < FRAME_SLOTS; 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[] = {
405 };
406 
408  .p.name = "vp9_raw_reorder",
409  .p.codec_ids = vp9_raw_reorder_codec_ids,
410  .priv_data_size = sizeof(VP9RawReorderContext),
413  .close = &vp9_raw_reorder_flush_close,
414 };
VP9RawReorderFrame::refresh_frame_flags
unsigned int refresh_frame_flags
Definition: vp9_raw_reorder_bsf.c:47
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
bsf_internal.h
out
FILE * out
Definition: movenc.c:54
ff_ctz
#define ff_ctz
Definition: intmath.h:106
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
VP9RawReorderContext
Definition: vp9_raw_reorder_bsf.c:50
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
AVPacket::data
uint8_t * data
Definition: packet.h:374
VP9RawReorderFrame::show_existing_frame
unsigned int show_existing_frame
Definition: vp9_raw_reorder_bsf.c:42
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
ff_bsf_get_packet
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:236
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:73
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
vp9_raw_reorder_filter
static int vp9_raw_reorder_filter(AVBSFContext *bsf, AVPacket *out)
Definition: vp9_raw_reorder_bsf.c:277
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
intra_only
int8_t intra_only
Definition: mxfenc.c:2204
bsf.h
fail
#define fail()
Definition: checkasm.h:131
GetBitContext
Definition: get_bits.h:61
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
next_output
static const void * next_output(const AVOutputFormat *prev, AVClassCategory c2)
Definition: alldevices.c:95
s
#define s(width, name)
Definition: cbs_vp9.c:256
VP9RawReorderFrame::needs_output
int needs_output
Definition: vp9_raw_reorder_bsf.c:33
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
VP9RawReorderFrame::profile
unsigned int profile
Definition: vp9_raw_reorder_bsf.c:40
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
VP9RawReorderFrame::show_frame
unsigned int show_frame
Definition: vp9_raw_reorder_bsf.c:46
VP9RawReorderFrame::packet
AVPacket * packet
Definition: vp9_raw_reorder_bsf.c:32
PutBitContext
Definition: put_bits.h:50
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:606
NULL
#define NULL
Definition: coverity.c:32
FFBitStreamFilter
Definition: bsf_internal.h:27
frame_sync_code
static int FUNC() frame_sync_code(CodedBitstreamContext *ctx, RWContext *rw, VP9RawFrameHeader *current)
Definition: cbs_vp9_syntax_template.c:19
VP9RawReorderFrame::needs_display
int needs_display
Definition: vp9_raw_reorder_bsf.c:34
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
vp9_raw_reorder_make_output
static int vp9_raw_reorder_make_output(AVBSFContext *bsf, AVPacket *out, VP9RawReorderFrame *last_frame)
Definition: vp9_raw_reorder_bsf.c:171
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
VP9RawReorderFrame::pts
int64_t pts
Definition: vp9_raw_reorder_bsf.c:36
AVPacket::size
int size
Definition: packet.h:375
VP9RawReorderFrame::sequence
int64_t sequence
Definition: vp9_raw_reorder_bsf.c:37
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
VP9RawReorderFrame
Definition: vp9_raw_reorder_bsf.c:31
VP9RawReorderFrame::frame_type
unsigned int frame_type
Definition: vp9_raw_reorder_bsf.c:45
FRAME_SLOTS
#define FRAME_SLOTS
Definition: vp9_raw_reorder_bsf.c:29
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
VP9RawReorderFrame::frame_to_show
unsigned int frame_to_show
Definition: vp9_raw_reorder_bsf.c:43
vp9_raw_reorder_flush_close
static av_cold void vp9_raw_reorder_flush_close(AVBSFContext *bsf)
Definition: vp9_raw_reorder_bsf.c:393
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:83
VP9RawReorderContext::slot
VP9RawReorderFrame * slot[FRAME_SLOTS]
Definition: vp9_raw_reorder_bsf.c:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_vp9_raw_reorder_bsf
const FFBitStreamFilter ff_vp9_raw_reorder_bsf
Definition: vp9_raw_reorder_bsf.c:407
VP9RawReorderFrame::slots
unsigned int slots
Definition: vp9_raw_reorder_bsf.c:38
mem.h
vp9_raw_reorder_codec_ids
static enum AVCodecID vp9_raw_reorder_codec_ids[]
Definition: vp9_raw_reorder_bsf.c:403
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
vp9_raw_reorder_clear_slot
static void vp9_raw_reorder_clear_slot(VP9RawReorderContext *ctx, int s)
Definition: vp9_raw_reorder_bsf.c:63
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
vp9_raw_reorder_frame_free
static void vp9_raw_reorder_frame_free(VP9RawReorderFrame **frame)
Definition: vp9_raw_reorder_bsf.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VP9RawReorderContext::next_frame
VP9RawReorderFrame * next_frame
Definition: vp9_raw_reorder_bsf.c:53
put_bits.h
VP9RawReorderContext::sequence
int64_t sequence
Definition: vp9_raw_reorder_bsf.c:51
vp9_raw_reorder_frame_parse
static int vp9_raw_reorder_frame_parse(AVBSFContext *bsf, VP9RawReorderFrame *frame)
Definition: vp9_raw_reorder_bsf.c:74
intmath.h