FFmpeg
dts2pts.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/mem.h"
29 #include "libavutil/tree.h"
30 
31 #include "bsf.h"
32 #include "bsf_internal.h"
33 #include "cbs.h"
34 #include "cbs_h264.h"
35 #include "h264_parse.h"
36 #include "h264_ps.h"
37 
38 typedef struct DTS2PTSNode {
39  int64_t dts;
40  int64_t duration;
41  int poc;
42  int gop;
43 } DTS2PTSNode;
44 
45 typedef struct DTS2PTSFrame {
47  int poc;
48  int poc_diff;
49  int gop;
50 } DTS2PTSFrame;
51 
52 typedef struct DTS2PTSH264Context {
55  int poc_diff;
56  int last_poc;
60 
61 typedef struct DTS2PTSContext {
62  struct AVTreeNode *root;
64 
65  // Codec specific function pointers and constants
68  void (*flush)(AVBSFContext *ctx);
69  size_t fifo_size;
70 
73 
74  union {
76  } u;
77 
78  int nb_frame;
79  int gop;
80  int eof;
82 
83 // AVTreeNode callbacks
84 static int cmp_insert(const void *key, const void *node)
85 {
86  int ret = ((const DTS2PTSNode *)key)->poc - ((const DTS2PTSNode *)node)->poc;
87  if (!ret)
88  ret = ((const DTS2PTSNode *)key)->gop - ((const DTS2PTSNode *)node)->gop;
89  return ret;
90 }
91 
92 static int cmp_find(const void *key, const void *node)
93 {
94  const DTS2PTSFrame * key1 = key;
95  const DTS2PTSNode *node1 = node;
96  int ret = FFDIFFSIGN(key1->poc, node1->poc);
97  if (!ret)
98  ret = key1->gop - node1->gop;
99  return ret;
100 }
101 
102 static int dec_poc(void *opaque, void *elem)
103 {
104  DTS2PTSNode *node = elem;
105  int dec = *(int *)opaque;
106  node->poc -= dec;
107  return 0;
108 }
109 
110 static int free_node(void *opaque, void *elem)
111 {
112  DTS2PTSNode *node = elem;
113  av_free(node);
114  return 0;
115 }
116 
117 // Shared functions
118 static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration,
119  int poc, int poc_diff, int gop)
120 {
122  for (int i = 0; i < poc_diff; i++) {
123  struct AVTreeNode *node = av_tree_node_alloc();
124  DTS2PTSNode *poc_node, *ret;
125  if (!node)
126  return AVERROR(ENOMEM);
127  poc_node = av_malloc(sizeof(*poc_node));
128  if (!poc_node) {
129  av_free(node);
130  return AVERROR(ENOMEM);
131  }
132  if (i && ts != AV_NOPTS_VALUE)
133  ts += duration / poc_diff;
134  *poc_node = (DTS2PTSNode) { ts, duration, poc++, gop };
135  ret = av_tree_insert(&s->root, poc_node, cmp_insert, &node);
136  if (ret && ret != poc_node) {
137  *ret = *poc_node;
138  av_free(poc_node);
139  av_free(node);
140  }
141  }
142  return 0;
143 }
144 
145 // H.264
147  H264_NAL_SPS,
148  H264_NAL_PPS,
151 };
152 
154 {
156  DTS2PTSH264Context *h264 = &s->u.h264;
157 
158  s->cbc->decompose_unit_types = h264_decompose_unit_types;
159  s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(h264_decompose_unit_types);
160 
161  s->nb_frame = -(ctx->par_in->video_delay << 1);
162  h264->last_poc = h264->highest_poc = INT_MIN;
163 
164  return 0;
165 }
166 
168 {
169  if (header->nal_unit_header.nal_ref_idc == 0 ||
170  !header->adaptive_ref_pic_marking_mode_flag)
171  return 0;
172 
173  for (int i = 0; i < H264_MAX_MMCO_COUNT; i++) {
174  if (header->mmco[i].memory_management_control_operation == 0)
175  return 0;
176  else if (header->mmco[i].memory_management_control_operation == 5)
177  return 1;
178  }
179 
180  return 0;
181 }
182 
183 static int h264_queue_frame(AVBSFContext *ctx, AVPacket *pkt, int poc, int *queued)
184 {
186  DTS2PTSH264Context *h264 = &s->u.h264;
188  int poc_diff, ret;
189 
190  poc_diff = (h264->picture_structure == 3) + 1;
191  if (h264->sps.frame_mbs_only_flag && h264->poc_diff)
192  poc_diff = FFMIN(poc_diff, h264->poc_diff);
193  if (poc < 0) {
194  av_tree_enumerate(s->root, &poc_diff, NULL, dec_poc);
195  s->nb_frame -= poc_diff;
196  }
197  // Check if there was a POC reset (Like an IDR slice)
198  if (s->nb_frame > h264->highest_poc) {
199  s->nb_frame = 0;
200  s->gop = (s->gop + 1) % s->fifo_size;
201  h264->highest_poc = h264->last_poc;
202  }
203 
204  ret = alloc_and_insert_node(ctx, pkt->dts, pkt->duration, s->nb_frame, poc_diff, s->gop);
205  if (ret < 0)
206  return ret;
207  av_log(ctx, AV_LOG_DEBUG, "Queueing frame with POC %d, GOP %d, dts %"PRId64"\n",
208  poc, s->gop, pkt->dts);
209  s->nb_frame += poc_diff;
210 
211  // Add frame to output FIFO only once
212  if (*queued)
213  return 0;
214 
215  frame = (DTS2PTSFrame) { pkt, poc, poc_diff, s->gop };
216  ret = av_fifo_write(s->fifo, &frame, 1);
217  av_assert2(ret >= 0);
218  *queued = 1;
219 
220  return 0;
221 }
222 
224 {
226  DTS2PTSH264Context *h264 = &s->u.h264;
227  CodedBitstreamFragment *au = &s->au;
228  AVPacket *in;
229  int output_picture_number = INT_MIN;
230  int field_poc[2];
231  int queued = 0, ret;
232 
233  ret = ff_bsf_get_packet(ctx, &in);
234  if (ret < 0)
235  return ret;
236 
237  ret = ff_cbs_read_packet(s->cbc, au, in);
238  if (ret < 0) {
239  av_log(ctx, AV_LOG_WARNING, "Failed to parse access unit.\n");
240  goto fail;
241  }
242 
243  for (int i = 0; i < au->nb_units; i++) {
244  CodedBitstreamUnit *unit = &au->units[i];
245 
246  switch (unit->type) {
247  case H264_NAL_IDR_SLICE:
248  h264->poc.prev_frame_num = 0;
249  h264->poc.prev_frame_num_offset = 0;
250  h264->poc.prev_poc_msb =
251  h264->poc.prev_poc_lsb = 0;
252  // fall-through
253  case H264_NAL_SLICE: {
254  const H264RawSlice *slice = unit->content;
255  const H264RawSliceHeader *header = &slice->header;
256  const CodedBitstreamH264Context *cbs_h264 = s->cbc->priv_data;
257  const H264RawSPS *sps = cbs_h264->active_sps;
258  int got_reset;
259 
260  if (!sps) {
261  av_log(ctx, AV_LOG_ERROR, "No active SPS for a slice\n");
262  goto fail;
263  }
264  // Initialize the SPS struct with the fields ff_h264_init_poc() cares about
265  h264->sps.frame_mbs_only_flag = sps->frame_mbs_only_flag;
266  h264->sps.log2_max_frame_num = sps->log2_max_frame_num_minus4 + 4;
267  h264->sps.poc_type = sps->pic_order_cnt_type;
268  h264->sps.log2_max_poc_lsb = sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
269  h264->sps.offset_for_non_ref_pic = sps->offset_for_non_ref_pic;
270  h264->sps.offset_for_top_to_bottom_field = sps->offset_for_top_to_bottom_field;
271  h264->sps.poc_cycle_length = sps->num_ref_frames_in_pic_order_cnt_cycle;
272  for (int i = 0; i < h264->sps.poc_cycle_length; i++)
273  h264->sps.offset_for_ref_frame[i] = sps->offset_for_ref_frame[i];
274 
275  h264->picture_structure = sps->frame_mbs_only_flag ? 3 :
276  (header->field_pic_flag ?
277  header->field_pic_flag + header->bottom_field_flag : 3);
278 
279  h264->poc.frame_num = header->frame_num;
280  h264->poc.poc_lsb = header->pic_order_cnt_lsb;
281  h264->poc.delta_poc_bottom = header->delta_pic_order_cnt_bottom;
282  h264->poc.delta_poc[0] = header->delta_pic_order_cnt[0];
283  h264->poc.delta_poc[1] = header->delta_pic_order_cnt[1];
284 
285  field_poc[0] = field_poc[1] = INT_MAX;
286  ret = ff_h264_init_poc(field_poc, &output_picture_number, &h264->sps,
287  &h264->poc, h264->picture_structure,
288  header->nal_unit_header.nal_ref_idc);
289  if (ret < 0) {
290  av_log(ctx, AV_LOG_ERROR, "ff_h264_init_poc() failure\n");
291  goto fail;
292  }
293 
294  got_reset = get_mmco_reset(header);
295  h264->poc.prev_frame_num = got_reset ? 0 : h264->poc.frame_num;
296  h264->poc.prev_frame_num_offset = got_reset ? 0 : h264->poc.frame_num_offset;
297  if (header->nal_unit_header.nal_ref_idc != 0) {
298  h264->poc.prev_poc_msb = got_reset ? 0 : h264->poc.poc_msb;
299  if (got_reset)
300  h264->poc.prev_poc_lsb = h264->picture_structure == 2 ? 0 : field_poc[0];
301  else
302  h264->poc.prev_poc_lsb = h264->poc.poc_lsb;
303  }
304 
305  if (output_picture_number != h264->last_poc) {
306  if (h264->last_poc != INT_MIN) {
307  int64_t diff = FFABS(h264->last_poc - (int64_t)output_picture_number);
308 
309  if ((output_picture_number < 0) && !h264->last_poc)
310  h264->poc_diff = 0;
311  else if (FFABS((int64_t)output_picture_number) < h264->poc_diff) {
312  diff = FFABS(output_picture_number);
313  h264->poc_diff = 0;
314  }
315  if ((!h264->poc_diff || (h264->poc_diff > diff)) && diff <= INT_MAX) {
316  h264->poc_diff = diff;
317  if (h264->poc_diff == 1 && h264->sps.frame_mbs_only_flag) {
318  av_tree_enumerate(s->root, &h264->poc_diff, NULL, dec_poc);
319  s->nb_frame -= 2;
320  }
321  }
322  }
323  h264->last_poc = output_picture_number;
324  h264->highest_poc = FFMAX(h264->highest_poc, output_picture_number);
325 
326  ret = h264_queue_frame(ctx, in, output_picture_number, &queued);
327  if (ret < 0)
328  goto fail;
329  }
330  break;
331  }
332  default:
333  break;
334  }
335  }
336 
337  if (output_picture_number == INT_MIN) {
338  av_log(ctx, AV_LOG_ERROR, "No slices in access unit\n");
340  goto fail;
341  }
342 
343  ret = 0;
344 fail:
346  if (!queued)
347  av_packet_free(&in);
348 
349  return ret;
350 }
351 
353 {
355  DTS2PTSH264Context *h264 = &s->u.h264;
356 
357  memset(&h264->sps, 0, sizeof(h264->sps));
358  memset(&h264->poc, 0, sizeof(h264->poc));
359  s->nb_frame = -(ctx->par_in->video_delay << 1);
360  h264->last_poc = h264->highest_poc = INT_MIN;
361 }
362 
363 // Core functions
364 static const struct {
365  enum AVCodecID id;
368  void (*flush)(AVBSFContext *ctx);
369  size_t fifo_size;
370 } func_tab[] = {
372 };
373 
375 {
377  CodedBitstreamFragment *au = &s->au;
378  int i, ret;
379 
380  for (i = 0; i < FF_ARRAY_ELEMS(func_tab); i++) {
381  if (func_tab[i].id == ctx->par_in->codec_id) {
382  s->init = func_tab[i].init;
383  s->filter = func_tab[i].filter;
384  s->flush = func_tab[i].flush;
385  s->fifo_size = func_tab[i].fifo_size;
386  break;
387  }
388  }
389  if (i == FF_ARRAY_ELEMS(func_tab))
390  return AVERROR_BUG;
391  av_assert0(s->filter && s->fifo_size);
392 
393  s->fifo = av_fifo_alloc2(s->fifo_size, sizeof(DTS2PTSFrame), 0);
394  if (!s->fifo)
395  return AVERROR(ENOMEM);
396 
397  ret = ff_cbs_init(&s->cbc, ctx->par_in->codec_id, ctx);
398  if (ret < 0)
399  return ret;
400 
401  if (s->init) {
402  ret = s->init(ctx);
403  if (ret < 0)
404  return ret;
405  }
406 
407  if (!ctx->par_in->extradata_size)
408  return 0;
409 
410  ret = ff_cbs_read_extradata(s->cbc, au, ctx->par_in);
411  if (ret < 0)
412  av_log(ctx, AV_LOG_WARNING, "Failed to parse extradata.\n");
413 
415 
416  return 0;
417 }
418 
420 {
422  DTS2PTSNode *poc_node = NULL, *next[2] = { NULL, NULL };
424  int ret;
425 
426  // Fill up the FIFO and POC tree
427  while (!s->eof && av_fifo_can_write(s->fifo)) {
428  ret = s->filter(ctx);
429  if (ret < 0) {
430  if (ret != AVERROR_EOF)
431  return ret;
432  s->eof = 1;
433  }
434  }
435 
436  if (!av_fifo_can_read(s->fifo))
437  return AVERROR_EOF;
438 
439  // Fetch a packet from the FIFO
440  ret = av_fifo_read(s->fifo, &frame, 1);
441  av_assert2(ret >= 0);
443  av_packet_free(&frame.pkt);
444 
445  // Search the timestamp for the requested POC and set PTS
446  poc_node = av_tree_find(s->root, &frame, cmp_find, (void **)next);
447  if (!poc_node) {
448  poc_node = next[1];
449  if (!poc_node || poc_node->poc != frame.poc)
450  poc_node = next[0];
451  }
452  if (poc_node && poc_node->poc == frame.poc) {
453  out->pts = poc_node->dts;
454  if (!s->eof) {
455  // Remove the found entry from the tree
456  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc + 1, frame.poc_diff, frame.gop };
457  for (; dup.poc_diff > 0; dup.poc++, dup.poc_diff--) {
458  struct AVTreeNode *node = NULL;
459  if (!poc_node || poc_node->dts != out->pts)
460  continue;
461  av_tree_insert(&s->root, poc_node, cmp_insert, &node);
462  av_free(poc_node);
463  av_free(node);
464  poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
465  }
466  }
467  } else if (s->eof && frame.poc > INT_MIN) {
468  DTS2PTSFrame dup = (DTS2PTSFrame) { NULL, frame.poc - 1, frame.poc_diff, frame.gop };
469  poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
470  if (poc_node && poc_node->poc == dup.poc) {
471  out->pts = poc_node->dts;
472  if (out->pts != AV_NOPTS_VALUE)
473  out->pts += poc_node->duration;
474  ret = alloc_and_insert_node(ctx, out->pts, out->duration,
475  frame.poc, frame.poc_diff, frame.gop);
476  if (ret < 0) {
478  return ret;
479  }
480  if (!ret)
481  av_log(ctx, AV_LOG_DEBUG, "Queueing frame for POC %d, GOP %d, dts %"PRId64", "
482  "generated from POC %d, GOP %d, dts %"PRId64", duration %"PRId64"\n",
483  frame.poc, frame.gop, out->pts,
484  poc_node->poc, poc_node->gop, poc_node->dts, poc_node->duration);
485  } else
486  av_log(ctx, AV_LOG_WARNING, "No timestamp for POC %d in tree\n", frame.poc);
487  } else
488  av_log(ctx, AV_LOG_WARNING, "No timestamp for POC %d in tree\n", frame.poc);
489  av_log(ctx, AV_LOG_DEBUG, "Returning frame for POC %d, GOP %d, dts %"PRId64", pts %"PRId64"\n",
490  frame.poc, frame.gop, out->dts, out->pts);
491 
492  return 0;
493 }
494 
496 {
499 
500  if (s->flush)
501  s->flush(ctx);
502  s->eof = 0;
503  s->gop = 0;
504 
505  while (s->fifo && av_fifo_read(s->fifo, &frame, 1) >= 0)
506  av_packet_free(&frame.pkt);
507 
509  av_tree_destroy(s->root);
510  s->root = NULL;
511 
512  ff_cbs_fragment_reset(&s->au);
513  if (s->cbc)
514  ff_cbs_flush(s->cbc);
515 }
516 
518 {
520 
522 
523  av_fifo_freep2(&s->fifo);
524  ff_cbs_fragment_free(&s->au);
525  ff_cbs_close(&s->cbc);
526 }
527 
528 static const enum AVCodecID dts2pts_codec_ids[] = {
531 };
532 
534  .p.name = "dts2pts",
535  .p.codec_ids = dts2pts_codec_ids,
536  .priv_data_size = sizeof(DTS2PTSContext),
537  .init = dts2pts_init,
538  .flush = dts2pts_flush,
539  .close = dts2pts_close,
541 };
SPS::offset_for_ref_frame
int32_t offset_for_ref_frame[256]
Definition: h264_ps.h:79
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
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
cmp_find
static int cmp_find(const void *key, const void *node)
Definition: dts2pts.c:92
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
dts2pts_flush
static void dts2pts_flush(AVBSFContext *ctx)
Definition: dts2pts.c:495
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
DTS2PTSContext::fifo_size
size_t fifo_size
Definition: dts2pts.c:69
out
FILE * out
Definition: movenc.c:55
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:85
DTS2PTSFrame::gop
int gop
Definition: dts2pts.c:49
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:186
SPS::offset_for_non_ref_pic
int offset_for_non_ref_pic
Definition: h264_ps.h:54
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
DTS2PTSFrame::poc
int poc
Definition: dts2pts.c:47
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:286
cbs_h264.h
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:107
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
DTS2PTSH264Context
Definition: dts2pts.c:52
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:172
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
DTS2PTSContext
Definition: dts2pts.c:61
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
dts2pts_filter
static int dts2pts_filter(AVBSFContext *ctx, AVPacket *out)
Definition: dts2pts.c:419
cbs.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
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.c:118
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
h264_init
static int h264_init(AVBSFContext *ctx)
Definition: dts2pts.c:153
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:235
DTS2PTSFrame::pkt
AVPacket * pkt
Definition: dts2pts.c:46
SPS::frame_mbs_only_flag
int frame_mbs_only_flag
Definition: h264_ps.h:62
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
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: packet.c:74
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.c:53
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
DTS2PTSH264Context::poc_diff
int poc_diff
Definition: dts2pts.c:55
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:51
DTS2PTSContext::fifo
AVFifo * fifo
Definition: dts2pts.c:63
DTS2PTSH264Context::sps
SPS sps
Definition: dts2pts.c:54
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
bsf.h
fail
#define fail()
Definition: checkasm.h:179
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:416
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:168
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:60
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
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
duration
int64_t duration
Definition: movenc.c:65
DTS2PTSContext::cbc
CodedBitstreamContext * cbc
Definition: dts2pts.c:71
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
ff_dts2pts_bsf
const FFBitStreamFilter ff_dts2pts_bsf
Definition: dts2pts.c:533
s
#define s(width, name)
Definition: cbs_vp9.c:198
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.c:67
DTS2PTSNode::poc
int poc
Definition: dts2pts.c:41
DTS2PTSNode::dts
int64_t dts
Definition: dts2pts.c:39
filter
int(* filter)(AVBSFContext *ctx)
Definition: dts2pts.c:367
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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.c:78
ctx
AVFormatContext * ctx
Definition: movenc.c:49
key
const char * key
Definition: hwcontext_opencl.c:189
h264_flush
static void h264_flush(AVBSFContext *ctx)
Definition: dts2pts.c:352
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:73
NULL
#define NULL
Definition: coverity.c:32
FFBitStreamFilter
Definition: bsf_internal.h:27
SPS
Sequence parameter set.
Definition: h264_ps.h:44
DTS2PTSContext::flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:68
DTS2PTSNode
Definition: dts2pts.c:38
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
AVTreeNode
Definition: tree.c:26
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:368
get_mmco_reset
static int get_mmco_reset(const H264RawSliceHeader *header)
Definition: dts2pts.c:167
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:484
av_tree_destroy
void av_tree_destroy(AVTreeNode *t)
Definition: tree.c:146
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_init
static int dts2pts_init(AVBSFContext *ctx)
Definition: dts2pts.c:374
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
DTS2PTSFrame::poc_diff
int poc_diff
Definition: dts2pts.c:48
DTS2PTSFrame
Definition: dts2pts.c:45
dts2pts_codec_ids
static enum AVCodecID dts2pts_codec_ids[]
Definition: dts2pts.c:528
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
DTS2PTSContext::h264
DTS2PTSH264Context h264
Definition: dts2pts.c:75
AVFifo
Definition: fifo.c:35
DTS2PTSH264Context::highest_poc
int highest_poc
Definition: dts2pts.c:57
free_node
static int free_node(void *opaque, void *elem)
Definition: dts2pts.c:110
DTS2PTSH264Context::last_poc
int last_poc
Definition: dts2pts.c:56
SPS::poc_cycle_length
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264_ps.h:56
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
DTS2PTSNode::duration
int64_t duration
Definition: dts2pts.c:40
DTS2PTSContext::init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:66
DTS2PTSContext::gop
int gop
Definition: dts2pts.c:79
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
tree.h
header
static const uint8_t header[24]
Definition: sdr2.c:68
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:165
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
SPS::offset_for_top_to_bottom_field
int offset_for_top_to_bottom_field
Definition: h264_ps.h:55
DTS2PTSH264Context::picture_structure
int picture_structure
Definition: dts2pts.c:58
H264POCContext::frame_num
int frame_num
Definition: h264_parse.h:87
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:67
SPS::log2_max_poc_lsb
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:52
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:256
h264_filter
static int h264_filter(AVBSFContext *ctx)
Definition: dts2pts.c:223
dec_poc
static int dec_poc(void *opaque, void *elem)
Definition: dts2pts.c:102
H264POCContext
Definition: h264_parse.h:82
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
DTS2PTSContext::au
CodedBitstreamFragment au
Definition: dts2pts.c:72
cmp_insert
static int cmp_insert(const void *key, const void *node)
Definition: dts2pts.c:84
ret
ret
Definition: filter_design.txt:187
func_tab
static const struct @32 func_tab[]
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:280
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
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.c:365
CodedBitstreamUnitType
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:47
dts2pts_close
static void dts2pts_close(AVBSFContext *ctx)
Definition: dts2pts.c:517
h264_decompose_unit_types
static const CodedBitstreamUnitType h264_decompose_unit_types[]
Definition: dts2pts.c:146
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:304
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
mem.h
DTS2PTSContext::eof
int eof
Definition: dts2pts.c:80
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:90
DTS2PTSContext::u
union DTS2PTSContext::@33 u
H264POCContext::poc_lsb
int poc_lsb
Definition: h264_parse.h:83
DTS2PTSContext::root
struct AVTreeNode * root
Definition: dts2pts.c:62
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
DTS2PTSNode::gop
int gop
Definition: dts2pts.c:42
AVPacket
This structure stores compressed data.
Definition: packet.h:501
h264_queue_frame
static int h264_queue_frame(AVBSFContext *ctx, AVPacket *pkt, int poc, int *queued)
Definition: dts2pts.c:183
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
ff_cbs_flush
av_cold void ff_cbs_flush(CodedBitstreamContext *ctx)
Reset all internal state in a context.
Definition: cbs.c:136
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:424
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
fifo_size
size_t fifo_size
Definition: dts2pts.c:369
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:153
SPS::log2_max_frame_num
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264RawSlice
Definition: cbs_h264.h:388
H264RawSPS
Definition: cbs_h264.h:102