FFmpeg
dts2pts_bsf.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2022 James Almer
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Derive PTS by reordering DTS from supported streams
24  */
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/fifo.h"
28 #include "libavutil/tree.h"
29 
30 #include "bsf.h"
31 #include "bsf_internal.h"
32 #include "cbs.h"
33 #include "cbs_h264.h"
34 #include "h264_parse.h"
35 #include "h264_ps.h"
36 
37 typedef struct DTS2PTSNode {
38  int64_t dts;
39  int64_t duration;
40  int poc;
41  int gop;
42 } DTS2PTSNode;
43 
44 typedef struct DTS2PTSFrame {
46  int poc;
47  int poc_diff;
48  int gop;
49 } DTS2PTSFrame;
50 
51 typedef struct DTS2PTSH264Context {
54  int poc_diff;
55  int last_poc;
59 
60 typedef struct DTS2PTSContext {
61  struct AVTreeNode *root;
63 
64  // Codec specific function pointers and constants
67  void (*flush)(AVBSFContext *ctx);
68  size_t fifo_size;
69 
72 
73  union {
75  } u;
76 
77  int nb_frame;
78  int gop;
79  int eof;
81 
82 // AVTreeNode callbacks
83 static int cmp_insert(const void *key, const void *node)
84 {
85  int ret = ((const DTS2PTSNode *)key)->poc - ((const DTS2PTSNode *)node)->poc;
86  if (!ret)
87  ret = ((const DTS2PTSNode *)key)->gop - ((const DTS2PTSNode *)node)->gop;
88  return ret;
89 }
90 
91 static int cmp_find(const void *key, const void *node)
92 {
93  const DTS2PTSFrame * key1 = key;
94  const DTS2PTSNode *node1 = node;
95  int ret = FFDIFFSIGN(key1->poc, node1->poc);
96  if (!ret)
97  ret = key1->gop - node1->gop;
98  return ret;
99 }
100 
101 static int dec_poc(void *opaque, void *elem)
102 {
103  DTS2PTSNode *node = elem;
104  int dec = *(int *)opaque;
105  node->poc -= dec;
106  return 0;
107 }
108 
109 static int free_node(void *opaque, void *elem)
110 {
111  DTS2PTSNode *node = elem;
112  av_free(node);
113  return 0;
114 }
115 
116 // Shared functions
117 static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration,
118  int poc, int poc_diff, int gop)
119 {
121  for (int i = 0; i < poc_diff; i++) {
122  struct AVTreeNode *node = av_tree_node_alloc();
123  DTS2PTSNode *poc_node, *ret;
124  if (!node)
125  return AVERROR(ENOMEM);
126  poc_node = av_malloc(sizeof(*poc_node));
127  if (!poc_node) {
128  av_free(node);
129  return AVERROR(ENOMEM);
130  }
131  if (i && ts != AV_NOPTS_VALUE)
132  ts += duration / poc_diff;
133  *poc_node = (DTS2PTSNode) { ts, duration, poc++, gop };
134  ret = av_tree_insert(&s->root, poc_node, cmp_insert, &node);
135  if (ret && ret != poc_node) {
136  *ret = *poc_node;
137  av_free(poc_node);
138  av_free(node);
139  }
140  }
141  return 0;
142 }
143 
144 // H.264
146  H264_NAL_SPS,
147  H264_NAL_PPS,
150 };
151 
153 {
155  DTS2PTSH264Context *h264 = &s->u.h264;
156 
157  s->cbc->decompose_unit_types = h264_decompose_unit_types;
158  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(h264_decompose_unit_types);
159 
160  s->nb_frame = -(ctx->par_in->video_delay << 1);
161  h264->last_poc = h264->highest_poc = INT_MIN;
162 
163  return 0;
164 }
165 
167 {
168  if (header->nal_unit_header.nal_ref_idc == 0 ||
169  !header->adaptive_ref_pic_marking_mode_flag)
170  return 0;
171 
172  for (int i = 0; i < H264_MAX_MMCO_COUNT; i++) {
173  if (header->mmco[i].memory_management_control_operation == 0)
174  return 0;
175  else if (header->mmco[i].memory_management_control_operation == 5)
176  return 1;
177  }
178 
179  return 0;
180 }
181 
182 static int h264_queue_frame(AVBSFContext *ctx, AVPacket *pkt, int poc, int *queued)
183 {
185  DTS2PTSH264Context *h264 = &s->u.h264;
187  int poc_diff, ret;
188 
189  poc_diff = (h264->picture_structure == 3) + 1;
190  if (h264->sps.frame_mbs_only_flag && h264->poc_diff)
191  poc_diff = FFMIN(poc_diff, h264->poc_diff);
192  if (poc < 0) {
193  av_tree_enumerate(s->root, &poc_diff, NULL, dec_poc);
194  s->nb_frame -= poc_diff;
195  }
196  // Check if there was a POC reset (Like an IDR slice)
197  if (s->nb_frame > h264->highest_poc) {
198  s->nb_frame = 0;
199  s->gop = (s->gop + 1) % s->fifo_size;
200  h264->highest_poc = h264->last_poc;
201  }
202 
203  ret = alloc_and_insert_node(ctx, pkt->dts, pkt->duration, s->nb_frame, poc_diff, s->gop);
204  if (ret < 0)
205  return ret;
206  av_log(ctx, AV_LOG_DEBUG, "Queueing frame with POC %d, GOP %d, dts %"PRId64"\n",
207  poc, s->gop, pkt->dts);
208  s->nb_frame += poc_diff;
209 
210  // Add frame to output FIFO only once
211  if (*queued)
212  return 0;
213 
214  frame = (DTS2PTSFrame) { pkt, poc, poc_diff, s->gop };
215  ret = av_fifo_write(s->fifo, &frame, 1);
216  av_assert2(ret >= 0);
217  *queued = 1;
218 
219  return 0;
220 }
221 
223 {
225  DTS2PTSH264Context *h264 = &s->u.h264;
226  CodedBitstreamFragment *au = &s->au;
227  AVPacket *in;
228  int output_picture_number = INT_MIN;
229  int field_poc[2];
230  int queued = 0, ret;
231 
232  ret = ff_bsf_get_packet(ctx, &in);
233  if (ret < 0)
234  return ret;
235 
236  ret = ff_cbs_read_packet(s->cbc, au, in);
237  if (ret < 0) {
238  av_log(ctx, AV_LOG_WARNING, "Failed to parse access unit.\n");
239  goto fail;
240  }
241 
242  for (int i = 0; i < au->nb_units; i++) {
243  CodedBitstreamUnit *unit = &au->units[i];
244 
245  switch (unit->type) {
246  case H264_NAL_IDR_SLICE:
247  h264->poc.prev_frame_num = 0;
248  h264->poc.prev_frame_num_offset = 0;
249  h264->poc.prev_poc_msb =
250  h264->poc.prev_poc_lsb = 0;
251  // fall-through
252  case H264_NAL_SLICE: {
253  const H264RawSlice *slice = unit->content;
254  const H264RawSliceHeader *header = &slice->header;
255  const CodedBitstreamH264Context *cbs_h264 = s->cbc->priv_data;
256  const H264RawSPS *sps = cbs_h264->active_sps;
257  int got_reset;
258 
259  if (!sps) {
260  av_log(ctx, AV_LOG_ERROR, "No active SPS for a slice\n");
261  goto fail;
262  }
263  // Initialize the SPS struct with the fields ff_h264_init_poc() cares about
264  h264->sps.frame_mbs_only_flag = sps->frame_mbs_only_flag;
265  h264->sps.log2_max_frame_num = sps->log2_max_frame_num_minus4 + 4;
266  h264->sps.poc_type = sps->pic_order_cnt_type;
267  h264->sps.log2_max_poc_lsb = sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
268  h264->sps.offset_for_non_ref_pic = sps->offset_for_non_ref_pic;
269  h264->sps.offset_for_top_to_bottom_field = sps->offset_for_top_to_bottom_field;
270  h264->sps.poc_cycle_length = sps->num_ref_frames_in_pic_order_cnt_cycle;
271  for (int i = 0; i < h264->sps.poc_cycle_length; i++)
272  h264->sps.offset_for_ref_frame[i] = sps->offset_for_ref_frame[i];
273 
274  h264->picture_structure = sps->frame_mbs_only_flag ? 3 :
275  (header->field_pic_flag ?
276  header->field_pic_flag + header->bottom_field_flag : 3);
277 
278  h264->poc.frame_num = header->frame_num;
279  h264->poc.poc_lsb = header->pic_order_cnt_lsb;
280  h264->poc.delta_poc_bottom = header->delta_pic_order_cnt_bottom;
281  h264->poc.delta_poc[0] = header->delta_pic_order_cnt[0];
282  h264->poc.delta_poc[1] = header->delta_pic_order_cnt[1];
283 
284  field_poc[0] = field_poc[1] = INT_MAX;
285  ret = ff_h264_init_poc(field_poc, &output_picture_number, &h264->sps,
286  &h264->poc, h264->picture_structure,
287  header->nal_unit_header.nal_ref_idc);
288  if (ret < 0) {
289  av_log(ctx, AV_LOG_ERROR, "ff_h264_init_poc() failure\n");
290  goto fail;
291  }
292 
293  got_reset = get_mmco_reset(header);
294  h264->poc.prev_frame_num = got_reset ? 0 : h264->poc.frame_num;
295  h264->poc.prev_frame_num_offset = got_reset ? 0 : h264->poc.frame_num_offset;
296  if (header->nal_unit_header.nal_ref_idc != 0) {
297  h264->poc.prev_poc_msb = got_reset ? 0 : h264->poc.poc_msb;
298  if (got_reset)
299  h264->poc.prev_poc_lsb = h264->picture_structure == 2 ? 0 : field_poc[0];
300  else
301  h264->poc.prev_poc_lsb = h264->poc.poc_lsb;
302  }
303 
304  if (output_picture_number != h264->last_poc) {
305  if (h264->last_poc != INT_MIN) {
306  int64_t diff = FFABS(h264->last_poc - (int64_t)output_picture_number);
307 
308  if ((output_picture_number < 0) && !h264->last_poc)
309  h264->poc_diff = 0;
310  else if (FFABS((int64_t)output_picture_number) < h264->poc_diff) {
311  diff = FFABS(output_picture_number);
312  h264->poc_diff = 0;
313  }
314  if ((!h264->poc_diff || (h264->poc_diff > diff)) && diff <= INT_MAX) {
315  h264->poc_diff = diff;
316  if (h264->poc_diff == 1 && h264->sps.frame_mbs_only_flag) {
317  av_tree_enumerate(s->root, &h264->poc_diff, NULL, dec_poc);
318  s->nb_frame -= 2;
319  }
320  }
321  }
322  h264->last_poc = output_picture_number;
323  h264->highest_poc = FFMAX(h264->highest_poc, output_picture_number);
324 
325  ret = h264_queue_frame(ctx, in, output_picture_number, &queued);
326  if (ret < 0)
327  goto fail;
328  }
329  break;
330  }
331  default:
332  break;
333  }
334  }
335 
336  if (output_picture_number == INT_MIN) {
337  av_log(ctx, AV_LOG_ERROR, "No slices in access unit\n");
339  goto fail;
340  }
341 
342  ret = 0;
343 fail:
345  if (!queued)
346  av_packet_free(&in);
347 
348  return ret;
349 }
350 
352 {
354  DTS2PTSH264Context *h264 = &s->u.h264;
355 
356  memset(&h264->sps, 0, sizeof(h264->sps));
357  memset(&h264->poc, 0, sizeof(h264->poc));
358  s->nb_frame = -(ctx->par_in->video_delay << 1);
359  h264->last_poc = h264->highest_poc = INT_MIN;
360 }
361 
362 // Core functions
363 static const struct {
364  enum AVCodecID id;
367  void (*flush)(AVBSFContext *ctx);
368  size_t fifo_size;
369 } func_tab[] = {
371 };
372 
374 {
376  CodedBitstreamFragment *au = &s->au;
377  int i, ret;
378 
379  for (i = 0; i < FF_ARRAY_ELEMS(func_tab); i++) {
380  if (func_tab[i].id == ctx->par_in->codec_id) {
381  s->init = func_tab[i].init;
382  s->filter = func_tab[i].filter;
383  s->flush = func_tab[i].flush;
384  s->fifo_size = func_tab[i].fifo_size;
385  break;
386  }
387  }
388  if (i == FF_ARRAY_ELEMS(func_tab))
389  return AVERROR_BUG;
390  av_assert0(s->filter && s->fifo_size);
391 
392  s->fifo = av_fifo_alloc2(s->fifo_size, sizeof(DTS2PTSFrame), 0);
393  if (!s->fifo)
394  return AVERROR(ENOMEM);
395 
396  ret = ff_cbs_init(&s->cbc, ctx->par_in->codec_id, ctx);
397  if (ret < 0)
398  return ret;
399 
400  if (s->init) {
401  ret = s->init(ctx);
402  if (ret < 0)
403  return ret;
404  }
405 
406  if (!ctx->par_in->extradata_size)
407  return 0;
408 
409  ret = ff_cbs_read_extradata(s->cbc, au, ctx->par_in);
410  if (ret < 0)
411  av_log(ctx, AV_LOG_WARNING, "Failed to parse extradata.\n");
412 
414 
415  return 0;
416 }
417 
419 {
421  DTS2PTSNode *poc_node = NULL, *next[2] = { NULL, NULL };
423  int ret;
424 
425  // Fill up the FIFO and POC tree
426  while (!s->eof && av_fifo_can_write(s->fifo)) {
427  ret = s->filter(ctx);
428  if (ret < 0) {
429  if (ret != AVERROR_EOF)
430  return ret;
431  s->eof = 1;
432  }
433  }
434 
435  if (!av_fifo_can_read(s->fifo))
436  return AVERROR_EOF;
437 
438  // Fetch a packet from the FIFO
439  ret = av_fifo_read(s->fifo, &frame, 1);
440  av_assert2(ret >= 0);
442  av_packet_free(&frame.pkt);
443 
444  // Search the timestamp for the requested POC and set PTS
445  poc_node = av_tree_find(s->root, &frame, cmp_find, (void **)next);
446  if (!poc_node) {
447  poc_node = next[1];
448  if (!poc_node || poc_node->poc != frame.poc)
449  poc_node = next[0];
450  }
451  if (poc_node && poc_node->poc == frame.poc) {
452  out->pts = poc_node->dts;
453  if (!s->eof) {
454  // Remove the found entry from the tree
455  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc + 1, frame.poc_diff, frame.gop };
456  for (; dup.poc_diff > 0; dup.poc++, dup.poc_diff--) {
457  struct AVTreeNode *node = NULL;
458  if (!poc_node || poc_node->dts != out->pts)
459  continue;
460  av_tree_insert(&s->root, poc_node, cmp_insert, &node);
461  av_free(poc_node);
462  av_free(node);
463  poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
464  }
465  }
466  } else if (s->eof && frame.poc > INT_MIN) {
467  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc - 1, frame.poc_diff, frame.gop };
468  poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
469  if (poc_node && poc_node->poc == dup.poc) {
470  out->pts = poc_node->dts;
471  if (out->pts != AV_NOPTS_VALUE)
472  out->pts += poc_node->duration;
473  ret = alloc_and_insert_node(ctx, out->pts, out->duration,
474  frame.poc, frame.poc_diff, frame.gop);
475  if (ret < 0) {
477  return ret;
478  }
479  if (!ret)
480  av_log(ctx, AV_LOG_DEBUG, "Queueing frame for POC %d, GOP %d, dts %"PRId64", "
481  "generated from POC %d, GOP %d, dts %"PRId64", duration %"PRId64"\n",
482  frame.poc, frame.gop, out->pts,
483  poc_node->poc, poc_node->gop, poc_node->dts, poc_node->duration);
484  } else
485  av_log(ctx, AV_LOG_WARNING, "No timestamp for POC %d in tree\n", frame.poc);
486  } else
487  av_log(ctx, AV_LOG_WARNING, "No timestamp for POC %d in tree\n", frame.poc);
488  av_log(ctx, AV_LOG_DEBUG, "Returning frame for POC %d, GOP %d, dts %"PRId64", pts %"PRId64"\n",
489  frame.poc, frame.gop, out->dts, out->pts);
490 
491  return 0;
492 }
493 
495 {
498 
499  if (s->flush)
500  s->flush(ctx);
501  s->eof = 0;
502  s->gop = 0;
503 
504  while (s->fifo && av_fifo_read(s->fifo, &frame, 1) >= 0)
505  av_packet_free(&frame.pkt);
506 
508  av_tree_destroy(s->root);
509  s->root = NULL;
510 
511  ff_cbs_fragment_reset(&s->au);
512  if (s->cbc)
513  ff_cbs_flush(s->cbc);
514 }
515 
517 {
519 
521 
522  av_fifo_freep2(&s->fifo);
523  ff_cbs_fragment_free(&s->au);
524  ff_cbs_close(&s->cbc);
525 }
526 
527 static const enum AVCodecID dts2pts_codec_ids[] = {
530 };
531 
533  .p.name = "dts2pts",
534  .p.codec_ids = dts2pts_codec_ids,
535  .priv_data_size = sizeof(DTS2PTSContext),
536  .init = dts2pts_init,
537  .flush = dts2pts_flush,
538  .close = dts2pts_close,
540 };
SPS::offset_for_ref_frame
int32_t offset_for_ref_frame[256]
Definition: h264_ps.h:80
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
dts2pts_init
static int dts2pts_init(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:373
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
H264POCContext::frame_num_offset
int frame_num_offset
for POC type 2
Definition: h264_parse.h:90
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
DTS2PTSContext::fifo_size
size_t fifo_size
Definition: dts2pts_bsf.c:68
out
FILE * out
Definition: movenc.c:54
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:85
DTS2PTSFrame::gop
int gop
Definition: dts2pts_bsf.c:48
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:171
SPS::offset_for_non_ref_pic
int offset_for_non_ref_pic
Definition: h264_ps.h:55
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_tree_insert
void * av_tree_insert(AVTreeNode **tp, void *key, int(*cmp)(const void *key, const void *b), AVTreeNode **next)
Insert or remove an element.
Definition: tree.c:59
DTS2PTSFrame::poc
int poc
Definition: dts2pts_bsf.c:46
ff_cbs_read_extradata
int ff_cbs_read_extradata(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecParameters *par)
Read the extradata bitstream found in codec parameters into a fragment, then split into units and dec...
Definition: cbs.c:271
cbs_h264.h
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:106
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
DTS2PTSH264Context
Definition: dts2pts_bsf.c:51
h264_parse.h
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:157
dec_poc
static int dec_poc(void *opaque, void *elem)
Definition: dts2pts_bsf.c:101
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:173
DTS2PTSContext
Definition: dts2pts_bsf.c:60
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:73
cbs.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
free_node
static int free_node(void *opaque, void *elem)
Definition: dts2pts_bsf.c:109
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_tree_node_alloc
struct AVTreeNode * av_tree_node_alloc(void)
Allocate an AVTreeNode.
Definition: tree.c:34
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
DTS2PTSFrame::pkt
AVPacket * pkt
Definition: dts2pts_bsf.c:45
SPS::frame_mbs_only_flag
int frame_mbs_only_flag
Definition: h264_ps.h:63
av_tree_enumerate
void av_tree_enumerate(AVTreeNode *t, void *opaque, int(*cmp)(void *opaque, void *elem), int(*enu)(void *opaque, void *elem))
Apply enu(opaque, &elem) to all the elements in the tree in a given range.
Definition: tree.c:155
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
H264POCContext::prev_poc_lsb
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:89
DTS2PTSH264Context::poc
H264POCContext poc
Definition: dts2pts_bsf.c:52
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:69
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:127
DTS2PTSH264Context::poc_diff
int poc_diff
Definition: dts2pts_bsf.c:54
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
H264POCContext::delta_poc
int delta_poc[2]
Definition: h264_parse.h:86
SPS::poc_type
int poc_type
pic_order_cnt_type
Definition: h264_ps.h:52
DTS2PTSContext::fifo
AVFifo * fifo
Definition: dts2pts_bsf.c:62
DTS2PTSH264Context::sps
SPS sps
Definition: dts2pts_bsf.c:53
fifo.h
H264POCContext::prev_frame_num
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:92
cmp_insert
static int cmp_insert(const void *key, const void *node)
Definition: dts2pts_bsf.c:83
bsf.h
fail
#define fail()
Definition: checkasm.h:134
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
CodedBitstreamH264Context::active_sps
const H264RawSPS * active_sps
Definition: cbs_h264.h:418
h264_filter
static int h264_filter(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:222
alloc_and_insert_node
static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration, int poc, int poc_diff, int gop)
Definition: dts2pts_bsf.c:117
ff_dts2pts_bsf
const FFBitStreamFilter ff_dts2pts_bsf
Definition: dts2pts_bsf.c:532
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:167
avassert.h
get_mmco_reset
static int get_mmco_reset(const H264RawSliceHeader *header)
Definition: dts2pts_bsf.c:166
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
h264_decompose_unit_types
static const CodedBitstreamUnitType h264_decompose_unit_types[]
Definition: dts2pts_bsf.c:145
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
dts2pts_close
static void dts2pts_close(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:516
duration
int64_t duration
Definition: movenc.c:64
DTS2PTSContext::cbc
CodedBitstreamContext * cbc
Definition: dts2pts_bsf.c:70
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:121
s
#define s(width, name)
Definition: cbs_vp9.c:256
H264_MAX_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
H264POCContext::prev_frame_num_offset
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:91
DTS2PTSContext::filter
int(* filter)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:66
DTS2PTSNode::poc
int poc
Definition: dts2pts_bsf.c:40
DTS2PTSNode::dts
int64_t dts
Definition: dts2pts_bsf.c:38
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
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
DTS2PTSContext::nb_frame
int nb_frame
Definition: dts2pts_bsf.c:77
ctx
AVFormatContext * ctx
Definition: movenc.c:48
key
const char * key
Definition: hwcontext_opencl.c:174
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
NULL
#define NULL
Definition: coverity.c:32
FFBitStreamFilter
Definition: bsf_internal.h:27
SPS
Sequence parameter set.
Definition: h264_ps.h:45
DTS2PTSContext::flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:67
DTS2PTSNode
Definition: dts2pts_bsf.c:37
DTS2PTSContext::u
union DTS2PTSContext::@65 u
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
AVTreeNode
Definition: tree.c:26
h264_queue_frame
static int h264_queue_frame(AVBSFContext *ctx, AVPacket *pkt, int poc, int *queued)
Definition: dts2pts_bsf.c:182
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
av_tree_destroy
void av_tree_destroy(AVTreeNode *t)
Definition: tree.c:146
dts2pts_codec_ids
static enum AVCodecID dts2pts_codec_ids[]
Definition: dts2pts_bsf.c:527
h264_ps.h
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
CodedBitstreamH264Context
Definition: cbs_h264.h:404
dts2pts_flush
static void dts2pts_flush(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:494
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
DTS2PTSFrame::poc_diff
int poc_diff
Definition: dts2pts_bsf.c:47
DTS2PTSFrame
Definition: dts2pts_bsf.c:44
DTS2PTSContext::h264
DTS2PTSH264Context h264
Definition: dts2pts_bsf.c:74
AVFifo
Definition: fifo.c:35
DTS2PTSH264Context::highest_poc
int highest_poc
Definition: dts2pts_bsf.c:56
DTS2PTSH264Context::last_poc
int last_poc
Definition: dts2pts_bsf.c:55
SPS::poc_cycle_length
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264_ps.h:57
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
DTS2PTSNode::duration
int64_t duration
Definition: dts2pts_bsf.c:39
DTS2PTSContext::init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:65
DTS2PTSContext::gop
int gop
Definition: dts2pts_bsf.c:78
tree.h
header
static const uint8_t header[24]
Definition: sdr2.c:67
fifo_size
size_t fifo_size
Definition: dts2pts_bsf.c:368
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:162
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
filter
int(* filter)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:366
SPS::offset_for_top_to_bottom_field
int offset_for_top_to_bottom_field
Definition: h264_ps.h:56
DTS2PTSH264Context::picture_structure
int picture_structure
Definition: dts2pts_bsf.c:57
H264POCContext::frame_num
int frame_num
Definition: h264_parse.h:87
cmp_find
static int cmp_find(const void *key, const void *node)
Definition: dts2pts_bsf.c:91
H264RawSliceHeader
Definition: cbs_h264.h:310
H264RawSlice::header
H264RawSliceHeader header
Definition: cbs_h264.h:389
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
SPS::log2_max_poc_lsb
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:53
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
H264POCContext
Definition: h264_parse.h:82
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
DTS2PTSContext::au
CodedBitstreamFragment au
Definition: dts2pts_bsf.c:71
ret
ret
Definition: filter_design.txt:187
ff_h264_init_poc
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
Definition: h264_parse.c:279
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
id
enum AVCodecID id
Definition: dts2pts_bsf.c:364
dts2pts_filter
static int dts2pts_filter(AVBSFContext *ctx, AVPacket *out)
Definition: dts2pts_bsf.c:418
CodedBitstreamUnitType
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:46
h264_flush
static void h264_flush(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:351
ff_cbs_read_packet
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:289
av_tree_find
void * av_tree_find(const AVTreeNode *t, void *key, int(*cmp)(const void *key, const void *b), void *next[2])
Definition: tree.c:39
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:367
func_tab
static const struct @64 func_tab[]
DTS2PTSContext::eof
int eof
Definition: dts2pts_bsf.c:79
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:76
H264POCContext::poc_lsb
int poc_lsb
Definition: h264_parse.h:83
DTS2PTSContext::root
struct AVTreeNode * root
Definition: dts2pts_bsf.c:61
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
DTS2PTSNode::gop
int gop
Definition: dts2pts_bsf.c:41
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
H264POCContext::poc_msb
int poc_msb
Definition: h264_parse.h:84
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ff_cbs_flush
av_cold void ff_cbs_flush(CodedBitstreamContext *ctx)
Reset all internal state in a context.
Definition: cbs.c:121
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:88
int
int
Definition: ffmpeg_filter.c:156
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1244
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:152
SPS::log2_max_frame_num
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:51
H264RawSlice
Definition: cbs_h264.h:388
h264_init
static int h264_init(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:152
H264RawSPS
Definition: cbs_h264.h:102