FFmpeg
nutdec.c
Go to the documentation of this file.
1 /*
2  * "NUT" Container Format demuxer
3  * Copyright (c) 2004-2006 Michael Niedermayer
4  * Copyright (c) 2003 Alex Beregszaszi
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/avstring.h"
24 #include "libavutil/avassert.h"
25 #include "libavutil/bswap.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/mathematics.h"
29 #include "libavutil/tree.h"
30 #include "libavcodec/bytestream.h"
31 #include "avio_internal.h"
32 #include "demux.h"
33 #include "isom.h"
34 #include "nut.h"
35 #include "riff.h"
36 
37 #define NUT_MAX_STREAMS 256 /* arbitrary sanity check value */
38 
39 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,
40  int64_t *pos_arg, int64_t pos_limit);
41 
42 static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)
43 {
44  unsigned int len = ffio_read_varlen(bc);
45 
46  if (len && maxlen)
47  avio_read(bc, string, FFMIN(len, maxlen));
48  while (len > maxlen) {
49  avio_r8(bc);
50  len--;
51  if (bc->eof_reached)
52  len = maxlen;
53  }
54 
55  if (maxlen)
56  string[FFMIN(len, maxlen - 1)] = 0;
57 
58  if (bc->eof_reached)
59  return AVERROR_EOF;
60  if (maxlen == len)
61  return -1;
62  else
63  return 0;
64 }
65 
66 static int64_t get_s(AVIOContext *bc)
67 {
68  int64_t v = ffio_read_varlen(bc) + 1;
69 
70  if (v & 1)
71  return -(v >> 1);
72  else
73  return (v >> 1);
74 }
75 
76 static uint64_t get_fourcc(AVIOContext *bc)
77 {
78  unsigned int len = ffio_read_varlen(bc);
79 
80  if (len == 2)
81  return avio_rl16(bc);
82  else if (len == 4)
83  return avio_rl32(bc);
84  else {
85  av_log(NULL, AV_LOG_ERROR, "Unsupported fourcc length %d\n", len);
86  return -1;
87  }
88 }
89 
91  int calculate_checksum, uint64_t startcode)
92 {
93  int64_t size;
94 
95  startcode = av_be2ne64(startcode);
96  startcode = ff_crc04C11DB7_update(0, (uint8_t*) &startcode, 8);
97 
99  size = ffio_read_varlen(bc);
100  if (size > 4096)
101  avio_rb32(bc);
102  if (ffio_get_checksum(bc) && size > 4096)
103  return -1;
104 
105  ffio_init_checksum(bc, calculate_checksum ? ff_crc04C11DB7_update : NULL, 0);
106 
107  return size;
108 }
109 
110 static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)
111 {
112  uint64_t state = 0;
113 
114  if (pos >= 0)
115  /* Note, this may fail if the stream is not seekable, but that should
116  * not matter, as in this case we simply start where we currently are */
117  avio_seek(bc, pos, SEEK_SET);
118  while (!avio_feof(bc)) {
119  state = (state << 8) | avio_r8(bc);
120  if ((state >> 56) != 'N')
121  continue;
122  switch (state) {
123  case MAIN_STARTCODE:
124  case STREAM_STARTCODE:
125  case SYNCPOINT_STARTCODE:
126  case INFO_STARTCODE:
127  case INDEX_STARTCODE:
128  return state;
129  }
130  }
131 
132  return 0;
133 }
134 
135 /**
136  * Find the given startcode.
137  * @param code the startcode
138  * @param pos the start position of the search, or -1 if the current position
139  * @return the position of the startcode or -1 if not found
140  */
141 static int64_t find_startcode(AVIOContext *bc, uint64_t code, int64_t pos)
142 {
143  for (;;) {
144  uint64_t startcode = find_any_startcode(bc, pos);
145  if (startcode == code)
146  return avio_tell(bc) - 8;
147  else if (startcode == 0)
148  return -1;
149  pos = -1;
150  }
151 }
152 
153 static int nut_probe(const AVProbeData *p)
154 {
155  int i;
156 
157  for (i = 0; i < p->buf_size-8; i++) {
158  if (AV_RB32(p->buf+i) != MAIN_STARTCODE>>32)
159  continue;
160  if (AV_RB32(p->buf+i+4) == (MAIN_STARTCODE & 0xFFFFFFFF))
161  return AVPROBE_SCORE_MAX;
162  }
163  return 0;
164 }
165 
166 #define GET_V(dst, check) \
167  do { \
168  tmp = ffio_read_varlen(bc); \
169  if (!(check)) { \
170  av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp); \
171  ret = AVERROR_INVALIDDATA; \
172  goto fail; \
173  } \
174  dst = tmp; \
175  } while (0)
176 
177 static int skip_reserved(AVIOContext *bc, int64_t pos)
178 {
179  pos -= avio_tell(bc);
180  if (pos < 0) {
181  avio_seek(bc, pos, SEEK_CUR);
182  return AVERROR_INVALIDDATA;
183  } else {
184  while (pos--) {
185  if (bc->eof_reached)
186  return AVERROR_INVALIDDATA;
187  avio_r8(bc);
188  }
189  return 0;
190  }
191 }
192 
194 {
195  AVFormatContext *s = nut->avf;
196  AVIOContext *bc = s->pb;
197  uint64_t tmp, end, length;
198  unsigned int stream_count;
199  int i, j, count, ret;
200  int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;
201 
202  length = get_packetheader(nut, bc, 1, MAIN_STARTCODE);
203  if (length == (uint64_t)-1)
204  return AVERROR_INVALIDDATA;
205  end = length + avio_tell(bc);
206 
207  nut->version = ffio_read_varlen(bc);
208  if (nut->version < NUT_MIN_VERSION ||
209  nut->version > NUT_MAX_VERSION) {
210  av_log(s, AV_LOG_ERROR, "Version %d not supported.\n",
211  nut->version);
212  return AVERROR(ENOSYS);
213  }
214  if (nut->version > 3)
215  nut->minor_version = ffio_read_varlen(bc);
216 
217  GET_V(stream_count, tmp > 0 && tmp <= NUT_MAX_STREAMS);
218 
219  nut->max_distance = ffio_read_varlen(bc);
220  if (nut->max_distance > 65536) {
221  av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance);
222  nut->max_distance = 65536;
223  }
224 
225  GET_V(nut->time_base_count, tmp > 0 && tmp < INT_MAX / sizeof(AVRational) && tmp < length/2);
226  nut->time_base = av_malloc_array(nut->time_base_count, sizeof(AVRational));
227  if (!nut->time_base)
228  return AVERROR(ENOMEM);
229 
230  for (i = 0; i < nut->time_base_count; i++) {
231  GET_V(nut->time_base[i].num, tmp > 0 && tmp < (1ULL << 31));
232  GET_V(nut->time_base[i].den, tmp > 0 && tmp < (1ULL << 31));
233  if (av_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1) {
234  av_log(s, AV_LOG_ERROR, "invalid time base %d/%d\n",
235  nut->time_base[i].num,
236  nut->time_base[i].den);
238  goto fail;
239  }
240  }
241  tmp_pts = 0;
242  tmp_mul = 1;
243  tmp_stream = 0;
244  tmp_head_idx = 0;
245  for (i = 0; i < 256;) {
246  int tmp_flags = ffio_read_varlen(bc);
247  int tmp_fields = ffio_read_varlen(bc);
248  if (tmp_fields < 0) {
249  av_log(s, AV_LOG_ERROR, "fields %d is invalid\n", tmp_fields);
251  goto fail;
252  }
253 
254  if (tmp_fields > 0)
255  tmp_pts = get_s(bc);
256  if (tmp_fields > 1)
257  tmp_mul = ffio_read_varlen(bc);
258  if (tmp_fields > 2)
259  tmp_stream = ffio_read_varlen(bc);
260  if (tmp_fields > 3)
261  tmp_size = ffio_read_varlen(bc);
262  else
263  tmp_size = 0;
264  if (tmp_fields > 4)
265  tmp_res = ffio_read_varlen(bc);
266  else
267  tmp_res = 0;
268  if (tmp_fields > 5)
269  count = ffio_read_varlen(bc);
270  else
271  count = tmp_mul - (unsigned)tmp_size;
272  if (tmp_fields > 6)
273  get_s(bc);
274  if (tmp_fields > 7)
275  tmp_head_idx = ffio_read_varlen(bc);
276 
277  while (tmp_fields-- > 8) {
278  if (bc->eof_reached) {
279  av_log(s, AV_LOG_ERROR, "reached EOF while decoding main header\n");
281  goto fail;
282  }
283  ffio_read_varlen(bc);
284  }
285 
286  if (count <= 0 || count > 256 - (i <= 'N') - i) {
287  av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);
289  goto fail;
290  }
291  if (tmp_stream >= stream_count) {
292  av_log(s, AV_LOG_ERROR, "illegal stream number %d >= %d\n",
293  tmp_stream, stream_count);
295  goto fail;
296  }
297  if (tmp_size < 0 || tmp_size > INT_MAX - count) {
298  av_log(s, AV_LOG_ERROR, "illegal size\n");
300  goto fail;
301  }
302 
303  for (j = 0; j < count; j++, i++) {
304  if (i == 'N') {
305  nut->frame_code[i].flags = FLAG_INVALID;
306  j--;
307  continue;
308  }
309  nut->frame_code[i].flags = tmp_flags;
310  nut->frame_code[i].pts_delta = tmp_pts;
311  nut->frame_code[i].stream_id = tmp_stream;
312  nut->frame_code[i].size_mul = tmp_mul;
313  nut->frame_code[i].size_lsb = tmp_size + j;
314  nut->frame_code[i].reserved_count = tmp_res;
315  nut->frame_code[i].header_idx = tmp_head_idx;
316  }
317  }
318  av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
319 
320  if (end > avio_tell(bc) + 4) {
321  int rem = 1024;
322  GET_V(nut->header_count, tmp < 128U);
323  nut->header_count++;
324  for (i = 1; i < nut->header_count; i++) {
325  uint8_t *hdr;
326  GET_V(nut->header_len[i], tmp > 0 && tmp < 256);
327  if (rem < nut->header_len[i]) {
329  "invalid elision header %d : %d > %d\n",
330  i, nut->header_len[i], rem);
332  goto fail;
333  }
334  rem -= nut->header_len[i];
335  hdr = av_malloc(nut->header_len[i]);
336  if (!hdr) {
337  ret = AVERROR(ENOMEM);
338  goto fail;
339  }
340  avio_read(bc, hdr, nut->header_len[i]);
341  nut->header[i] = hdr;
342  }
343  av_assert0(nut->header_len[0] == 0);
344  }
345 
346  // flags had been effectively introduced in version 4
347  if (nut->version > 3 && end > avio_tell(bc) + 4) {
348  nut->flags = ffio_read_varlen(bc);
349  }
350 
351  if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
352  av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n");
354  goto fail;
355  }
356 
357  nut->stream = av_calloc(stream_count, sizeof(StreamContext));
358  if (!nut->stream) {
359  ret = AVERROR(ENOMEM);
360  goto fail;
361  }
362  for (i = 0; i < stream_count; i++) {
363  if (!avformat_new_stream(s, NULL)) {
364  ret = AVERROR(ENOMEM);
365  goto fail;
366  }
367  }
368 
369  return 0;
370 fail:
371  av_freep(&nut->time_base);
372  for (i = 1; i < nut->header_count; i++) {
373  av_freep(&nut->header[i]);
374  }
375  nut->header_count = 0;
376  return ret;
377 }
378 
380 {
381  AVFormatContext *s = nut->avf;
382  AVIOContext *bc = s->pb;
383  StreamContext *stc;
384  int class, stream_id, ret;
385  uint64_t tmp, end;
386  AVStream *st = NULL;
387 
388  end = get_packetheader(nut, bc, 1, STREAM_STARTCODE);
389  end += avio_tell(bc);
390 
391  GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base);
392  stc = &nut->stream[stream_id];
393  st = s->streams[stream_id];
394  if (!st)
395  return AVERROR(ENOMEM);
396 
397  class = ffio_read_varlen(bc);
398  tmp = get_fourcc(bc);
399  st->codecpar->codec_tag = tmp;
400  switch (class) {
401  case 0:
403  st->codecpar->codec_id = av_codec_get_id((const AVCodecTag * const []) {
407  0
408  },
409  tmp);
410  break;
411  case 1:
413  st->codecpar->codec_id = av_codec_get_id((const AVCodecTag * const []) {
417  0
418  },
419  tmp);
420  break;
421  case 2:
424  break;
425  case 3:
428  break;
429  default:
430  av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);
431  return AVERROR(ENOSYS);
432  }
433  if (class < 3 && st->codecpar->codec_id == AV_CODEC_ID_NONE)
435  "Unknown codec tag '0x%04x' for stream number %d\n",
436  (unsigned int) tmp, stream_id);
437 
438  GET_V(stc->time_base_id, tmp < nut->time_base_count);
439  GET_V(stc->msb_pts_shift, tmp < 16);
441  GET_V(stc->decode_delay, tmp < 1000); // sanity limit, raise this if Moore's law is true
442  st->codecpar->video_delay = stc->decode_delay;
443  ffio_read_varlen(bc); // stream flags
444 
445  GET_V(st->codecpar->extradata_size, tmp < (1 << 30));
446  if (st->codecpar->extradata_size) {
447  ret = ff_get_extradata(s, st->codecpar, bc,
448  st->codecpar->extradata_size);
449  if (ret < 0)
450  return ret;
451  }
452 
453  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
454  GET_V(st->codecpar->width, tmp > 0);
455  GET_V(st->codecpar->height, tmp > 0);
458  if ((!st->sample_aspect_ratio.num) != (!st->sample_aspect_ratio.den)) {
459  av_log(s, AV_LOG_ERROR, "invalid aspect ratio %d/%d\n",
462  goto fail;
463  }
464  ffio_read_varlen(bc); /* csp type */
465  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
466  GET_V(st->codecpar->sample_rate, tmp > 0);
467  ffio_read_varlen(bc); // samplerate_den
469  }
470  if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
472  "stream header %d checksum mismatch\n", stream_id);
474  goto fail;
475  }
476  stc->time_base = &nut->time_base[stc->time_base_id];
477  avpriv_set_pts_info(s->streams[stream_id], 63, stc->time_base->num,
478  stc->time_base->den);
479  return 0;
480 fail:
481  if (st && st->codecpar) {
482  av_freep(&st->codecpar->extradata);
483  st->codecpar->extradata_size = 0;
484  }
485  return ret;
486 }
487 
489  int stream_id)
490 {
491  int flag = 0, i;
492 
493  for (i = 0; ff_nut_dispositions[i].flag; ++i)
494  if (!strcmp(ff_nut_dispositions[i].str, value))
496  if (!flag)
497  av_log(avf, AV_LOG_INFO, "unknown disposition type '%s'\n", value);
498  for (i = 0; i < avf->nb_streams; ++i)
499  if (stream_id == i || stream_id == -1)
500  avf->streams[i]->disposition |= flag;
501 }
502 
504 {
505  AVFormatContext *s = nut->avf;
506  AVIOContext *bc = s->pb;
507  uint64_t tmp, chapter_start, chapter_len;
508  unsigned int stream_id_plus1, count;
509  int i, ret = 0;
510  int64_t chapter_id, value, end;
511  char name[256], str_value[1024], type_str[256];
512  const char *type;
513  int *event_flags = NULL;
514  AVChapter *chapter = NULL;
515  AVStream *st = NULL;
516  AVDictionary **metadata = NULL;
517  int metadata_flag = 0;
518 
519  end = get_packetheader(nut, bc, 1, INFO_STARTCODE);
520  end += avio_tell(bc);
521 
522  GET_V(stream_id_plus1, tmp <= s->nb_streams);
523  chapter_id = get_s(bc);
524  chapter_start = ffio_read_varlen(bc);
525  chapter_len = ffio_read_varlen(bc);
526  count = ffio_read_varlen(bc);
527 
528  if (chapter_id && !stream_id_plus1) {
529  int64_t start = chapter_start / nut->time_base_count;
530  chapter = avpriv_new_chapter(s, chapter_id,
531  nut->time_base[chapter_start %
532  nut->time_base_count],
533  start, start + chapter_len, NULL);
534  if (!chapter) {
535  av_log(s, AV_LOG_ERROR, "Could not create chapter.\n");
536  return AVERROR(ENOMEM);
537  }
538  metadata = &chapter->metadata;
539  } else if (stream_id_plus1) {
540  st = s->streams[stream_id_plus1 - 1];
541  metadata = &st->metadata;
542  event_flags = &st->event_flags;
543  metadata_flag = AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
544  } else {
545  metadata = &s->metadata;
546  event_flags = &s->event_flags;
547  metadata_flag = AVFMT_EVENT_FLAG_METADATA_UPDATED;
548  }
549 
550  for (i = 0; i < count; i++) {
551  ret = get_str(bc, name, sizeof(name));
552  if (ret < 0) {
553  av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
554  return ret;
555  }
556  value = get_s(bc);
557  str_value[0] = 0;
558 
559  if (value == -1) {
560  type = "UTF-8";
561  ret = get_str(bc, str_value, sizeof(str_value));
562  } else if (value == -2) {
563  ret = get_str(bc, type_str, sizeof(type_str));
564  if (ret < 0) {
565  av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
566  return ret;
567  }
568  type = type_str;
569  ret = get_str(bc, str_value, sizeof(str_value));
570  } else if (value == -3) {
571  type = "s";
572  value = get_s(bc);
573  } else if (value == -4) {
574  type = "t";
575  value = ffio_read_varlen(bc);
576  } else if (value < -4) {
577  type = "r";
578  get_s(bc);
579  } else {
580  type = "v";
581  }
582 
583  if (ret < 0) {
584  av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
585  return ret;
586  }
587 
588  if (stream_id_plus1 > s->nb_streams) {
590  "invalid stream id %d for info packet\n",
591  stream_id_plus1);
592  continue;
593  }
594 
595  if (!strcmp(type, "UTF-8")) {
596  if (chapter_id == 0 && !strcmp(name, "Disposition")) {
597  set_disposition_bits(s, str_value, stream_id_plus1 - 1);
598  continue;
599  }
600 
601  if (stream_id_plus1 && !strcmp(name, "r_frame_rate")) {
602  sscanf(str_value, "%d/%d", &st->r_frame_rate.num, &st->r_frame_rate.den);
603  if (st->r_frame_rate.num >= 1000LL*st->r_frame_rate.den ||
604  st->r_frame_rate.num < 0 || st->r_frame_rate.den < 0)
605  st->r_frame_rate.num = st->r_frame_rate.den = 0;
606  continue;
607  }
608 
609  if (metadata && av_strcasecmp(name, "Uses") &&
610  av_strcasecmp(name, "Depends") && av_strcasecmp(name, "Replaces")) {
611  if (event_flags)
612  *event_flags |= metadata_flag;
613  av_dict_set(metadata, name, str_value, 0);
614  }
615  }
616  }
617 
618  if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
619  av_log(s, AV_LOG_ERROR, "info header checksum mismatch\n");
620  return AVERROR_INVALIDDATA;
621  }
622 fail:
623  return FFMIN(ret, 0);
624 }
625 
626 static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)
627 {
628  AVFormatContext *s = nut->avf;
629  AVIOContext *bc = s->pb;
630  int64_t end;
631  uint64_t tmp;
632  int ret;
633 
634  nut->last_syncpoint_pos = avio_tell(bc) - 8;
635 
636  end = get_packetheader(nut, bc, 1, SYNCPOINT_STARTCODE);
637  end += avio_tell(bc);
638 
639  tmp = ffio_read_varlen(bc);
640  *back_ptr = nut->last_syncpoint_pos - 16 * ffio_read_varlen(bc);
641  if (*back_ptr < 0)
642  return AVERROR_INVALIDDATA;
643 
644  ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count],
645  tmp / nut->time_base_count);
646 
647  if (nut->flags & NUT_BROADCAST) {
648  tmp = ffio_read_varlen(bc);
649  av_log(s, AV_LOG_VERBOSE, "Syncpoint wallclock %"PRId64"\n",
651  nut->time_base[tmp % nut->time_base_count],
652  AV_TIME_BASE_Q));
653  }
654 
655  if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
656  av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n");
657  return AVERROR_INVALIDDATA;
658  }
659 
660  *ts = tmp / nut->time_base_count *
662 
663  if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, *back_ptr, *ts)) < 0)
664  return ret;
665 
666  return 0;
667 }
668 
669 //FIXME calculate exactly, this is just a good approximation.
670 static int64_t find_duration(NUTContext *nut, int64_t filesize)
671 {
672  AVFormatContext *s = nut->avf;
673  int64_t duration = 0;
674 
676 
677  if(duration > 0)
678  s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
679  return duration;
680 }
681 
683 {
684  AVFormatContext *s = nut->avf;
685  AVIOContext *bc = s->pb;
686  uint64_t tmp, end;
687  int i, j, syncpoint_count;
688  int64_t filesize = avio_size(bc);
689  int64_t *syncpoints = NULL;
690  uint64_t max_pts;
691  int8_t *has_keyframe = NULL;
692  int ret = AVERROR_INVALIDDATA;
693 
694  if(filesize <= 0)
695  return -1;
696 
697  avio_seek(bc, filesize - 12, SEEK_SET);
698  avio_seek(bc, filesize - avio_rb64(bc), SEEK_SET);
699  if (avio_rb64(bc) != INDEX_STARTCODE) {
700  av_log(s, AV_LOG_WARNING, "no index at the end\n");
701 
702  if(s->duration<=0)
703  s->duration = find_duration(nut, filesize);
704  return ret;
705  }
706 
707  end = get_packetheader(nut, bc, 1, INDEX_STARTCODE);
708  end += avio_tell(bc);
709 
710  max_pts = ffio_read_varlen(bc);
711  s->duration = av_rescale_q(max_pts / nut->time_base_count,
712  nut->time_base[max_pts % nut->time_base_count],
714  s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
715 
716  GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0);
717  syncpoints = av_malloc_array(syncpoint_count, sizeof(int64_t));
718  has_keyframe = av_malloc_array(syncpoint_count + 1, sizeof(int8_t));
719  if (!syncpoints || !has_keyframe) {
720  ret = AVERROR(ENOMEM);
721  goto fail;
722  }
723  for (i = 0; i < syncpoint_count; i++) {
724  syncpoints[i] = ffio_read_varlen(bc);
725  if (syncpoints[i] <= 0)
726  goto fail;
727  if (i)
728  syncpoints[i] += syncpoints[i - 1];
729  }
730 
731  for (i = 0; i < s->nb_streams; i++) {
732  int64_t last_pts = -1;
733  for (j = 0; j < syncpoint_count;) {
734  uint64_t x = ffio_read_varlen(bc);
735  int type = x & 1;
736  int n = j;
737  x >>= 1;
738  if (type) {
739  int flag = x & 1;
740  x >>= 1;
741  if (n + x >= syncpoint_count + 1) {
742  av_log(s, AV_LOG_ERROR, "index overflow A %d + %"PRIu64" >= %d\n", n, x, syncpoint_count + 1);
743  goto fail;
744  }
745  while (x--)
746  has_keyframe[n++] = flag;
747  has_keyframe[n++] = !flag;
748  } else {
749  if (x <= 1) {
750  av_log(s, AV_LOG_ERROR, "index: x %"PRIu64" is invalid\n", x);
751  goto fail;
752  }
753  while (x != 1) {
754  if (n >= syncpoint_count + 1) {
755  av_log(s, AV_LOG_ERROR, "index overflow B\n");
756  goto fail;
757  }
758  has_keyframe[n++] = x & 1;
759  x >>= 1;
760  }
761  }
762  if (has_keyframe[0]) {
763  av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");
764  goto fail;
765  }
766  av_assert0(n <= syncpoint_count + 1);
767  for (; j < n && j < syncpoint_count; j++) {
768  if (has_keyframe[j]) {
769  uint64_t B, A = ffio_read_varlen(bc);
770  if (!A) {
771  A = ffio_read_varlen(bc);
772  B = ffio_read_varlen(bc);
773  // eor_pts[j][i] = last_pts + A + B
774  } else
775  B = 0;
776  av_add_index_entry(s->streams[i], 16 * syncpoints[j - 1],
777  last_pts + A, 0, 0, AVINDEX_KEYFRAME);
778  last_pts += A + B;
779  }
780  }
781  }
782  }
783 
784  if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
785  av_log(s, AV_LOG_ERROR, "index checksum mismatch\n");
786  goto fail;
787  }
788  ret = 0;
789 
790 fail:
791  av_free(syncpoints);
792  av_free(has_keyframe);
793  return ret;
794 }
795 
797 {
798  NUTContext *nut = s->priv_data;
799  int i;
800 
801  av_freep(&nut->time_base);
802  av_freep(&nut->stream);
803  ff_nut_free_sp(nut);
804  for (i = 1; i < nut->header_count; i++)
805  av_freep(&nut->header[i]);
806 
807  return 0;
808 }
809 
811 {
812  NUTContext *nut = s->priv_data;
813  AVIOContext *bc = s->pb;
814  int64_t pos;
815  int initialized_stream_count, ret;
816 
817  nut->avf = s;
818 
819  /* main header */
820  pos = 0;
821  ret = 0;
822  do {
823  if (ret == AVERROR(ENOMEM))
824  return ret;
825 
826  pos = find_startcode(bc, MAIN_STARTCODE, pos) + 1;
827  if (pos < 0 + 1) {
828  av_log(s, AV_LOG_ERROR, "No main startcode found.\n");
829  return AVERROR_INVALIDDATA;
830  }
831  } while ((ret = decode_main_header(nut)) < 0);
832 
833  /* stream headers */
834  pos = 0;
835  for (initialized_stream_count = 0; initialized_stream_count < s->nb_streams;) {
837  if (pos < 0 + 1) {
838  av_log(s, AV_LOG_ERROR, "Not all stream headers found.\n");
839  return AVERROR_INVALIDDATA;
840  }
841  if (decode_stream_header(nut) >= 0)
842  initialized_stream_count++;
843  }
844 
845  /* info headers */
846  pos = 0;
847  for (;;) {
848  uint64_t startcode = find_any_startcode(bc, pos);
849  pos = avio_tell(bc);
850 
851  if (startcode == 0) {
852  av_log(s, AV_LOG_ERROR, "EOF before video frames\n");
853  return AVERROR_INVALIDDATA;
854  } else if (startcode == SYNCPOINT_STARTCODE) {
855  nut->next_startcode = startcode;
856  break;
857  } else if (startcode != INFO_STARTCODE) {
858  continue;
859  }
860 
861  decode_info_header(nut);
862  }
863 
865 
866  if (bc->seekable & AVIO_SEEKABLE_NORMAL) {
867  int64_t orig_pos = avio_tell(bc);
869  avio_seek(bc, orig_pos, SEEK_SET);
870  }
872 
874 
875  return 0;
876 }
877 
878 static int read_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta, int64_t maxpos)
879 {
880  int count = ffio_read_varlen(bc);
881  int skip_start = 0;
882  int skip_end = 0;
883  int channels = 0;
884  int64_t channel_layout = 0;
885  int sample_rate = 0;
886  int width = 0;
887  int height = 0;
888  int i, ret;
889 
890  for (i=0; i<count; i++) {
891  uint8_t name[256], str_value[256], type_str[256];
892  int value;
893  if (avio_tell(bc) >= maxpos)
894  return AVERROR_INVALIDDATA;
895  ret = get_str(bc, name, sizeof(name));
896  if (ret < 0) {
897  av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
898  return ret;
899  }
900  value = get_s(bc);
901 
902  if (value == -1) {
903  ret = get_str(bc, str_value, sizeof(str_value));
904  if (ret < 0) {
905  av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
906  return ret;
907  }
908  av_log(s, AV_LOG_WARNING, "Unknown string %s / %s\n", name, str_value);
909  } else if (value == -2) {
910  uint8_t *dst = NULL;
911  int64_t v64, value_len;
912 
913  ret = get_str(bc, type_str, sizeof(type_str));
914  if (ret < 0) {
915  av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
916  return ret;
917  }
918  value_len = ffio_read_varlen(bc);
919  if (value_len < 0 || value_len >= maxpos - avio_tell(bc))
920  return AVERROR_INVALIDDATA;
921  if (!strcmp(name, "Palette")) {
923  } else if (!strcmp(name, "Extradata")) {
925  } else if (sscanf(name, "CodecSpecificSide%"SCNd64"", &v64) == 1) {
927  if(!dst)
928  return AVERROR(ENOMEM);
929  AV_WB64(dst, v64);
930  dst += 8;
931  } else if (!strcmp(name, "ChannelLayout") && value_len == 8) {
932  channel_layout = avio_rl64(bc);
933  continue;
934  } else {
935  av_log(s, AV_LOG_WARNING, "Unknown data %s / %s\n", name, type_str);
936  avio_skip(bc, value_len);
937  continue;
938  }
939  if(!dst)
940  return AVERROR(ENOMEM);
941  avio_read(bc, dst, value_len);
942  } else if (value == -3) {
943  value = get_s(bc);
944  } else if (value == -4) {
945  value = ffio_read_varlen(bc);
946  } else if (value < -4) {
947  get_s(bc);
948  } else {
949  if (!strcmp(name, "SkipStart")) {
950  skip_start = value;
951  } else if (!strcmp(name, "SkipEnd")) {
952  skip_end = value;
953  } else if (!strcmp(name, "Channels")) {
954  channels = value;
955  } else if (!strcmp(name, "SampleRate")) {
956  sample_rate = value;
957  } else if (!strcmp(name, "Width")) {
958  width = value;
959  } else if (!strcmp(name, "Height")) {
960  height = value;
961  } else {
962  av_log(s, AV_LOG_WARNING, "Unknown integer %s\n", name);
963  }
964  }
965  }
966 
967  if (channels || channel_layout || sample_rate || width || height) {
969  if (!dst)
970  return AVERROR(ENOMEM);
971  bytestream_put_le32(&dst,
973  AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT*(!!channels) +
974  AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT*(!!channel_layout) +
975 #endif
978  );
979  if (channels)
980  bytestream_put_le32(&dst, channels);
981  if (channel_layout)
982  bytestream_put_le64(&dst, channel_layout);
983  if (sample_rate)
984  bytestream_put_le32(&dst, sample_rate);
985  if (width || height){
986  bytestream_put_le32(&dst, width);
987  bytestream_put_le32(&dst, height);
988  }
989  }
990 
991  if (skip_start || skip_end) {
993  if (!dst)
994  return AVERROR(ENOMEM);
995  AV_WL32(dst, skip_start);
996  AV_WL32(dst+4, skip_end);
997  }
998 
999  if (avio_tell(bc) >= maxpos)
1000  return AVERROR_INVALIDDATA;
1001 
1002  return 0;
1003 }
1004 
1005 static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id,
1006  uint8_t *header_idx, int frame_code)
1007 {
1008  AVFormatContext *s = nut->avf;
1009  AVIOContext *bc = s->pb;
1010  StreamContext *stc;
1011  int size, flags, size_mul, pts_delta, i, reserved_count, ret;
1012  uint64_t tmp;
1013 
1014  if (!(nut->flags & NUT_PIPE) &&
1015  avio_tell(bc) > nut->last_syncpoint_pos + nut->max_distance) {
1017  "Last frame must have been damaged %"PRId64" > %"PRId64" + %d\n",
1018  avio_tell(bc), nut->last_syncpoint_pos, nut->max_distance);
1019  return AVERROR_INVALIDDATA;
1020  }
1021 
1022  flags = nut->frame_code[frame_code].flags;
1023  size_mul = nut->frame_code[frame_code].size_mul;
1024  size = nut->frame_code[frame_code].size_lsb;
1025  *stream_id = nut->frame_code[frame_code].stream_id;
1026  pts_delta = nut->frame_code[frame_code].pts_delta;
1027  reserved_count = nut->frame_code[frame_code].reserved_count;
1028  *header_idx = nut->frame_code[frame_code].header_idx;
1029 
1030  if (flags & FLAG_INVALID)
1031  return AVERROR_INVALIDDATA;
1032  if (flags & FLAG_CODED)
1033  flags ^= ffio_read_varlen(bc);
1034  if (flags & FLAG_STREAM_ID) {
1035  GET_V(*stream_id, tmp < s->nb_streams);
1036  }
1037  stc = &nut->stream[*stream_id];
1038  if (flags & FLAG_CODED_PTS) {
1039  int64_t coded_pts = ffio_read_varlen(bc);
1040  // FIXME check last_pts validity?
1041  if (coded_pts < (1LL << stc->msb_pts_shift)) {
1042  *pts = ff_lsb2full(stc, coded_pts);
1043  } else
1044  *pts = coded_pts - (1LL << stc->msb_pts_shift);
1045  } else
1046  *pts = stc->last_pts + pts_delta;
1047  if (flags & FLAG_SIZE_MSB)
1048  size += size_mul * ffio_read_varlen(bc);
1049  if (flags & FLAG_MATCH_TIME)
1050  get_s(bc);
1051  if (flags & FLAG_HEADER_IDX)
1052  *header_idx = ffio_read_varlen(bc);
1053  if (flags & FLAG_RESERVED)
1054  reserved_count = ffio_read_varlen(bc);
1055  for (i = 0; i < reserved_count; i++) {
1056  if (bc->eof_reached) {
1057  av_log(s, AV_LOG_ERROR, "reached EOF while decoding frame header\n");
1058  return AVERROR_INVALIDDATA;
1059  }
1060  ffio_read_varlen(bc);
1061  }
1062 
1063  if (*header_idx >= (unsigned)nut->header_count) {
1064  av_log(s, AV_LOG_ERROR, "header_idx invalid\n");
1065  return AVERROR_INVALIDDATA;
1066  }
1067  if (size > 4096)
1068  *header_idx = 0;
1069  size -= nut->header_len[*header_idx];
1070 
1071  if (flags & FLAG_CHECKSUM) {
1072  avio_rb32(bc); // FIXME check this
1073  } else if (!(nut->flags & NUT_PIPE) &&
1074  size > 2 * nut->max_distance ||
1075  FFABS(stc->last_pts - *pts) > stc->max_pts_distance) {
1076  av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");
1077  return AVERROR_INVALIDDATA;
1078  }
1079 
1080  stc->last_pts = *pts;
1081  stc->last_flags = flags;
1082 
1083  return size;
1084 fail:
1085  return ret;
1086 }
1087 
1088 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)
1089 {
1090  AVFormatContext *s = nut->avf;
1091  AVIOContext *bc = s->pb;
1092  int size, stream_id, discard, ret;
1093  int64_t pts, last_IP_pts;
1094  StreamContext *stc;
1095  uint8_t header_idx;
1096 
1097  size = decode_frame_header(nut, &pts, &stream_id, &header_idx, frame_code);
1098  if (size < 0)
1099  return size;
1100 
1101  stc = &nut->stream[stream_id];
1102 
1103  if (stc->last_flags & FLAG_KEY)
1104  stc->skip_until_key_frame = 0;
1105 
1106  discard = s->streams[stream_id]->discard;
1107  last_IP_pts = ffstream(s->streams[stream_id])->last_IP_pts;
1108  if ((discard >= AVDISCARD_NONKEY && !(stc->last_flags & FLAG_KEY)) ||
1109  (discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE &&
1110  last_IP_pts > pts) ||
1111  discard >= AVDISCARD_ALL ||
1112  stc->skip_until_key_frame) {
1113  avio_skip(bc, size);
1114  return 1;
1115  }
1116 
1117  ret = av_new_packet(pkt, size + nut->header_len[header_idx]);
1118  if (ret < 0)
1119  return ret;
1120  if (nut->header[header_idx])
1121  memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
1122  pkt->pos = avio_tell(bc); // FIXME
1123  if (stc->last_flags & FLAG_SM_DATA) {
1124  int sm_size;
1125  if (read_sm_data(s, bc, pkt, 0, pkt->pos + size) < 0) {
1127  goto fail;
1128  }
1129  if (read_sm_data(s, bc, pkt, 1, pkt->pos + size) < 0) {
1131  goto fail;
1132  }
1133  sm_size = avio_tell(bc) - pkt->pos;
1134  size -= sm_size;
1135  }
1136 
1137  ret = avio_read(bc, pkt->data + nut->header_len[header_idx], size);
1138  if (ret != size) {
1139  if (ret < 0)
1140  goto fail;
1141  }
1142  av_shrink_packet(pkt, nut->header_len[header_idx] + ret);
1143 
1144  pkt->stream_index = stream_id;
1145  if (stc->last_flags & FLAG_KEY)
1147  pkt->pts = pts;
1148 
1149  return 0;
1150 fail:
1152  return ret;
1153 }
1154 
1156 {
1157  NUTContext *nut = s->priv_data;
1158  AVIOContext *bc = s->pb;
1159  int i, frame_code = 0, ret, skip;
1160  int64_t ts, back_ptr;
1161 
1162  for (;;) {
1163  int64_t pos = avio_tell(bc);
1164  uint64_t tmp = nut->next_startcode;
1165  nut->next_startcode = 0;
1166 
1167  if (tmp) {
1168  pos -= 8;
1169  } else {
1170  frame_code = avio_r8(bc);
1171  if (avio_feof(bc))
1172  return AVERROR_EOF;
1173  if (frame_code == 'N') {
1174  tmp = frame_code;
1175  for (i = 1; i < 8; i++)
1176  tmp = (tmp << 8) + avio_r8(bc);
1177  }
1178  }
1179  switch (tmp) {
1180  case MAIN_STARTCODE:
1181  case STREAM_STARTCODE:
1182  case INDEX_STARTCODE:
1183  skip = get_packetheader(nut, bc, 0, tmp);
1184  avio_skip(bc, skip);
1185  break;
1186  case INFO_STARTCODE:
1187  if (decode_info_header(nut) < 0)
1188  goto resync;
1189  break;
1190  case SYNCPOINT_STARTCODE:
1191  if (decode_syncpoint(nut, &ts, &back_ptr) < 0)
1192  goto resync;
1193  frame_code = avio_r8(bc);
1194  case 0:
1195  ret = decode_frame(nut, pkt, frame_code);
1196  if (ret == 0)
1197  return 0;
1198  else if (ret == 1) // OK but discard packet
1199  break;
1200  default:
1201 resync:
1202  av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);
1204  nut->last_resync_pos = avio_tell(bc);
1205  if (tmp == 0)
1206  return AVERROR_INVALIDDATA;
1207  av_log(s, AV_LOG_DEBUG, "sync\n");
1208  nut->next_startcode = tmp;
1209  }
1210  }
1211 }
1212 
1213 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,
1214  int64_t *pos_arg, int64_t pos_limit)
1215 {
1216  NUTContext *nut = s->priv_data;
1217  AVIOContext *bc = s->pb;
1218  int64_t pos, pts, back_ptr;
1219  av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n",
1220  stream_index, *pos_arg, pos_limit);
1221 
1222  pos = *pos_arg;
1223  do {
1225  if (pos < 1) {
1226  av_log(s, AV_LOG_ERROR, "read_timestamp failed.\n");
1227  return AV_NOPTS_VALUE;
1228  }
1229  } while (decode_syncpoint(nut, &pts, &back_ptr) < 0);
1230  *pos_arg = pos - 1;
1231  av_assert0(nut->last_syncpoint_pos == *pos_arg);
1232 
1233  av_log(s, AV_LOG_DEBUG, "return %"PRId64" %"PRId64"\n", pts, back_ptr);
1234  if (stream_index == -2)
1235  return back_ptr;
1236  av_assert0(stream_index == -1);
1237  return pts;
1238 }
1239 
1240 static int read_seek(AVFormatContext *s, int stream_index,
1241  int64_t pts, int flags)
1242 {
1243  NUTContext *nut = s->priv_data;
1244  AVStream *st = s->streams[stream_index];
1245  FFStream *const sti = ffstream(st);
1246  Syncpoint dummy = { .ts = pts * av_q2d(st->time_base) * AV_TIME_BASE };
1247  Syncpoint nopts_sp = { .ts = AV_NOPTS_VALUE, .back_ptr = AV_NOPTS_VALUE };
1248  Syncpoint *sp, *next_node[2] = { &nopts_sp, &nopts_sp };
1249  int64_t pos, pos2, ts;
1250  int i;
1251 
1252  if (nut->flags & NUT_PIPE) {
1253  return AVERROR(ENOSYS);
1254  }
1255 
1256  if (sti->index_entries) {
1258  if (index < 0)
1260  if (index < 0)
1261  return -1;
1262 
1263  pos2 = sti->index_entries[index].pos;
1264  ts = sti->index_entries[index].timestamp;
1265  } else {
1267  (void **) next_node);
1268  av_log(s, AV_LOG_DEBUG, "%"PRIu64"-%"PRIu64" %"PRId64"-%"PRId64"\n",
1269  next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,
1270  next_node[1]->ts);
1271  pos = ff_gen_search(s, -1, dummy.ts, next_node[0]->pos,
1272  next_node[1]->pos, next_node[1]->pos,
1273  next_node[0]->ts, next_node[1]->ts,
1275  if (pos < 0)
1276  return pos;
1277 
1278  if (!(flags & AVSEEK_FLAG_BACKWARD)) {
1279  dummy.pos = pos + 16;
1280  next_node[1] = &nopts_sp;
1282  (void **) next_node);
1283  pos2 = ff_gen_search(s, -2, dummy.pos, next_node[0]->pos,
1284  next_node[1]->pos, next_node[1]->pos,
1285  next_node[0]->back_ptr, next_node[1]->back_ptr,
1286  flags, &ts, nut_read_timestamp);
1287  if (pos2 >= 0)
1288  pos = pos2;
1289  // FIXME dir but I think it does not matter
1290  }
1291  dummy.pos = pos;
1293  NULL);
1294 
1295  av_assert0(sp);
1296  pos2 = sp->back_ptr - 15;
1297  }
1298  av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos2);
1299  pos = find_startcode(s->pb, SYNCPOINT_STARTCODE, pos2);
1300  avio_seek(s->pb, pos, SEEK_SET);
1301  nut->last_syncpoint_pos = pos;
1302  av_log(s, AV_LOG_DEBUG, "SP: %"PRId64"\n", pos);
1303  if (pos2 > pos || pos2 + 15 < pos)
1304  av_log(s, AV_LOG_ERROR, "no syncpoint at backptr pos\n");
1305  for (i = 0; i < s->nb_streams; i++)
1306  nut->stream[i].skip_until_key_frame = 1;
1307 
1308  nut->last_resync_pos = 0;
1309 
1310  return 0;
1311 }
1312 
1314  .name = "nut",
1315  .long_name = NULL_IF_CONFIG_SMALL("NUT"),
1316  .flags = AVFMT_SEEK_TO_PTS,
1317  .priv_data_size = sizeof(NUTContext),
1318  .flags_internal = FF_FMT_INIT_CLEANUP,
1319  .read_probe = nut_probe,
1323  .read_seek = read_seek,
1324  .extensions = "nut",
1325  .codec_tag = ff_nut_codec_tags,
1326 };
avpriv_new_chapter
AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: demux_utils.c:42
ff_gen_search
int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Perform a binary search using read_timestamp().
Definition: seek.c:393
A
#define A(x)
Definition: vpx_arith.h:28
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
nut_read_close
static int nut_read_close(AVFormatContext *s)
Definition: nutdec.c:796
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_codec_get_id
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:75
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_nut_audio_extra_tags
const AVCodecTag ff_nut_audio_extra_tags[]
Definition: nut.c:211
FrameCode::stream_id
uint8_t stream_id
Definition: nut.h:67
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:47
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1179
NUT_PIPE
#define NUT_PIPE
Definition: nut.h:114
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:237
decode_frame
static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)
Definition: nutdec.c:1088
StreamContext::last_flags
int last_flags
Definition: nut.h:76
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
NUTContext::time_base_count
unsigned int time_base_count
Definition: nut.h:103
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
last_pts
static int64_t last_pts
Definition: filtering_video.c:52
NUT_MAX_VERSION
#define NUT_MAX_VERSION
Definition: nut.h:39
NUTContext::minor_version
int minor_version
Definition: nut.h:117
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:73
FFStream::last_IP_pts
int64_t last_IP_pts
Definition: internal.h:377
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:191
NUTContext::max_distance
unsigned int max_distance
Definition: nut.h:102
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
nut_read_packet
static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nutdec.c:1155
ff_find_last_ts
int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:355
ff_nut_data_tags
const AVCodecTag ff_nut_data_tags[]
Definition: nut.c:38
SYNCPOINT_STARTCODE
#define SYNCPOINT_STARTCODE
Definition: nut.h:31
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:218
FLAG_RESERVED
@ FLAG_RESERVED
Definition: nut.h:50
STREAM_STARTCODE
#define STREAM_STARTCODE
Definition: nut.h:30
av_be2ne64
#define av_be2ne64(x)
Definition: bswap.h:96
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1284
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_nut_dispositions
const Dispositions ff_nut_dispositions[]
Definition: nut.c:324
NUTContext::last_syncpoint_pos
int64_t last_syncpoint_pos
Definition: nut.h:104
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
NUTContext::header_len
uint8_t header_len[128]
Definition: nut.h:97
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:458
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:511
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:65
find_any_startcode
static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)
Definition: nutdec.c:110
StreamContext::decode_delay
int decode_delay
Definition: nut.h:83
mathematics.h
ff_nut_reset_ts
void ff_nut_reset_ts(NUTContext *nut, AVRational time_base, int64_t val)
Definition: nut.c:255
AVDictionary
Definition: dict.c:31
FrameCode::size_lsb
uint16_t size_lsb
Definition: nut.h:69
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
nut_probe
static int nut_probe(const AVProbeData *p)
Definition: nutdec.c:153
Syncpoint
Definition: nut.h:58
read_sm_data
static int read_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta, int64_t maxpos)
Definition: nutdec.c:878
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
get_fourcc
static uint64_t get_fourcc(AVIOContext *bc)
Definition: nutdec.c:76
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:612
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
NUTContext::last_resync_pos
int64_t last_resync_pos
Definition: nut.h:105
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:815
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:355
ff_nut_sp_pos_cmp
int ff_nut_sp_pos_cmp(const void *a, const void *b)
Definition: nut.c:273
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
ff_nut_free_sp
void ff_nut_free_sp(NUTContext *nut)
Definition: nut.c:316
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:763
get_s
static int64_t get_s(AVIOContext *bc)
Definition: nutdec.c:66
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:413
AVFMT_SEEK_TO_PTS
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:503
fail
#define fail()
Definition: checkasm.h:133
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:120
dummy
int dummy
Definition: motion.c:65
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
NUTContext::avf
AVFormatContext * avf
Definition: nut.h:93
AVChapter
Definition: avformat.h:1175
AVFMT_DURATION_FROM_PTS
@ AVFMT_DURATION_FROM_PTS
Duration accurately estimated from PTSes.
Definition: avformat.h:1197
skip_reserved
static int skip_reserved(AVIOContext *bc, int64_t pos)
Definition: nutdec.c:177
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:654
NUTContext::header
const uint8_t * header[128]
Definition: nut.h:98
NUT_MAX_STREAMS
#define NUT_MAX_STREAMS
Definition: nutdec.c:37
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
Syncpoint::ts
int64_t ts
Definition: nut.h:62
AVRational::num
int num
Numerator.
Definition: rational.h:59
NUTContext::header_count
int header_count
Definition: nut.h:106
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
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
NUTContext
Definition: nut.h:91
AVInputFormat
Definition: avformat.h:656
AVCodecTag
Definition: internal.h:49
duration
int64_t duration
Definition: movenc.c:64
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:459
width
#define width
intreadwrite.h
ff_nut_metadata_conv
const AVMetadataConv ff_nut_metadata_conv[]
Definition: nut.c:334
s
#define s(width, name)
Definition: cbs_vp9.c:256
nut.h
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
FrameCode::reserved_count
uint8_t reserved_count
Definition: nut.h:71
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
get_str
static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)
Definition: nutdec.c:42
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:127
NUTContext::time_base
AVRational * time_base
Definition: nut.h:107
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
find_startcode
static int64_t find_startcode(AVIOContext *bc, uint64_t code, int64_t pos)
Find the given startcode.
Definition: nutdec.c:141
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:809
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
nut_read_timestamp
static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit)
Definition: nutdec.c:1213
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:108
StreamContext::last_pts
int64_t last_pts
Definition: nut.h:78
channels
channels
Definition: aptx.h:31
nb_streams
static int nb_streams
Definition: ffprobe.c:308
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FrameCode::size_mul
uint16_t size_mul
Definition: nut.h:68
FLAG_INVALID
@ FLAG_INVALID
Definition: nut.h:55
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:73
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
GET_V
#define GET_V(dst, check)
Definition: nutdec.c:166
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:76
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
ff_metadata_conv_ctx
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2292
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
Dispositions::flag
int flag
Definition: nut.h:130
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
NUT_BROADCAST
#define NUT_BROADCAST
Definition: nut.h:113
isom.h
ff_nut_sp_pts_cmp
int ff_nut_sp_pts_cmp(const void *a, const void *b)
Definition: nut.c:279
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
state
static struct @336 state
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:937
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1019
read_seek
static int read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
Definition: nutdec.c:1240
ff_nut_video_tags
const AVCodecTag ff_nut_video_tags[]
Definition: nut.c:43
ff_codec_movvideo_tags
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
FLAG_MATCH_TIME
@ FLAG_MATCH_TIME
Definition: nut.h:53
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1081
index
int index
Definition: gxfenc.c:89
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
FLAG_CODED
@ FLAG_CODED
Definition: nut.h:54
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:79
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1272
StreamContext
Definition: transcoding.c:51
decode_main_header
static int decode_main_header(NUTContext *nut)
Definition: nutdec.c:193
StreamContext::time_base_id
int time_base_id
Definition: nut.h:79
FLAG_SIZE_MSB
@ FLAG_SIZE_MSB
Definition: nut.h:48
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:75
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
ff_nut_demuxer
const AVInputFormat ff_nut_demuxer
Definition: nutdec.c:1313
FrameCode::pts_delta
int16_t pts_delta
Definition: nut.h:70
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:115
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:144
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:263
FFStream
Definition: internal.h:196
FF_API_OLD_CHANNEL_LAYOUT
#define FF_API_OLD_CHANNEL_LAYOUT
Definition: version.h:115
sp
#define sp
Definition: regdef.h:63
NUTContext::flags
int flags
Definition: nut.h:115
ff_nut_audio_tags
const AVCodecTag ff_nut_audio_tags[]
Definition: nut.c:221
size
int size
Definition: twinvq_data.h:10344
NUTContext::stream
StreamContext * stream
Definition: nut.h:100
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:1074
FrameCode::flags
uint16_t flags
Definition: nut.h:66
ffio_init_checksum
void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)
Definition: aviobuf.c:620
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:1017
tree.h
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
height
#define height
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
ffio_read_varlen
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:945
NUTContext::version
int version
Definition: nut.h:116
StreamContext::msb_pts_shift
int msb_pts_shift
Definition: nut.h:81
ff_crc04C11DB7_update
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:594
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:77
flag
#define flag(name)
Definition: cbs_av1.c:553
ff_nut_add_sp
int ff_nut_add_sp(NUTContext *nut, int64_t pos, int64_t back_ptr, int64_t ts)
Definition: nut.c:285
NUTContext::syncpoints
struct AVTreeNode * syncpoints
Definition: nut.h:108
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
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
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
avio_internal.h
ff_lsb2full
int64_t ff_lsb2full(StreamContext *stream, int64_t lsb)
Definition: nut.c:266
NUTContext::next_startcode
uint64_t next_startcode
Definition: nut.h:99
find_and_decode_index
static int find_and_decode_index(NUTContext *nut)
Definition: nutdec.c:682
AVCodecParameters::height
int height
Definition: codec_par.h:128
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
resync
static int resync(AVFormatContext *s)
Definition: flvdec.c:973
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
StreamContext::skip_until_key_frame
int skip_until_key_frame
Definition: nut.h:77
get_packetheader
static int get_packetheader(NUTContext *nut, AVIOContext *bc, int calculate_checksum, uint64_t startcode)
Definition: nutdec.c:90
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
demux.h
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
len
int len
Definition: vorbis_enc_data.h:426
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
NUTContext::frame_code
FrameCode frame_code[256]
Definition: nut.h:96
FLAG_SM_DATA
@ FLAG_SM_DATA
Definition: nut.h:51
decode_frame_header
static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, uint8_t *header_idx, int frame_code)
Definition: nutdec.c:1005
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:1008
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:948
bswap.h
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
FLAG_STREAM_ID
@ FLAG_STREAM_ID
Definition: nut.h:47
decode_syncpoint
static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)
Definition: nutdec.c:626
pos
unsigned int pos
Definition: spdifenc.c:412
dict.h
FrameCode::header_idx
uint8_t header_idx
Definition: nut.h:72
set_disposition_bits
static void set_disposition_bits(AVFormatContext *avf, char *value, int stream_id)
Definition: nutdec.c:488
U
#define U(x)
Definition: vpx_arith.h:37
FLAG_CHECKSUM
@ FLAG_CHECKSUM
Definition: nut.h:49
FLAG_KEY
@ FLAG_KEY
Definition: nut.h:44
B
#define B
Definition: huffyuvdsp.h:32
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:36
ff_nut_codec_tags
const AVCodecTag *const ff_nut_codec_tags[]
Definition: nut.c:250
FLAG_HEADER_IDX
@ FLAG_HEADER_IDX
Definition: nut.h:52
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:230
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVRational::den
int den
Denominator.
Definition: rational.h:60
nut_read_header
static int nut_read_header(AVFormatContext *s)
Definition: nutdec.c:810
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1097
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:808
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:240
AVPacket::stream_index
int stream_index
Definition: packet.h:376
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
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:251
NUT_MIN_VERSION
#define NUT_MIN_VERSION
Definition: nut.h:41
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:192
ff_nut_subtitle_tags
const AVCodecTag ff_nut_subtitle_tags[]
Definition: nut.c:28
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:156
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FLAG_CODED_PTS
@ FLAG_CODED_PTS
Definition: nut.h:46
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
decode_stream_header
static int decode_stream_header(NUTContext *nut)
Definition: nutdec.c:379
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:71
riff.h
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:767
INDEX_STARTCODE
#define INDEX_STARTCODE
Definition: nut.h:32
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
avstring.h
StreamContext::time_base
AVRational time_base
Definition: signature.h:103
find_duration
static int64_t find_duration(NUTContext *nut, int64_t filesize)
Definition: nutdec.c:670
INFO_STARTCODE
#define INFO_STARTCODE
Definition: nut.h:33
MAIN_STARTCODE
#define MAIN_STARTCODE
Definition: nut.h:29
StreamContext::max_pts_distance
int max_pts_distance
Definition: nut.h:82
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1533
decode_info_header
static int decode_info_header(NUTContext *nut)
Definition: nutdec.c:503
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:240
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375