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