FFmpeg
nutenc.c
Go to the documentation of this file.
1 /*
2  * nut muxer
3  * Copyright (c) 2004-2007 Michael Niedermayer
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/tree.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/time.h"
31 #include "libavutil/opt.h"
32 #include "libavcodec/bytestream.h"
34 #include "mux.h"
35 #include "nut.h"
36 #include "internal.h"
37 #include "avio_internal.h"
38 #include "riff.h"
39 #include "version.h"
40 
41 /**
42  * Chooses a timebase for muxing the specified stream.
43  *
44  * The chosen timebase allows sample accurate timestamps based
45  * on the framerate or sample rate for audio streams. It also is
46  * at least as precise as 1/min_precision would be.
47  */
48 static AVRational choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
49 {
50  AVRational q = st->time_base;
51 
52  for (int j = 2; j < 14; j += 1 + (j > 2))
53  while (q.den / q.num < min_precision && q.num % j == 0)
54  q.num /= j;
55  while (q.den / q.num < min_precision && q.den < (1<<24))
56  q.den <<= 1;
57 
58  return q;
59 }
60 
61 static int find_expected_header(AVCodecParameters *p, int size, int key_frame,
62  uint8_t out[64])
63 {
64  int sample_rate = p->sample_rate;
65 
66  if (size > 4096)
67  return 0;
68 
69  AV_WB24(out, 1);
70 
71  if (p->codec_id == AV_CODEC_ID_MPEG4) {
72  if (key_frame) {
73  return 3;
74  } else {
75  out[3] = 0xB6;
76  return 4;
77  }
78  } else if (p->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
80  return 3;
81  } else if (p->codec_id == AV_CODEC_ID_H264) {
82  return 3;
83  } else if (p->codec_id == AV_CODEC_ID_MP3 ||
84  p->codec_id == AV_CODEC_ID_MP2) {
85  int lsf, mpeg25, sample_rate_index, bitrate_index, frame_size;
86  int layer = p->codec_id == AV_CODEC_ID_MP3 ? 3 : 2;
87  unsigned int header = 0xFFF00000;
88 
89  lsf = sample_rate < (24000 + 32000) / 2;
90  mpeg25 = sample_rate < (12000 + 16000) / 2;
91  sample_rate <<= lsf + mpeg25;
92  if (sample_rate < (32000 + 44100) / 2) sample_rate_index = 2;
93  else if (sample_rate < (44100 + 48000) / 2) sample_rate_index = 0;
94  else sample_rate_index = 1;
95 
96  sample_rate = ff_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25);
97 
98  for (bitrate_index = 2; bitrate_index < 30; bitrate_index++) {
99  frame_size =
100  ff_mpa_bitrate_tab[lsf][layer - 1][bitrate_index >> 1];
101  frame_size = (frame_size * 144000) / (sample_rate << lsf) +
102  (bitrate_index & 1);
103 
104  if (frame_size == size)
105  break;
106  }
107 
108  header |= (!lsf) << 19;
109  header |= (4 - layer) << 17;
110  header |= 1 << 16; //no crc
111  AV_WB32(out, header);
112  if (size <= 0)
113  return 2; //we guess there is no crc, if there is one the user clearly does not care about overhead
114  if (bitrate_index == 30)
115  return -1; //something is wrong ...
116 
117  header |= (bitrate_index >> 1) << 12;
118  header |= sample_rate_index << 10;
119  header |= (bitrate_index & 1) << 9;
120 
121  return 2; //FIXME actually put the needed ones in build_elision_headers()
122  //return 3; //we guess that the private bit is not set
123 //FIXME the above assumptions should be checked, if these turn out false too often something should be done
124  }
125  return 0;
126 }
127 
129  int frame_type)
130 {
131  NUTContext *nut = s->priv_data;
132  uint8_t out[64];
133  int i;
135 
136  for (i = 1; i < nut->header_count; i++) {
137  if (len == nut->header_len[i] && !memcmp(out, nut->header[i], len)) {
138  return i;
139  }
140  }
141 
142  return 0;
143 }
144 
146 {
147  NUTContext *nut = s->priv_data;
148  int i;
149  //FIXME this is lame
150  //FIXME write a 2pass mode to find the maximal headers
151  static const uint8_t headers[][5] = {
152  { 3, 0x00, 0x00, 0x01 },
153  { 4, 0x00, 0x00, 0x01, 0xB6},
154  { 2, 0xFF, 0xFA }, //mp3+crc
155  { 2, 0xFF, 0xFB }, //mp3
156  { 2, 0xFF, 0xFC }, //mp2+crc
157  { 2, 0xFF, 0xFD }, //mp2
158  };
159 
160  nut->header_count = 7;
161  for (i = 1; i < nut->header_count; i++) {
162  nut->header_len[i] = headers[i - 1][0];
163  nut->header[i] = &headers[i - 1][1];
164  }
165 }
166 
168 {
169  NUTContext *nut = s->priv_data;
170  int key_frame, index, pred, stream_id;
171  int start = 1;
172  int end = 254;
173  int keyframe_0_esc = s->nb_streams > 2;
174  int pred_table[10];
175  FrameCode *ft;
176 
177  ft = &nut->frame_code[start];
178  ft->flags = FLAG_CODED;
179  ft->size_mul = 1;
180  ft->pts_delta = 1;
181  start++;
182 
183  if (keyframe_0_esc) {
184  /* keyframe = 0 escape */
185  FrameCode *ft = &nut->frame_code[start];
187  ft->size_mul = 1;
188  start++;
189  }
190 
191  for (stream_id = 0; stream_id < s->nb_streams; stream_id++) {
192  int start2 = start + (end - start) * stream_id / s->nb_streams;
193  int end2 = start + (end - start) * (stream_id + 1) / s->nb_streams;
194  AVCodecParameters *par = s->streams[stream_id]->codecpar;
195  int is_audio = par->codec_type == AVMEDIA_TYPE_AUDIO;
196  int intra_only = /*codec->intra_only || */ is_audio;
197  int pred_count;
198  int frame_size = 0;
199 
200  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
202  if (par->codec_id == AV_CODEC_ID_VORBIS && !frame_size)
203  frame_size = 64;
204  } else {
205  AVRational f = av_div_q(av_inv_q(s->streams[stream_id]->avg_frame_rate), *nut->stream[stream_id].time_base);
206  if (f.den == 1 && f.num>0)
207  frame_size = f.num;
208  }
209  if (!frame_size)
210  frame_size = 1;
211 
212  for (key_frame = 0; key_frame < 2; key_frame++) {
213  if (!intra_only || !keyframe_0_esc || key_frame != 0) {
214  FrameCode *ft = &nut->frame_code[start2];
215  ft->flags = FLAG_KEY * key_frame;
217  ft->stream_id = stream_id;
218  ft->size_mul = 1;
219  if (is_audio)
220  ft->header_idx = find_header_idx(s, par, -1, key_frame);
221  start2++;
222  }
223  }
224 
225  key_frame = intra_only;
226 #if 1
227  if (is_audio) {
228  int frame_bytes;
229  int pts;
230 
231  if (par->block_align > 0) {
232  frame_bytes = par->block_align;
233  } else {
235  frame_bytes = frame_size * (int64_t)par->bit_rate / (8 * par->sample_rate);
236  }
237 
238  for (pts = 0; pts < 2; pts++) {
239  for (pred = 0; pred < 2; pred++) {
240  FrameCode *ft = &nut->frame_code[start2];
241  ft->flags = FLAG_KEY * key_frame;
242  ft->stream_id = stream_id;
243  ft->size_mul = frame_bytes + 2;
244  ft->size_lsb = frame_bytes + pred;
245  ft->pts_delta = pts * frame_size;
246  ft->header_idx = find_header_idx(s, par, frame_bytes + pred, key_frame);
247  start2++;
248  }
249  }
250  } else {
251  FrameCode *ft = &nut->frame_code[start2];
252  ft->flags = FLAG_KEY | FLAG_SIZE_MSB;
253  ft->stream_id = stream_id;
254  ft->size_mul = 1;
255  ft->pts_delta = frame_size;
256  start2++;
257  }
258 #endif
259 
260  if (par->video_delay) {
261  pred_count = 5;
262  pred_table[0] = -2;
263  pred_table[1] = -1;
264  pred_table[2] = 1;
265  pred_table[3] = 3;
266  pred_table[4] = 4;
267  } else if (par->codec_id == AV_CODEC_ID_VORBIS) {
268  pred_count = 3;
269  pred_table[0] = 2;
270  pred_table[1] = 9;
271  pred_table[2] = 16;
272  } else {
273  pred_count = 1;
274  pred_table[0] = 1;
275  }
276 
277  for (pred = 0; pred < pred_count; pred++) {
278  int start3 = start2 + (end2 - start2) * pred / pred_count;
279  int end3 = start2 + (end2 - start2) * (pred + 1) / pred_count;
280 
281  pred_table[pred] *= frame_size;
282 
283  for (index = start3; index < end3; index++) {
284  FrameCode *ft = &nut->frame_code[index];
285  ft->flags = FLAG_KEY * key_frame;
286  ft->flags |= FLAG_SIZE_MSB;
287  ft->stream_id = stream_id;
288 //FIXME use single byte size and pred from last
289  ft->size_mul = end3 - start3;
290  ft->size_lsb = index - start3;
291  ft->pts_delta = pred_table[pred];
292  if (is_audio)
293  ft->header_idx = find_header_idx(s, par, -1, key_frame);
294  }
295  }
296  }
297  memmove(&nut->frame_code['N' + 1], &nut->frame_code['N'], sizeof(FrameCode) * (255 - 'N'));
298  nut->frame_code[0].flags =
299  nut->frame_code[255].flags =
300  nut->frame_code['N'].flags = FLAG_INVALID;
301 }
302 
303 /**
304  * Get the length in bytes which is needed to store val as v.
305  */
306 static int get_v_length(uint64_t val)
307 {
308  int i = 1;
309 
310  while (val >>= 7)
311  i++;
312 
313  return i;
314 }
315 
316 /**
317  * Put val using a variable number of bytes.
318  */
319 static void put_v(AVIOContext *bc, uint64_t val)
320 {
321  int i = get_v_length(val);
322 
323  while (--i > 0)
324  avio_w8(bc, 128 | (uint8_t)(val >> (7*i)));
325 
326  avio_w8(bc, val & 127);
327 }
328 
329 static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val)
330 {
331  val *= nut->time_base_count;
332  val += time_base - nut->time_base;
333  put_v(bc, val);
334 }
335 /**
336  * Store a string as vb.
337  */
338 static void put_str(AVIOContext *bc, const char *string)
339 {
340  size_t len = strlen(string);
341 
342  put_v(bc, len);
343  avio_write(bc, string, len);
344 }
345 
346 static void put_s(AVIOContext *bc, int64_t val)
347 {
348  put_v(bc, 2 * FFABS(val) - (val > 0));
349 }
350 
351 static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc,
352  uint64_t startcode)
353 {
354  uint8_t *dyn_buf = NULL;
355  int dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
356  int forw_ptr = dyn_size + 4;
357 
358  if (forw_ptr > 4096)
360  avio_wb64(bc, startcode);
361  put_v(bc, forw_ptr);
362  if (forw_ptr > 4096)
363  avio_wl32(bc, ffio_get_checksum(bc));
364 
366  avio_write(bc, dyn_buf, dyn_size);
367  avio_wl32(bc, ffio_get_checksum(bc));
368 
369  ffio_reset_dyn_buf(dyn_bc);
370 }
371 
373 {
374  int i, j, tmp_pts, tmp_flags, tmp_stream, tmp_mul, tmp_size, tmp_fields,
375  tmp_head_idx;
376  int64_t tmp_match;
377 
378  put_v(bc, nut->version);
379  if (nut->version > 3)
380  put_v(bc, nut->minor_version = 1);
381  put_v(bc, nut->avf->nb_streams);
382  put_v(bc, nut->max_distance);
383  put_v(bc, nut->time_base_count);
384 
385  for (i = 0; i < nut->time_base_count; i++) {
386  put_v(bc, nut->time_base[i].num);
387  put_v(bc, nut->time_base[i].den);
388  }
389 
390  tmp_pts = 0;
391  tmp_mul = 1;
392  tmp_stream = 0;
393  tmp_match = 1 - (1LL << 62);
394  tmp_head_idx = 0;
395  for (i = 0; i < 256; ) {
396  tmp_fields = 0;
397  tmp_size = 0;
398 // tmp_res=0;
399  if (tmp_pts != nut->frame_code[i].pts_delta ) tmp_fields = 1;
400  if (tmp_mul != nut->frame_code[i].size_mul ) tmp_fields = 2;
401  if (tmp_stream != nut->frame_code[i].stream_id ) tmp_fields = 3;
402  if (tmp_size != nut->frame_code[i].size_lsb ) tmp_fields = 4;
403 // if (tmp_res != nut->frame_code[i].res ) tmp_fields=5;
404  if (tmp_head_idx != nut->frame_code[i].header_idx) tmp_fields = 8;
405 
406  tmp_pts = nut->frame_code[i].pts_delta;
407  tmp_flags = nut->frame_code[i].flags;
408  tmp_stream = nut->frame_code[i].stream_id;
409  tmp_mul = nut->frame_code[i].size_mul;
410  tmp_size = nut->frame_code[i].size_lsb;
411 // tmp_res = nut->frame_code[i].res;
412  tmp_head_idx = nut->frame_code[i].header_idx;
413 
414  for (j = 0; i < 256; j++, i++) {
415  if (i == 'N') {
416  j--;
417  continue;
418  }
419  if (nut->frame_code[i].pts_delta != tmp_pts ||
420  nut->frame_code[i].flags != tmp_flags ||
421  nut->frame_code[i].stream_id != tmp_stream ||
422  nut->frame_code[i].size_mul != tmp_mul ||
423  nut->frame_code[i].size_lsb != tmp_size + j ||
424 // nut->frame_code[i].res != tmp_res ||
425  nut->frame_code[i].header_idx != tmp_head_idx)
426  break;
427  }
428  if (j != tmp_mul - tmp_size)
429  tmp_fields = 6;
430 
431  put_v(bc, tmp_flags);
432  put_v(bc, tmp_fields);
433  if (tmp_fields > 0) put_s(bc, tmp_pts);
434  if (tmp_fields > 1) put_v(bc, tmp_mul);
435  if (tmp_fields > 2) put_v(bc, tmp_stream);
436  if (tmp_fields > 3) put_v(bc, tmp_size);
437  if (tmp_fields > 4) put_v(bc, 0 /*tmp_res*/);
438  if (tmp_fields > 5) put_v(bc, j);
439  if (tmp_fields > 6) put_v(bc, tmp_match);
440  if (tmp_fields > 7) put_v(bc, tmp_head_idx);
441  }
442  put_v(bc, nut->header_count - 1);
443  for (i = 1; i < nut->header_count; i++) {
444  put_v(bc, nut->header_len[i]);
445  avio_write(bc, nut->header[i], nut->header_len[i]);
446  }
447  // flags had been effectively introduced in version 4
448  if (nut->version > 3)
449  put_v(bc, nut->flags);
450 }
451 
453  AVStream *st, int i)
454 {
455  NUTContext *nut = avctx->priv_data;
456  AVCodecParameters *par = st->codecpar;
457 
458  put_v(bc, i);
459  switch (par->codec_type) {
460  case AVMEDIA_TYPE_VIDEO: put_v(bc, 0); break;
461  case AVMEDIA_TYPE_AUDIO: put_v(bc, 1); break;
462  case AVMEDIA_TYPE_SUBTITLE: put_v(bc, 2); break;
463  default: put_v(bc, 3); break;
464  }
465  put_v(bc, 4);
466 
467  if (par->codec_tag) {
468  avio_wl32(bc, par->codec_tag);
469  } else {
470  av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
471  return AVERROR(EINVAL);
472  }
473 
474  put_v(bc, nut->stream[i].time_base - nut->time_base);
475  put_v(bc, nut->stream[i].msb_pts_shift);
476  put_v(bc, nut->stream[i].max_pts_distance);
477  put_v(bc, par->video_delay);
478  avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
479 
480  put_v(bc, par->extradata_size);
481  avio_write(bc, par->extradata, par->extradata_size);
482 
483  switch (par->codec_type) {
484  case AVMEDIA_TYPE_AUDIO:
485  put_v(bc, par->sample_rate);
486  put_v(bc, 1);
487  put_v(bc, par->ch_layout.nb_channels);
488  break;
489  case AVMEDIA_TYPE_VIDEO:
490  put_v(bc, par->width);
491  put_v(bc, par->height);
492 
493  if (st->sample_aspect_ratio.num <= 0 ||
494  st->sample_aspect_ratio.den <= 0) {
495  put_v(bc, 0);
496  put_v(bc, 0);
497  } else {
498  put_v(bc, st->sample_aspect_ratio.num);
499  put_v(bc, st->sample_aspect_ratio.den);
500  }
501  put_v(bc, 0); /* csp type -- unknown */
502  break;
503  default:
504  break;
505  }
506  return 0;
507 }
508 
509 static int add_info(AVIOContext *bc, const char *type, const char *value)
510 {
511  put_str(bc, type);
512  put_s(bc, -1);
513  put_str(bc, value);
514  return 1;
515 }
516 
518 {
519  AVFormatContext *s = nut->avf;
520  const AVDictionaryEntry *t = NULL;
521  AVIOContext *dyn_bc;
522  uint8_t *dyn_buf = NULL;
523  int count = 0, dyn_size;
524  int ret = avio_open_dyn_buf(&dyn_bc);
525  if (ret < 0)
526  return ret;
527 
529  while ((t = av_dict_iterate(s->metadata, t)))
530  count += add_info(dyn_bc, t->key, t->value);
531 
532  put_v(bc, 0); //stream_if_plus1
533  put_v(bc, 0); //chapter_id
534  put_v(bc, 0); //timestamp_start
535  put_v(bc, 0); //length
536 
537  put_v(bc, count);
538 
539  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
540  avio_write(bc, dyn_buf, dyn_size);
541  av_free(dyn_buf);
542  return 0;
543 }
544 
545 static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id) {
546  AVFormatContext *s= nut->avf;
547  AVStream* st = s->streams[stream_id];
548  const AVDictionaryEntry *t = NULL;
549  AVIOContext *dyn_bc;
550  uint8_t *dyn_buf=NULL;
551  int count=0, dyn_size, i;
552  int ret = avio_open_dyn_buf(&dyn_bc);
553  if (ret < 0)
554  return ret;
555 
556  while ((t = av_dict_iterate(st->metadata, t)))
557  count += add_info(dyn_bc, t->key, t->value);
558  for (i=0; ff_nut_dispositions[i].flag; ++i) {
560  count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
561  }
562  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
563  uint8_t buf[256];
564  if (st->r_frame_rate.num>0 && st->r_frame_rate.den>0)
565  snprintf(buf, sizeof(buf), "%d/%d", st->r_frame_rate.num, st->r_frame_rate.den);
566  else
567  snprintf(buf, sizeof(buf), "%d/%d", st->avg_frame_rate.num, st->avg_frame_rate.den);
568  count += add_info(dyn_bc, "r_frame_rate", buf);
569  }
570  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
571 
572  if (count) {
573  put_v(bc, stream_id + 1); //stream_id_plus1
574  put_v(bc, 0); //chapter_id
575  put_v(bc, 0); //timestamp_start
576  put_v(bc, 0); //length
577 
578  put_v(bc, count);
579 
580  avio_write(bc, dyn_buf, dyn_size);
581  }
582 
583  av_free(dyn_buf);
584  return count;
585 }
586 
587 static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
588 {
589  AVIOContext *dyn_bc;
590  uint8_t *dyn_buf = NULL;
591  const AVDictionaryEntry *t = NULL;
592  AVChapter *ch = nut->avf->chapters[id];
593  int ret, dyn_size, count = 0;
594 
595  ret = avio_open_dyn_buf(&dyn_bc);
596  if (ret < 0)
597  return ret;
598 
599  put_v(bc, 0); // stream_id_plus1
600  put_s(bc, id + 1); // chapter_id
601  put_tt(nut, nut->chapter[id].time_base, bc, ch->start); // chapter_start
602  put_v(bc, ch->end - ch->start); // chapter_len
603 
604  while ((t = av_dict_iterate(ch->metadata, t)))
605  count += add_info(dyn_bc, t->key, t->value);
606 
607  put_v(bc, count);
608 
609  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
610  avio_write(bc, dyn_buf, dyn_size);
611  av_freep(&dyn_buf);
612  return 0;
613 }
614 
615 static int write_index(NUTContext *nut, AVIOContext *bc) {
616  int i;
617  Syncpoint dummy= { .pos= 0 };
618  Syncpoint *next_node[2] = { NULL };
619  int64_t startpos = avio_tell(bc);
620  int64_t payload_size;
621 
622  put_tt(nut, nut->max_pts_tb, bc, nut->max_pts);
623 
624  put_v(bc, nut->sp_count);
625 
626  for (i=0; i<nut->sp_count; i++) {
627  av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp, (void**)next_node);
628  put_v(bc, (next_node[1]->pos >> 4) - (dummy.pos>>4));
629  dummy.pos = next_node[1]->pos;
630  }
631 
632  for (i=0; i<nut->avf->nb_streams; i++) {
633  StreamContext *nus= &nut->stream[i];
634  int64_t last_pts= -1;
635  int j, k;
636  for (j=0; j<nut->sp_count; j++) {
637  int flag;
638  int n = 0;
639 
640  if (j && nus->keyframe_pts[j] == nus->keyframe_pts[j-1]) {
641  av_log(nut->avf, AV_LOG_WARNING, "Multiple keyframes with same PTS\n");
642  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
643  }
644 
645  flag = (nus->keyframe_pts[j] != AV_NOPTS_VALUE) ^ (j+1 == nut->sp_count);
646  for (; j<nut->sp_count && (nus->keyframe_pts[j] != AV_NOPTS_VALUE) == flag; j++)
647  n++;
648 
649  put_v(bc, 1 + 2 * flag + 4 * n);
650  for (k= j - n; k<=j && k<nut->sp_count; k++) {
651  if (nus->keyframe_pts[k] == AV_NOPTS_VALUE)
652  continue;
653  av_assert0(nus->keyframe_pts[k] > last_pts);
654  put_v(bc, nus->keyframe_pts[k] - last_pts);
655  last_pts = nus->keyframe_pts[k];
656  }
657  }
658  }
659 
660  payload_size = avio_tell(bc) - startpos + 8 + 4;
661 
662  avio_wb64(bc, 8 + payload_size + av_log2(payload_size) / 7 + 1 + 4*(payload_size > 4096));
663 
664  return 0;
665 }
666 
668 {
669  NUTContext *nut = avctx->priv_data;
670  AVIOContext *dyn_bc;
671  int i, ret;
672 
674 
675  ret = avio_open_dyn_buf(&dyn_bc);
676  if (ret < 0)
677  return ret;
678  write_mainheader(nut, dyn_bc);
679  put_packet(nut, bc, dyn_bc, MAIN_STARTCODE);
680 
681  for (i = 0; i < nut->avf->nb_streams; i++) {
682  ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i);
683  if (ret < 0) {
684  goto fail;
685  }
686  put_packet(nut, bc, dyn_bc, STREAM_STARTCODE);
687  }
688 
689  write_globalinfo(nut, dyn_bc);
690  put_packet(nut, bc, dyn_bc, INFO_STARTCODE);
691 
692  for (i = 0; i < nut->avf->nb_streams; i++) {
693  ret = write_streaminfo(nut, dyn_bc, i);
694  if (ret > 0)
695  put_packet(nut, bc, dyn_bc, INFO_STARTCODE);
696  else if (ret < 0) {
697  goto fail;
698  }
699  }
700 
701  for (i = 0; i < nut->avf->nb_chapters; i++) {
702  ret = write_chapter(nut, dyn_bc, i);
703  if (ret < 0) {
704  goto fail;
705  }
706  put_packet(nut, bc, dyn_bc, INFO_STARTCODE);
707  }
708 
709  nut->last_syncpoint_pos = INT_MIN;
710  nut->header_count++;
711 
712  ret = 0;
713 fail:
714  ffio_free_dyn_buf(&dyn_bc);
715 
716  return ret;
717 }
718 
720 {
721  NUTContext *nut = s->priv_data;
722  AVIOContext *bc = s->pb;
723  int i, j, ret;
724 
725  nut->avf = s;
726 
727  nut->version = FFMAX(NUT_STABLE_VERSION, 3 + !!nut->flags);
728  if (nut->version > 3 && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
730  "The additional syncpoint modes require version %d, "
731  "that is currently not finalized, "
732  "please set -f_strict experimental in order to enable it.\n",
733  nut->version);
734  return AVERROR_EXPERIMENTAL;
735  }
736 
737  nut->stream = av_calloc(s->nb_streams, sizeof(*nut->stream ));
738  nut->chapter = av_calloc(s->nb_chapters, sizeof(*nut->chapter));
739  nut->time_base= av_calloc(s->nb_streams +
740  s->nb_chapters, sizeof(*nut->time_base));
741  if (!nut->stream || !nut->chapter || !nut->time_base)
742  return AVERROR(ENOMEM);
743 
744  for (i = 0; i < s->nb_streams; i++) {
745  AVStream *st = s->streams[i];
746  int ssize;
747  AVRational time_base;
748  ff_parse_specific_params(st, &time_base.den, &ssize, &time_base.num);
749 
751  time_base = (AVRational) {1, st->codecpar->sample_rate};
752  } else {
753  time_base = choose_timebase(s, st, 48000);
754  }
755 
756  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
757 
758  for (j = 0; j < nut->time_base_count; j++)
759  if (!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))) {
760  break;
761  }
762  nut->time_base[j] = time_base;
763  nut->stream[i].time_base = &nut->time_base[j];
764  if (j == nut->time_base_count)
765  nut->time_base_count++;
766 
767  if (INT64_C(1000) * time_base.num >= time_base.den)
768  nut->stream[i].msb_pts_shift = 7;
769  else
770  nut->stream[i].msb_pts_shift = 14;
771  nut->stream[i].max_pts_distance =
772  FFMAX(time_base.den, time_base.num) / time_base.num;
773  }
774 
775  for (i = 0; i < s->nb_chapters; i++) {
776  AVChapter *ch = s->chapters[i];
777 
778  for (j = 0; j < nut->time_base_count; j++)
779  if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational)))
780  break;
781 
782  nut->time_base[j] = ch->time_base;
783  nut->chapter[i].time_base = &nut->time_base[j];
784  if (j == nut->time_base_count)
785  nut->time_base_count++;
786  }
787 
788  nut->max_distance = MAX_DISTANCE;
791  av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
792 
793  avio_write(bc, ID_STRING, strlen(ID_STRING));
794  avio_w8(bc, 0);
795 
796  if ((ret = write_headers(s, bc)) < 0)
797  return ret;
798 
799  if (s->avoid_negative_ts < 0)
800  s->avoid_negative_ts = 1;
801 
802  return 0;
803 }
804 
806  AVPacket *pkt)
807 {
808  int flags = 0;
809 
810  if (pkt->flags & AV_PKT_FLAG_KEY)
811  flags |= FLAG_KEY;
812  if (pkt->stream_index != fc->stream_id)
814  if (pkt->size / fc->size_mul)
815  flags |= FLAG_SIZE_MSB;
816  if (pkt->pts - nus->last_pts != fc->pts_delta)
818  if (pkt->side_data_elems && nut->version > 3)
819  flags |= FLAG_SM_DATA;
820  if (pkt->size > 2 * nut->max_distance)
821  flags |= FLAG_CHECKSUM;
822  if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
823  flags |= FLAG_CHECKSUM;
824  if (fc->header_idx)
825  if (pkt->size < nut->header_len[fc->header_idx] ||
826  pkt->size > 4096 ||
827  memcmp(pkt->data, nut->header [fc->header_idx],
828  nut->header_len[fc->header_idx]))
830 
831  return flags | (fc->flags & FLAG_CODED);
832 }
833 
835 {
836  int i;
837  int best_i = 0;
838  int best_len = 0;
839 
840  if (pkt->size > 4096)
841  return 0;
842 
843  for (i = 1; i < nut->header_count; i++)
844  if (pkt->size >= nut->header_len[i]
845  && nut->header_len[i] > best_len
846  && !memcmp(pkt->data, nut->header[i], nut->header_len[i])) {
847  best_i = i;
848  best_len = nut->header_len[i];
849  }
850  return best_i;
851 }
852 
853 static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
854 {
855  int ret, i, dyn_size;
856  unsigned flags;
857  AVIOContext *dyn_bc;
858  int sm_data_count = 0;
859  uint8_t tmp[256];
860  uint8_t *dyn_buf;
861 
862  ret = avio_open_dyn_buf(&dyn_bc);
863  if (ret < 0)
864  return ret;
865 
866  for (i = 0; i<pkt->side_data_elems; i++) {
867  const uint8_t *data = pkt->side_data[i].data;
868  int size = pkt->side_data[i].size;
869  const uint8_t *data_end = data + size;
870 
871  if (is_meta) {
874  if (!size || data[size-1]) {
875  ret = AVERROR(EINVAL);
876  goto fail;
877  }
878  while (data < data_end) {
879  const uint8_t *key = data;
880  const uint8_t *val = data + strlen(key) + 1;
881 
882  if(val >= data_end) {
883  ret = AVERROR(EINVAL);
884  goto fail;
885  }
886  put_str(dyn_bc, key);
887  put_s(dyn_bc, -1);
888  put_str(dyn_bc, val);
889  data = val + strlen(val) + 1;
890  sm_data_count++;
891  }
892  }
893  } else {
894  switch (pkt->side_data[i].type) {
895  case AV_PKT_DATA_PALETTE:
898  default:
900  put_str(dyn_bc, "Palette");
901  } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
902  put_str(dyn_bc, "Extradata");
904  snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
905  put_str(dyn_bc, tmp);
906  } else {
907  snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
908  (s->flags & AVFMT_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
909  pkt->side_data[i].type);
910  put_str(dyn_bc, tmp);
911  }
912  put_s(dyn_bc, -2);
913  put_str(dyn_bc, "bin");
914  put_v(dyn_bc, pkt->side_data[i].size);
915  avio_write(dyn_bc, data, pkt->side_data[i].size);
916  sm_data_count++;
917  break;
919  flags = bytestream_get_le32(&data);
921  put_str(dyn_bc, "SampleRate");
922  put_s(dyn_bc, bytestream_get_le32(&data));
923  sm_data_count++;
924  }
926  put_str(dyn_bc, "Width");
927  put_s(dyn_bc, bytestream_get_le32(&data));
928  put_str(dyn_bc, "Height");
929  put_s(dyn_bc, bytestream_get_le32(&data));
930  sm_data_count+=2;
931  }
932  break;
934  if (AV_RL32(data)) {
935  put_str(dyn_bc, "SkipStart");
936  put_s(dyn_bc, (unsigned)AV_RL32(data));
937  sm_data_count++;
938  }
939  if (AV_RL32(data+4)) {
940  put_str(dyn_bc, "SkipEnd");
941  put_s(dyn_bc, (unsigned)AV_RL32(data+4));
942  sm_data_count++;
943  }
944  break;
948  // belongs into meta, not side data
949  break;
950  }
951  }
952  }
953 
954 fail:
955  put_v(bc, sm_data_count);
956  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
957  avio_write(bc, dyn_buf, dyn_size);
958  av_freep(&dyn_buf);
959 
960  return ret;
961 }
962 
964 {
965  NUTContext *nut = s->priv_data;
966  StreamContext *nus = &nut->stream[pkt->stream_index];
967  AVIOContext *bc = s->pb, *dyn_bc, *sm_bc = NULL;
968  FrameCode *fc;
969  int64_t coded_pts;
970  int best_length, frame_code, flags, needed_flags, i, header_idx;
971  int best_header_idx;
972  int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
973  int store_sp = 0;
974  int ret = 0;
975  int sm_size = 0;
976  int data_size = pkt->size;
977  uint8_t *sm_buf = NULL;
978 
979  if (pkt->pts < 0) {
981  "Negative pts not supported stream %d, pts %"PRId64"\n",
982  pkt->stream_index, pkt->pts);
983  if (pkt->pts == AV_NOPTS_VALUE)
984  av_log(s, AV_LOG_ERROR, "Try to enable the genpts flag\n");
985  return AVERROR(EINVAL);
986  }
987 
988  if (pkt->side_data_elems && nut->version > 3) {
989  ret = avio_open_dyn_buf(&sm_bc);
990  if (ret < 0)
991  return ret;
992  ret = write_sm_data(s, sm_bc, pkt, 0);
993  if (ret >= 0)
994  ret = write_sm_data(s, sm_bc, pkt, 1);
995  sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
996  if (ret < 0)
997  goto fail;
998  data_size += sm_size;
999  }
1000 
1001  if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
1002  write_headers(s, bc);
1003 
1004  if (key_frame && !(nus->last_flags & FLAG_KEY))
1005  store_sp = 1;
1006 
1007  if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
1008  store_sp = 1;
1009 
1010 //FIXME: Ensure store_sp is 1 in the first place.
1011 
1012  if (store_sp &&
1013  (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) {
1014  int64_t sp_pos = INT64_MAX;
1015 
1016  ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
1017  for (i = 0; i < s->nb_streams; i++) {
1018  AVStream *st = s->streams[i];
1019  FFStream *const sti = ffstream(st);
1020  int64_t dts_tb = av_rescale_rnd(pkt->dts,
1021  nus->time_base->num * (int64_t)nut->stream[i].time_base->den,
1022  nus->time_base->den * (int64_t)nut->stream[i].time_base->num,
1023  AV_ROUND_DOWN);
1024  int index = av_index_search_timestamp(st, dts_tb,
1026  if (index >= 0) {
1027  sp_pos = FFMIN(sp_pos, sti->index_entries[index].pos);
1028  if (!nut->write_index && 2*index > sti->nb_index_entries) {
1029  memmove(sti->index_entries,
1030  sti->index_entries + index,
1031  sizeof(*sti->index_entries) * (sti->nb_index_entries - index));
1032  sti->nb_index_entries -= index;
1033  }
1034  }
1035  }
1036 
1037  nut->last_syncpoint_pos = avio_tell(bc);
1038  ret = avio_open_dyn_buf(&dyn_bc);
1039  if (ret < 0)
1040  goto fail;
1041  put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
1042  put_v(dyn_bc, sp_pos != INT64_MAX ? (nut->last_syncpoint_pos - sp_pos) >> 4 : 0);
1043 
1044  if (nut->flags & NUT_BROADCAST) {
1045  put_tt(nut, nus->time_base, dyn_bc,
1047  }
1048  put_packet(nut, bc, dyn_bc, SYNCPOINT_STARTCODE);
1049  ffio_free_dyn_buf(&dyn_bc);
1050 
1051  if (nut->write_index) {
1052  if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0)
1053  goto fail;
1054 
1055  if ((1ll<<60) % nut->sp_count == 0)
1056  for (unsigned i = 0; i < s->nb_streams; i++) {
1057  StreamContext *nus = &nut->stream[i];
1058  av_reallocp_array(&nus->keyframe_pts, 2*nut->sp_count, sizeof(*nus->keyframe_pts));
1059  if (!nus->keyframe_pts) {
1060  ret = AVERROR(ENOMEM);
1061  goto fail;
1062  }
1063  for (int j = nut->sp_count == 1 ? 0 : nut->sp_count;
1064  j < 2 * nut->sp_count; j++)
1065  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
1066  }
1067  }
1068  }
1070 
1071  coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
1072  if (ff_lsb2full(nus, coded_pts) != pkt->pts)
1073  coded_pts = pkt->pts + (1 << nus->msb_pts_shift);
1074 
1075  best_header_idx = find_best_header_idx(nut, pkt);
1076 
1077  best_length = INT_MAX;
1078  frame_code = -1;
1079  for (i = 0; i < 256; i++) {
1080  int length = 0;
1081  FrameCode *fc = &nut->frame_code[i];
1082  int flags = fc->flags;
1083 
1084  if (flags & FLAG_INVALID)
1085  continue;
1086  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1087 
1088  if (flags & FLAG_CODED) {
1089  length++;
1090  flags = needed_flags;
1091  }
1092 
1093  if ((flags & needed_flags) != needed_flags)
1094  continue;
1095 
1096  if ((flags ^ needed_flags) & FLAG_KEY)
1097  continue;
1098 
1099  if (flags & FLAG_STREAM_ID)
1100  length += get_v_length(pkt->stream_index);
1101 
1102  if (data_size % fc->size_mul != fc->size_lsb)
1103  continue;
1104  if (flags & FLAG_SIZE_MSB)
1105  length += get_v_length(data_size / fc->size_mul);
1106 
1107  if (flags & FLAG_CHECKSUM)
1108  length += 4;
1109 
1110  if (flags & FLAG_CODED_PTS)
1111  length += get_v_length(coded_pts);
1112 
1113  if ( (flags & FLAG_CODED)
1114  && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx] + 1) {
1116  }
1117 
1118  if (flags & FLAG_HEADER_IDX) {
1119  length += 1 - nut->header_len[best_header_idx];
1120  } else {
1121  length -= nut->header_len[fc->header_idx];
1122  }
1123 
1124  length *= 4;
1125  length += !(flags & FLAG_CODED_PTS);
1126  length += !(flags & FLAG_CHECKSUM);
1127 
1128  if (length < best_length) {
1129  best_length = length;
1130  frame_code = i;
1131  }
1132  }
1133  av_assert0(frame_code != -1);
1134 
1135  fc = &nut->frame_code[frame_code];
1136  flags = fc->flags;
1137  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1138  header_idx = fc->header_idx;
1139 
1141  avio_w8(bc, frame_code);
1142  if (flags & FLAG_CODED) {
1143  put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
1144  flags = needed_flags;
1145  }
1146  if (flags & FLAG_STREAM_ID) put_v(bc, pkt->stream_index);
1147  if (flags & FLAG_CODED_PTS) put_v(bc, coded_pts);
1148  if (flags & FLAG_SIZE_MSB ) put_v(bc, data_size / fc->size_mul);
1149  if (flags & FLAG_HEADER_IDX) put_v(bc, header_idx = best_header_idx);
1150 
1152  else ffio_get_checksum(bc);
1153 
1154  if (flags & FLAG_SM_DATA) {
1155  avio_write(bc, sm_buf, sm_size);
1156  }
1157  avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
1158 
1159  nus->last_flags = flags;
1160  nus->last_pts = pkt->pts;
1161 
1162  //FIXME just store one per syncpoint
1163  if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) {
1165  s->streams[pkt->stream_index],
1166  nut->last_syncpoint_pos,
1167  pkt->pts,
1168  0,
1169  0,
1171  if (nus->keyframe_pts && nus->keyframe_pts[nut->sp_count] == AV_NOPTS_VALUE)
1172  nus->keyframe_pts[nut->sp_count] = pkt->pts;
1173  }
1174 
1175  if (!nut->max_pts_tb || av_compare_ts(nut->max_pts, *nut->max_pts_tb, pkt->pts, *nus->time_base) < 0) {
1176  nut->max_pts = pkt->pts;
1177  nut->max_pts_tb = nus->time_base;
1178  }
1179 
1180 fail:
1181  av_freep(&sm_buf);
1182 
1183  return ret;
1184 }
1185 
1187 {
1188  NUTContext *nut = s->priv_data;
1189  AVIOContext *bc = s->pb, *dyn_bc;
1190  int ret;
1191 
1192  while (nut->header_count < 3)
1193  write_headers(s, bc);
1194 
1195  if (!nut->sp_count)
1196  return 0;
1197 
1198  ret = avio_open_dyn_buf(&dyn_bc);
1199  if (ret >= 0) {
1200  av_assert1(nut->write_index); // sp_count should be 0 if no index is going to be written
1201  write_index(nut, dyn_bc);
1202  put_packet(nut, bc, dyn_bc, INDEX_STARTCODE);
1203  ffio_free_dyn_buf(&dyn_bc);
1204  }
1205 
1206  return 0;
1207 }
1208 
1210 {
1211  NUTContext *nut = s->priv_data;
1212  int i;
1213 
1214  ff_nut_free_sp(nut);
1215  if (nut->stream)
1216  for (i=0; i<s->nb_streams; i++)
1217  av_freep(&nut->stream[i].keyframe_pts);
1218 
1219  av_freep(&nut->stream);
1220  av_freep(&nut->chapter);
1221  av_freep(&nut->time_base);
1222 }
1223 
1224 #define OFFSET(x) offsetof(NUTContext, x)
1225 #define E AV_OPT_FLAG_ENCODING_PARAM
1226 static const AVOption options[] = {
1227  { "syncpoints", "NUT syncpoint behaviour", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, E, .unit = "syncpoints" },
1228  { "default", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E, .unit = "syncpoints" },
1229  { "none", "Disable syncpoints, low overhead and unseekable", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E, .unit = "syncpoints" },
1230  { "timestamped", "Extend syncpoints with a wallclock timestamp", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, .unit = "syncpoints" },
1231  { "write_index", "Write index", OFFSET(write_index), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E, },
1232  { NULL },
1233 };
1234 
1235 static const AVClass class = {
1236  .class_name = "nutenc",
1237  .item_name = av_default_item_name,
1238  .option = options,
1240 };
1241 
1243  .p.name = "nut",
1244  .p.long_name = NULL_IF_CONFIG_SMALL("NUT"),
1245  .p.mime_type = "video/x-nut",
1246  .p.extensions = "nut",
1247  .priv_data_size = sizeof(NUTContext),
1248  .p.audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
1249  CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
1250  .p.video_codec = AV_CODEC_ID_MPEG4,
1251  .write_header = nut_write_header,
1252  .write_packet = nut_write_packet,
1253  .write_trailer = nut_write_trailer,
1254  .deinit = nut_write_deinit,
1256  .p.codec_tag = ff_nut_codec_tags,
1257  .p.priv_class = &class,
1258 };
write_streaminfo
static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id)
Definition: nutenc.c:545
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
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:69
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
FrameCode::stream_id
uint8_t stream_id
Definition: nut.h:67
write_mainheader
static void write_mainheader(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:372
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1218
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
write_globalinfo
static int write_globalinfo(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:517
get_v_length
static int get_v_length(uint64_t val)
Get the length in bytes which is needed to store val as v.
Definition: nutenc.c:306
opt.h
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:51
NUTContext::time_base_count
unsigned int time_base_count
Definition: nut.h:103
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
out
FILE * out
Definition: movenc.c:55
NUTContext::minor_version
int minor_version
Definition: nut.h:117
get_needed_flags
static int get_needed_flags(NUTContext *nut, StreamContext *nus, FrameCode *fc, AVPacket *pkt)
Definition: nutenc.c:805
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:129
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1355
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
NUTContext::max_distance
unsigned int max_distance
Definition: nut.h:102
nut_write_trailer
static int nut_write_trailer(AVFormatContext *s)
Definition: nutenc.c:1186
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
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:482
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
choose_timebase
static AVRational choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: nutenc.c:48
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:264
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
STREAM_STARTCODE
#define STREAM_STARTCODE
Definition: nut.h:30
NUTContext::write_index
int write_index
Definition: nut.h:110
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:1323
nut_write_packet
static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nutenc.c:963
AVPacket::data
uint8_t * data
Definition: packet.h:520
ff_nut_dispositions
const Dispositions ff_nut_dispositions[]
Definition: nut.c:327
NUTContext::last_syncpoint_pos
int64_t last_syncpoint_pos
Definition: nut.h:104
AVOption
AVOption.
Definition: opt.h:357
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
AVChapter::start
int64_t start
Definition: avformat.h:1217
data
const char data[16]
Definition: mxf.c:148
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:597
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:464
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
mathematics.h
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
ff_nut_reset_ts
void ff_nut_reset_ts(NUTContext *nut, AVRational time_base, int64_t val)
Definition: nut.c:258
write_chapter
static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
Definition: nutenc.c:587
FrameCode::size_lsb
uint16_t size_lsb
Definition: nut.h:69
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Syncpoint
Definition: nut.h:58
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1374
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:575
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:583
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
ff_nut_sp_pos_cmp
int ff_nut_sp_pos_cmp(const void *a, const void *b)
Definition: nut.c:276
ff_nut_free_sp
void ff_nut_free_sp(NUTContext *nut)
Definition: nut.c:319
AVPacketSideData::size
size_t size
Definition: packet.h:373
intra_only
int8_t intra_only
Definition: mxfenc.c:2426
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:853
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
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
find_best_header_idx
static int find_best_header_idx(NUTContext *nut, AVPacket *pkt)
Definition: nutenc.c:834
fail
#define fail()
Definition: checkasm.h:185
nut_write_header
static int nut_write_header(AVFormatContext *s)
Definition: nutenc.c:719
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:121
dummy
int dummy
Definition: motion.c:66
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
NUTContext::avf
AVFormatContext * avf
Definition: nut.h:93
AVChapter
Definition: avformat.h:1214
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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:644
NUTContext::header
const uint8_t * header[128]
Definition: nut.h:98
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
AVRational::num
int num
Numerator.
Definition: rational.h:59
NUTContext::sp_count
int sp_count
Definition: nut.h:109
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1407
NUTContext::header_count
int header_count
Definition: nut.h:106
avassert.h
put_str
static void put_str(AVIOContext *bc, const char *string)
Store a string as vb.
Definition: nutenc.c:338
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:69
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
NUTContext
Definition: nut.h:91
ChapterContext::time_base
AVRational * time_base
Definition: nut.h:88
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
E
#define E
Definition: nutenc.c:1225
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:598
AVChapter::end
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1217
intreadwrite.h
ff_nut_metadata_conv
const AVMetadataConv ff_nut_metadata_conv[]
Definition: nut.c:337
s
#define s(width, name)
Definition: cbs_vp9.c:198
nut.h
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1356
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:440
NUTContext::time_base
AVRational * time_base
Definition: nut.h:107
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
write_streamheader
static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, AVStream *st, int i)
Definition: nutenc.c:452
AVPacketSideData::data
uint8_t * data
Definition: packet.h:372
StreamContext::last_pts
int64_t last_pts
Definition: nut.h:78
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
ff_nut_muxer
const FFOutputFormat ff_nut_muxer
Definition: nutenc.c:1242
write_index
static int write_index(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:615
put_packet
static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, uint64_t startcode)
Definition: nutenc.c:351
key
const char * key
Definition: hwcontext_opencl.c:189
FrameCode::size_mul
uint16_t size_mul
Definition: nut.h:68
FLAG_INVALID
@ FLAG_INVALID
Definition: nut.h:55
find_expected_header
static int find_expected_header(AVCodecParameters *p, int size, int key_frame, uint8_t out[64])
Definition: nutenc.c:61
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:74
if
if(ret)
Definition: filter_design.txt:179
options
static const AVOption options[]
Definition: nutenc.c:1226
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2445
Dispositions::flag
int flag
Definition: nut.h:130
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:782
NULL
#define NULL
Definition: coverity.c:32
NUT_BROADCAST
#define NUT_BROADCAST
Definition: nut.h:113
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:374
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
NUTContext::chapter
ChapterContext * chapter
Definition: nut.h:101
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:251
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
FFOutputFormat
Definition: mux.h:61
time.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
build_elision_headers
static void build_elision_headers(AVFormatContext *s)
Definition: nutenc.c:145
write_headers
static int write_headers(AVFormatContext *avctx, AVIOContext *bc)
Definition: nutenc.c:667
index
int index
Definition: gxfenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
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:73
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:413
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
StreamContext
Definition: transcode.c:54
put_tt
static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val)
Definition: nutenc.c:329
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
FLAG_SIZE_MSB
@ FLAG_SIZE_MSB
Definition: nut.h:48
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
put_s
static void put_s(AVIOContext *bc, int64_t val)
Definition: nutenc.c:346
ffio_reset_dyn_buf
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1396
AVPacket::size
int size
Definition: packet.h:521
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:94
FFStream
Definition: internal.h:193
ff_standardize_creation_time
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: mux_utils.c:155
add_info
static int add_info(AVIOContext *bc, const char *type, const char *value)
Definition: nutenc.c:509
NUTContext::max_pts_tb
AVRational * max_pts_tb
Definition: nut.h:112
NUTContext::flags
int flags
Definition: nut.h:115
size
int size
Definition: twinvq_data.h:10344
NUTContext::stream
StreamContext * stream
Definition: nut.h:100
AV_PKT_DATA_METADATA_UPDATE
@ AV_PKT_DATA_METADATA_UPDATE
A list of zero terminated key/value strings.
Definition: packet.h:206
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
FrameCode::flags
uint16_t flags
Definition: nut.h:66
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:796
NUT_STABLE_VERSION
#define NUT_STABLE_VERSION
Definition: nut.h:40
build_frame_code
static void build_frame_code(AVFormatContext *s)
Definition: nutenc.c:167
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:444
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:591
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
tree.h
header
static const uint8_t header[24]
Definition: sdr2.c:68
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:519
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:357
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:526
find_header_idx
static int find_header_idx(AVFormatContext *s, AVCodecParameters *p, int size, int frame_type)
Definition: nutenc.c:128
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:565
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:169
flag
#define flag(name)
Definition: cbs_av1.c:466
ff_nut_add_sp
int ff_nut_add_sp(NUTContext *nut, int64_t pos, int64_t back_ptr, int64_t ts)
Definition: nut.c:288
NUTContext::syncpoints
struct AVTreeNode * syncpoints
Definition: nut.h:108
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:478
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:513
frame_type
frame_type
Definition: jpeg2000_parser.c:31
avio_internal.h
ff_lsb2full
int64_t ff_lsb2full(StreamContext *stream, int64_t lsb)
Definition: nut.c:269
AVCodecParameters::height
int height
Definition: codec_par.h:135
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
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
NUTContext::max_pts
int64_t max_pts
Definition: nut.h:111
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
last_pts
static int64_t last_pts
Definition: decode_filter_video.c:53
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
NUTContext::frame_code
FrameCode frame_code[256]
Definition: nut.h:96
StreamContext::keyframe_pts
int64_t * keyframe_pts
Definition: nut.h:84
version.h
FLAG_SM_DATA
@ FLAG_SM_DATA
Definition: nut.h:51
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:812
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:188
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1435
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1423
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
pred
static const float pred[4]
Definition: siprdata.h:259
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
FLAG_STREAM_ID
@ FLAG_STREAM_ID
Definition: nut.h:47
ff_parse_specific_params
void ff_parse_specific_params(AVStream *st, int *au_rate, int *au_ssize, int *au_scale)
Definition: riffenc.c:274
pos
unsigned int pos
Definition: spdifenc.c:414
dict.h
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:531
FrameCode::header_idx
uint8_t header_idx
Definition: nut.h:72
id
enum AVCodecID id
Definition: dts2pts.c:365
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
FLAG_CHECKSUM
@ FLAG_CHECKSUM
Definition: nut.h:49
FLAG_KEY
@ FLAG_KEY
Definition: nut.h:44
ff_nut_codec_tags
const AVCodecTag *const ff_nut_codec_tags[]
Definition: nut.c:253
FLAG_HEADER_IDX
@ FLAG_HEADER_IDX
Definition: nut.h:52
AVRational::den
int den
Denominator.
Definition: rational.h:60
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
ff_mpa_freq_tab
const uint16_t ff_mpa_freq_tab[3]
Definition: mpegaudiotabs.h:37
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVPacket::stream_index
int stream_index
Definition: packet.h:522
write_sm_data
static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
Definition: nutenc.c:853
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
mpegaudiodata.h
OFFSET
#define OFFSET(x)
Definition: nutenc.c:1224
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:431
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
MAX_DISTANCE
#define MAX_DISTANCE
Definition: nut.h:37
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:175
ff_mpa_bitrate_tab
const FF_VISIBILITY_PUSH_HIDDEN uint16_t ff_mpa_bitrate_tab[2][3][15]
Definition: mpegaudiotabs.h:27
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
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:55
FrameCode
Definition: nut.h:65
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
riff.h
nut_write_deinit
static void nut_write_deinit(AVFormatContext *s)
Definition: nutenc.c:1209
INDEX_STARTCODE
#define INDEX_STARTCODE
Definition: nut.h:32
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
bytestream.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:445
AVDictionaryEntry::value
char * value
Definition: dict.h:91
StreamContext::time_base
AVRational time_base
Definition: signature.h:103
AVChapter::time_base
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1216
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
snprintf
#define snprintf
Definition: snprintf.h:34
INFO_STARTCODE
#define INFO_STARTCODE
Definition: nut.h:33
MAIN_STARTCODE
#define MAIN_STARTCODE
Definition: nut.h:29
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
StreamContext::max_pts_distance
int max_pts_distance
Definition: nut.h:82
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
put_v
static void put_v(AVIOContext *bc, uint64_t val)
Put val using a variable number of bytes.
Definition: nutenc.c:319
ID_STRING
#define ID_STRING
Definition: ffmeta.h:25
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:532
ff_metadata_conv_ctx
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
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:244
mux.h