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  int ret = ((const DTS2PTSFrame *)key)->poc - ((const DTS2PTSNode *) node)->poc;
94  if (!ret)
95  ret = ((const DTS2PTSFrame *)key)->gop - ((const DTS2PTSNode *) node)->gop;
96  return ret;
97 }
98 
99 static int dec_poc(void *opaque, void *elem)
100 {
101  DTS2PTSNode *node = elem;
102  int dec = *(int *)opaque;
103  node->poc -= dec;
104  return 0;
105 }
106 
107 static int free_node(void *opaque, void *elem)
108 {
109  DTS2PTSNode *node = elem;
110  av_free(node);
111  return 0;
112 }
113 
114 // Shared functions
115 static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration,
116  int poc, int poc_diff, int gop)
117 {
119  for (int i = 0; i < poc_diff; i++) {
120  struct AVTreeNode *node = av_tree_node_alloc();
121  DTS2PTSNode *poc_node, *ret;
122  if (!node)
123  return AVERROR(ENOMEM);
124  poc_node = av_malloc(sizeof(*poc_node));
125  if (!poc_node) {
126  av_free(node);
127  return AVERROR(ENOMEM);
128  }
129  if (i && ts != AV_NOPTS_VALUE)
130  ts += duration / poc_diff;
131  *poc_node = (DTS2PTSNode) { ts, duration, poc++, gop };
132  ret = av_tree_insert(&s->root, poc_node, cmp_insert, &node);
133  if (ret && ret != poc_node) {
134  *ret = *poc_node;
135  av_free(poc_node);
136  av_free(node);
137  }
138  }
139  return 0;
140 }
141 
142 // H.264
144  H264_NAL_SPS,
145  H264_NAL_PPS,
148 };
149 
151 {
153  DTS2PTSH264Context *h264 = &s->u.h264;
154 
155  s->cbc->decompose_unit_types = h264_decompose_unit_types;
156  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(h264_decompose_unit_types);
157 
158  s->nb_frame = -(ctx->par_in->video_delay << 1);
159  h264->last_poc = h264->highest_poc = INT_MIN;
160 
161  return 0;
162 }
163 
165 {
166  if (header->nal_unit_header.nal_ref_idc == 0 ||
167  !header->adaptive_ref_pic_marking_mode_flag)
168  return 0;
169 
170  for (int i = 0; i < H264_MAX_MMCO_COUNT; i++) {
171  if (header->mmco[i].memory_management_control_operation == 0)
172  return 0;
173  else if (header->mmco[i].memory_management_control_operation == 5)
174  return 1;
175  }
176 
177  return 0;
178 }
179 
180 static int h264_queue_frame(AVBSFContext *ctx, AVPacket *pkt, int poc, int *queued)
181 {
183  DTS2PTSH264Context *h264 = &s->u.h264;
185  int poc_diff, ret;
186 
187  poc_diff = (h264->picture_structure == 3) + 1;
188  if (h264->sps.frame_mbs_only_flag && h264->poc_diff)
189  poc_diff = FFMIN(poc_diff, h264->poc_diff);
190  if (poc < 0) {
191  av_tree_enumerate(s->root, &poc_diff, NULL, dec_poc);
192  s->nb_frame -= poc_diff;
193  }
194  // Check if there was a POC reset (Like an IDR slice)
195  if (s->nb_frame > h264->highest_poc) {
196  s->nb_frame = 0;
197  s->gop = (s->gop + 1) % s->fifo_size;
198  h264->highest_poc = h264->last_poc;
199  }
200 
201  ret = alloc_and_insert_node(ctx, pkt->dts, pkt->duration, s->nb_frame, poc_diff, s->gop);
202  if (ret < 0)
203  return ret;
204  av_log(ctx, AV_LOG_DEBUG, "Queueing frame with POC %d, GOP %d, dts %"PRId64"\n",
205  poc, s->gop, pkt->dts);
206  s->nb_frame += poc_diff;
207 
208  // Add frame to output FIFO only once
209  if (*queued)
210  return 0;
211 
212  frame = (DTS2PTSFrame) { pkt, poc, poc_diff, s->gop };
213  ret = av_fifo_write(s->fifo, &frame, 1);
214  av_assert2(ret >= 0);
215  *queued = 1;
216 
217  return 0;
218 }
219 
221 {
223  DTS2PTSH264Context *h264 = &s->u.h264;
224  CodedBitstreamFragment *au = &s->au;
225  AVPacket *in;
226  int output_picture_number = INT_MIN;
227  int field_poc[2];
228  int queued = 0, ret;
229 
230  ret = ff_bsf_get_packet(ctx, &in);
231  if (ret < 0)
232  return ret;
233 
234  ret = ff_cbs_read_packet(s->cbc, au, in);
235  if (ret < 0) {
236  av_log(ctx, AV_LOG_WARNING, "Failed to parse access unit.\n");
237  goto fail;
238  }
239 
240  for (int i = 0; i < au->nb_units; i++) {
241  CodedBitstreamUnit *unit = &au->units[i];
242 
243  switch (unit->type) {
244  case H264_NAL_IDR_SLICE:
245  h264->poc.prev_frame_num = 0;
246  h264->poc.prev_frame_num_offset = 0;
247  h264->poc.prev_poc_msb =
248  h264->poc.prev_poc_lsb = 0;
249  // fall-through
250  case H264_NAL_SLICE: {
251  const H264RawSlice *slice = unit->content;
252  const H264RawSliceHeader *header = &slice->header;
253  const CodedBitstreamH264Context *cbs_h264 = s->cbc->priv_data;
254  const H264RawSPS *sps = cbs_h264->active_sps;
255  int got_reset;
256 
257  if (!sps) {
258  av_log(ctx, AV_LOG_ERROR, "No active SPS for a slice\n");
259  goto fail;
260  }
261  // Initialize the SPS struct with the fields ff_h264_init_poc() cares about
262  h264->sps.frame_mbs_only_flag = sps->frame_mbs_only_flag;
263  h264->sps.log2_max_frame_num = sps->log2_max_frame_num_minus4 + 4;
264  h264->sps.poc_type = sps->pic_order_cnt_type;
265  h264->sps.log2_max_poc_lsb = sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
266  h264->sps.offset_for_non_ref_pic = sps->offset_for_non_ref_pic;
267  h264->sps.offset_for_top_to_bottom_field = sps->offset_for_top_to_bottom_field;
268  h264->sps.poc_cycle_length = sps->num_ref_frames_in_pic_order_cnt_cycle;
269  for (int i = 0; i < h264->sps.poc_cycle_length; i++)
270  h264->sps.offset_for_ref_frame[i] = sps->offset_for_ref_frame[i];
271 
272  h264->picture_structure = sps->frame_mbs_only_flag ? 3 :
273  (header->field_pic_flag ?
274  header->field_pic_flag + header->bottom_field_flag : 3);
275 
276  h264->poc.frame_num = header->frame_num;
277  h264->poc.poc_lsb = header->pic_order_cnt_lsb;
278  h264->poc.delta_poc_bottom = header->delta_pic_order_cnt_bottom;
279  h264->poc.delta_poc[0] = header->delta_pic_order_cnt[0];
280  h264->poc.delta_poc[1] = header->delta_pic_order_cnt[1];
281 
282  field_poc[0] = field_poc[1] = INT_MAX;
283  ret = ff_h264_init_poc(field_poc, &output_picture_number, &h264->sps,
284  &h264->poc, h264->picture_structure,
285  header->nal_unit_header.nal_ref_idc);
286  if (ret < 0) {
287  av_log(ctx, AV_LOG_ERROR, "ff_h264_init_poc() failure\n");
288  goto fail;
289  }
290 
291  got_reset = get_mmco_reset(header);
292  h264->poc.prev_frame_num = got_reset ? 0 : h264->poc.frame_num;
293  h264->poc.prev_frame_num_offset = got_reset ? 0 : h264->poc.frame_num_offset;
294  if (header->nal_unit_header.nal_ref_idc != 0) {
295  h264->poc.prev_poc_msb = got_reset ? 0 : h264->poc.poc_msb;
296  if (got_reset)
297  h264->poc.prev_poc_lsb = h264->picture_structure == 2 ? 0 : field_poc[0];
298  else
299  h264->poc.prev_poc_lsb = h264->poc.poc_lsb;
300  }
301 
302  if (output_picture_number != h264->last_poc) {
303  if (h264->last_poc != INT_MIN) {
304  int64_t diff = FFABS(h264->last_poc - (int64_t)output_picture_number);
305 
306  if ((output_picture_number < 0) && !h264->last_poc)
307  h264->poc_diff = 0;
308  else if (FFABS((int64_t)output_picture_number) < h264->poc_diff) {
309  diff = FFABS(output_picture_number);
310  h264->poc_diff = 0;
311  }
312  if ((!h264->poc_diff || (h264->poc_diff > diff)) && diff <= INT_MAX) {
313  h264->poc_diff = diff;
314  if (h264->poc_diff == 1 && h264->sps.frame_mbs_only_flag) {
315  av_tree_enumerate(s->root, &h264->poc_diff, NULL, dec_poc);
316  s->nb_frame -= 2;
317  }
318  }
319  }
320  h264->last_poc = output_picture_number;
321  h264->highest_poc = FFMAX(h264->highest_poc, output_picture_number);
322 
323  ret = h264_queue_frame(ctx, in, output_picture_number, &queued);
324  if (ret < 0)
325  goto fail;
326  }
327  break;
328  }
329  default:
330  break;
331  }
332  }
333 
334  if (output_picture_number == INT_MIN) {
335  av_log(ctx, AV_LOG_ERROR, "No slices in access unit\n");
337  goto fail;
338  }
339 
340  ret = 0;
341 fail:
343  if (!queued)
344  av_packet_free(&in);
345 
346  return ret;
347 }
348 
350 {
352  DTS2PTSH264Context *h264 = &s->u.h264;
353 
354  memset(&h264->sps, 0, sizeof(h264->sps));
355  memset(&h264->poc, 0, sizeof(h264->poc));
356  s->nb_frame = -(ctx->par_in->video_delay << 1);
357  h264->last_poc = h264->highest_poc = INT_MIN;
358 }
359 
360 // Core functions
361 static const struct {
362  enum AVCodecID id;
365  void (*flush)(AVBSFContext *ctx);
366  size_t fifo_size;
367 } func_tab[] = {
369 };
370 
372 {
374  CodedBitstreamFragment *au = &s->au;
375  int i, ret;
376 
377  for (i = 0; i < FF_ARRAY_ELEMS(func_tab); i++) {
378  if (func_tab[i].id == ctx->par_in->codec_id) {
379  s->init = func_tab[i].init;
380  s->filter = func_tab[i].filter;
381  s->flush = func_tab[i].flush;
382  s->fifo_size = func_tab[i].fifo_size;
383  break;
384  }
385  }
386  if (i == FF_ARRAY_ELEMS(func_tab))
387  return AVERROR_BUG;
388  av_assert0(s->filter && s->fifo_size);
389 
390  s->fifo = av_fifo_alloc2(s->fifo_size, sizeof(DTS2PTSFrame), 0);
391  if (!s->fifo)
392  return AVERROR(ENOMEM);
393 
394  ret = ff_cbs_init(&s->cbc, ctx->par_in->codec_id, ctx);
395  if (ret < 0)
396  return ret;
397 
398  if (s->init) {
399  ret = s->init(ctx);
400  if (ret < 0)
401  return ret;
402  }
403 
404  if (!ctx->par_in->extradata_size)
405  return 0;
406 
407  ret = ff_cbs_read_extradata(s->cbc, au, ctx->par_in);
408  if (ret < 0)
409  av_log(ctx, AV_LOG_WARNING, "Failed to parse extradata.\n");
410 
412 
413  return 0;
414 }
415 
417 {
419  DTS2PTSNode *poc_node = NULL, *next[2] = { NULL, NULL };
421  int ret;
422 
423  // Fill up the FIFO and POC tree
424  while (!s->eof && av_fifo_can_write(s->fifo)) {
425  ret = s->filter(ctx);
426  if (ret < 0) {
427  if (ret != AVERROR_EOF)
428  return ret;
429  s->eof = 1;
430  }
431  }
432 
433  if (!av_fifo_can_read(s->fifo))
434  return AVERROR_EOF;
435 
436  // Fetch a packet from the FIFO
437  ret = av_fifo_read(s->fifo, &frame, 1);
438  av_assert2(ret >= 0);
440  av_packet_free(&frame.pkt);
441 
442  // Search the timestamp for the requested POC and set PTS
443  poc_node = av_tree_find(s->root, &frame, cmp_find, (void **)next);
444  if (!poc_node) {
445  poc_node = next[1];
446  if (!poc_node || poc_node->poc != frame.poc)
447  poc_node = next[0];
448  }
449  if (poc_node && poc_node->poc == frame.poc) {
450  out->pts = poc_node->dts;
451  if (!s->eof) {
452  // Remove the found entry from the tree
453  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc + 1, frame.poc_diff, frame.gop };
454  for (; dup.poc_diff > 0; dup.poc++, dup.poc_diff--) {
455  struct AVTreeNode *node = NULL;
456  if (!poc_node || poc_node->dts != out->pts)
457  continue;
458  av_tree_insert(&s->root, poc_node, cmp_insert, &node);
459  av_free(poc_node);
460  av_free(node);
461  poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
462  }
463  }
464  } else {
465  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc - 1, frame.poc_diff, frame.gop };
466  if (s->eof && (poc_node = av_tree_find(s->root, &dup, cmp_find, NULL)) && poc_node->poc == dup.poc) {
467  out->pts = poc_node->dts;
468  if (out->pts != AV_NOPTS_VALUE)
469  out->pts += poc_node->duration;
470  ret = alloc_and_insert_node(ctx, out->pts, out->duration,
471  frame.poc, frame.poc_diff, frame.gop);
472  if (ret < 0) {
474  return ret;
475  }
476  if (!ret)
477  av_log(ctx, AV_LOG_DEBUG, "Queueing frame for POC %d, GOP %d, dts %"PRId64", "
478  "generated from POC %d, GOP %d, dts %"PRId64", duration %"PRId64"\n",
479  frame.poc, frame.gop, out->pts,
480  poc_node->poc, poc_node->gop, poc_node->dts, poc_node->duration);
481  } else
482  av_log(ctx, AV_LOG_WARNING, "No timestamp for POC %d in tree\n", frame.poc);
483  }
484  av_log(ctx, AV_LOG_DEBUG, "Returning frame for POC %d, GOP %d, dts %"PRId64", pts %"PRId64"\n",
485  frame.poc, frame.gop, out->dts, out->pts);
486 
487  return 0;
488 }
489 
491 {
494 
495  if (s->flush)
496  s->flush(ctx);
497  s->eof = 0;
498  s->gop = 0;
499 
500  while (s->fifo && av_fifo_read(s->fifo, &frame, 1) >= 0)
501  av_packet_free(&frame.pkt);
502 
504  av_tree_destroy(s->root);
505  s->root = NULL;
506 
507  ff_cbs_fragment_reset(&s->au);
508  if (s->cbc)
509  ff_cbs_flush(s->cbc);
510 }
511 
513 {
515 
517 
518  av_fifo_freep2(&s->fifo);
519  ff_cbs_fragment_free(&s->au);
520  ff_cbs_close(&s->cbc);
521 }
522 
523 static const enum AVCodecID dts2pts_codec_ids[] = {
526 };
527 
529  .p.name = "dts2pts",
530  .p.codec_ids = dts2pts_codec_ids,
531  .priv_data_size = sizeof(DTS2PTSContext),
532  .init = dts2pts_init,
533  .flush = dts2pts_flush,
534  .close = dts2pts_close,
536 };
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:371
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:99
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:107
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:220
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:115
ff_dts2pts_bsf
const FFBitStreamFilter ff_dts2pts_bsf
Definition: dts2pts_bsf.c:528
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:164
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:143
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:512
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:363
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:180
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:523
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:490
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:366
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:364
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:362
dts2pts_filter
static int dts2pts_filter(AVBSFContext *ctx, AVPacket *out)
Definition: dts2pts_bsf.c:416
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:349
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:365
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
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:150
H264RawSPS
Definition: cbs_h264.h:102