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 "nut.h"
34 #include "internal.h"
35 #include "avio_internal.h"
36 #include "riff.h"
37 
38 static int find_expected_header(AVCodecParameters *p, int size, int key_frame,
39  uint8_t out[64])
40 {
41  int sample_rate = p->sample_rate;
42 
43  if (size > 4096)
44  return 0;
45 
46  AV_WB24(out, 1);
47 
48  if (p->codec_id == AV_CODEC_ID_MPEG4) {
49  if (key_frame) {
50  return 3;
51  } else {
52  out[3] = 0xB6;
53  return 4;
54  }
55  } else if (p->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
57  return 3;
58  } else if (p->codec_id == AV_CODEC_ID_H264) {
59  return 3;
60  } else if (p->codec_id == AV_CODEC_ID_MP3 ||
61  p->codec_id == AV_CODEC_ID_MP2) {
62  int lsf, mpeg25, sample_rate_index, bitrate_index, frame_size;
63  int layer = p->codec_id == AV_CODEC_ID_MP3 ? 3 : 2;
64  unsigned int header = 0xFFF00000;
65 
66  lsf = sample_rate < (24000 + 32000) / 2;
67  mpeg25 = sample_rate < (12000 + 16000) / 2;
68  sample_rate <<= lsf + mpeg25;
69  if (sample_rate < (32000 + 44100) / 2) sample_rate_index = 2;
70  else if (sample_rate < (44100 + 48000) / 2) sample_rate_index = 0;
71  else sample_rate_index = 1;
72 
73  sample_rate = avpriv_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25);
74 
75  for (bitrate_index = 2; bitrate_index < 30; bitrate_index++) {
76  frame_size =
77  avpriv_mpa_bitrate_tab[lsf][layer - 1][bitrate_index >> 1];
78  frame_size = (frame_size * 144000) / (sample_rate << lsf) +
79  (bitrate_index & 1);
80 
81  if (frame_size == size)
82  break;
83  }
84 
85  header |= (!lsf) << 19;
86  header |= (4 - layer) << 17;
87  header |= 1 << 16; //no crc
88  AV_WB32(out, header);
89  if (size <= 0)
90  return 2; //we guess there is no crc, if there is one the user clearly does not care about overhead
91  if (bitrate_index == 30)
92  return -1; //something is wrong ...
93 
94  header |= (bitrate_index >> 1) << 12;
95  header |= sample_rate_index << 10;
96  header |= (bitrate_index & 1) << 9;
97 
98  return 2; //FIXME actually put the needed ones in build_elision_headers()
99  //return 3; //we guess that the private bit is not set
100 //FIXME the above assumptions should be checked, if these turn out false too often something should be done
101  }
102  return 0;
103 }
104 
106  int frame_type)
107 {
108  NUTContext *nut = s->priv_data;
109  uint8_t out[64];
110  int i;
111  int len = find_expected_header(p, size, frame_type, out);
112 
113  for (i = 1; i < nut->header_count; i++) {
114  if (len == nut->header_len[i] && !memcmp(out, nut->header[i], len)) {
115  return i;
116  }
117  }
118 
119  return 0;
120 }
121 
123 {
124  NUTContext *nut = s->priv_data;
125  int i;
126  //FIXME this is lame
127  //FIXME write a 2pass mode to find the maximal headers
128  static const uint8_t headers[][5] = {
129  { 3, 0x00, 0x00, 0x01 },
130  { 4, 0x00, 0x00, 0x01, 0xB6},
131  { 2, 0xFF, 0xFA }, //mp3+crc
132  { 2, 0xFF, 0xFB }, //mp3
133  { 2, 0xFF, 0xFC }, //mp2+crc
134  { 2, 0xFF, 0xFD }, //mp2
135  };
136 
137  nut->header_count = 7;
138  for (i = 1; i < nut->header_count; i++) {
139  nut->header_len[i] = headers[i - 1][0];
140  nut->header[i] = &headers[i - 1][1];
141  }
142 }
143 
145 {
146  NUTContext *nut = s->priv_data;
147  int key_frame, index, pred, stream_id;
148  int start = 1;
149  int end = 254;
150  int keyframe_0_esc = s->nb_streams > 2;
151  int pred_table[10];
152  FrameCode *ft;
153 
154  ft = &nut->frame_code[start];
155  ft->flags = FLAG_CODED;
156  ft->size_mul = 1;
157  ft->pts_delta = 1;
158  start++;
159 
160  if (keyframe_0_esc) {
161  /* keyframe = 0 escape */
162  FrameCode *ft = &nut->frame_code[start];
164  ft->size_mul = 1;
165  start++;
166  }
167 
168  for (stream_id = 0; stream_id < s->nb_streams; stream_id++) {
169  int start2 = start + (end - start) * stream_id / s->nb_streams;
170  int end2 = start + (end - start) * (stream_id + 1) / s->nb_streams;
171  AVCodecParameters *par = s->streams[stream_id]->codecpar;
172  int is_audio = par->codec_type == AVMEDIA_TYPE_AUDIO;
173  int intra_only = /*codec->intra_only || */ is_audio;
174  int pred_count;
175  int frame_size = 0;
176 
177  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
179  if (par->codec_id == AV_CODEC_ID_VORBIS && !frame_size)
180  frame_size = 64;
181  } else {
182  AVRational f = av_div_q(av_inv_q(s->streams[stream_id]->avg_frame_rate), *nut->stream[stream_id].time_base);
183  if (f.den == 1 && f.num>0)
184  frame_size = f.num;
185  }
186  if (!frame_size)
187  frame_size = 1;
188 
189  for (key_frame = 0; key_frame < 2; key_frame++) {
190  if (!intra_only || !keyframe_0_esc || key_frame != 0) {
191  FrameCode *ft = &nut->frame_code[start2];
192  ft->flags = FLAG_KEY * key_frame;
194  ft->stream_id = stream_id;
195  ft->size_mul = 1;
196  if (is_audio)
197  ft->header_idx = find_header_idx(s, par, -1, key_frame);
198  start2++;
199  }
200  }
201 
202  key_frame = intra_only;
203 #if 1
204  if (is_audio) {
205  int frame_bytes;
206  int pts;
207 
208  if (par->block_align > 0) {
209  frame_bytes = par->block_align;
210  } else {
212  frame_bytes = frame_size * (int64_t)par->bit_rate / (8 * par->sample_rate);
213  }
214 
215  for (pts = 0; pts < 2; pts++) {
216  for (pred = 0; pred < 2; pred++) {
217  FrameCode *ft = &nut->frame_code[start2];
218  ft->flags = FLAG_KEY * key_frame;
219  ft->stream_id = stream_id;
220  ft->size_mul = frame_bytes + 2;
221  ft->size_lsb = frame_bytes + pred;
222  ft->pts_delta = pts * frame_size;
223  ft->header_idx = find_header_idx(s, par, frame_bytes + pred, key_frame);
224  start2++;
225  }
226  }
227  } else {
228  FrameCode *ft = &nut->frame_code[start2];
229  ft->flags = FLAG_KEY | FLAG_SIZE_MSB;
230  ft->stream_id = stream_id;
231  ft->size_mul = 1;
232  ft->pts_delta = frame_size;
233  start2++;
234  }
235 #endif
236 
237  if (par->video_delay) {
238  pred_count = 5;
239  pred_table[0] = -2;
240  pred_table[1] = -1;
241  pred_table[2] = 1;
242  pred_table[3] = 3;
243  pred_table[4] = 4;
244  } else if (par->codec_id == AV_CODEC_ID_VORBIS) {
245  pred_count = 3;
246  pred_table[0] = 2;
247  pred_table[1] = 9;
248  pred_table[2] = 16;
249  } else {
250  pred_count = 1;
251  pred_table[0] = 1;
252  }
253 
254  for (pred = 0; pred < pred_count; pred++) {
255  int start3 = start2 + (end2 - start2) * pred / pred_count;
256  int end3 = start2 + (end2 - start2) * (pred + 1) / pred_count;
257 
258  pred_table[pred] *= frame_size;
259 
260  for (index = start3; index < end3; index++) {
261  FrameCode *ft = &nut->frame_code[index];
262  ft->flags = FLAG_KEY * key_frame;
263  ft->flags |= FLAG_SIZE_MSB;
264  ft->stream_id = stream_id;
265 //FIXME use single byte size and pred from last
266  ft->size_mul = end3 - start3;
267  ft->size_lsb = index - start3;
268  ft->pts_delta = pred_table[pred];
269  if (is_audio)
270  ft->header_idx = find_header_idx(s, par, -1, key_frame);
271  }
272  }
273  }
274  memmove(&nut->frame_code['N' + 1], &nut->frame_code['N'], sizeof(FrameCode) * (255 - 'N'));
275  nut->frame_code[0].flags =
276  nut->frame_code[255].flags =
277  nut->frame_code['N'].flags = FLAG_INVALID;
278 }
279 
280 static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val)
281 {
282  val *= nut->time_base_count;
283  val += time_base - nut->time_base;
284  ff_put_v(bc, val);
285 }
286 /**
287  * Store a string as vb.
288  */
289 static void put_str(AVIOContext *bc, const char *string)
290 {
291  size_t len = strlen(string);
292 
293  ff_put_v(bc, len);
294  avio_write(bc, string, len);
295 }
296 
297 static void put_s(AVIOContext *bc, int64_t val)
298 {
299  ff_put_v(bc, 2 * FFABS(val) - (val > 0));
300 }
301 
302 //FIXME remove calculate_checksum
303 static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc,
304  int calculate_checksum, uint64_t startcode)
305 {
306  uint8_t *dyn_buf = NULL;
307  int dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
308  int forw_ptr = dyn_size + 4 * calculate_checksum;
309 
310  if (forw_ptr > 4096)
312  avio_wb64(bc, startcode);
313  ff_put_v(bc, forw_ptr);
314  if (forw_ptr > 4096)
315  avio_wl32(bc, ffio_get_checksum(bc));
316 
317  if (calculate_checksum)
319  avio_write(bc, dyn_buf, dyn_size);
320  if (calculate_checksum)
321  avio_wl32(bc, ffio_get_checksum(bc));
322 
323  av_free(dyn_buf);
324 }
325 
327 {
328  int i, j, tmp_pts, tmp_flags, tmp_stream, tmp_mul, tmp_size, tmp_fields,
329  tmp_head_idx;
330  int64_t tmp_match;
331 
332  ff_put_v(bc, nut->version);
333  if (nut->version > 3)
334  ff_put_v(bc, nut->minor_version = 1);
335  ff_put_v(bc, nut->avf->nb_streams);
336  ff_put_v(bc, nut->max_distance);
337  ff_put_v(bc, nut->time_base_count);
338 
339  for (i = 0; i < nut->time_base_count; i++) {
340  ff_put_v(bc, nut->time_base[i].num);
341  ff_put_v(bc, nut->time_base[i].den);
342  }
343 
344  tmp_pts = 0;
345  tmp_mul = 1;
346  tmp_stream = 0;
347  tmp_match = 1 - (1LL << 62);
348  tmp_head_idx = 0;
349  for (i = 0; i < 256; ) {
350  tmp_fields = 0;
351  tmp_size = 0;
352 // tmp_res=0;
353  if (tmp_pts != nut->frame_code[i].pts_delta ) tmp_fields = 1;
354  if (tmp_mul != nut->frame_code[i].size_mul ) tmp_fields = 2;
355  if (tmp_stream != nut->frame_code[i].stream_id ) tmp_fields = 3;
356  if (tmp_size != nut->frame_code[i].size_lsb ) tmp_fields = 4;
357 // if (tmp_res != nut->frame_code[i].res ) tmp_fields=5;
358  if (tmp_head_idx != nut->frame_code[i].header_idx) tmp_fields = 8;
359 
360  tmp_pts = nut->frame_code[i].pts_delta;
361  tmp_flags = nut->frame_code[i].flags;
362  tmp_stream = nut->frame_code[i].stream_id;
363  tmp_mul = nut->frame_code[i].size_mul;
364  tmp_size = nut->frame_code[i].size_lsb;
365 // tmp_res = nut->frame_code[i].res;
366  tmp_head_idx = nut->frame_code[i].header_idx;
367 
368  for (j = 0; i < 256; j++, i++) {
369  if (i == 'N') {
370  j--;
371  continue;
372  }
373  if (nut->frame_code[i].pts_delta != tmp_pts ||
374  nut->frame_code[i].flags != tmp_flags ||
375  nut->frame_code[i].stream_id != tmp_stream ||
376  nut->frame_code[i].size_mul != tmp_mul ||
377  nut->frame_code[i].size_lsb != tmp_size + j ||
378 // nut->frame_code[i].res != tmp_res ||
379  nut->frame_code[i].header_idx != tmp_head_idx)
380  break;
381  }
382  if (j != tmp_mul - tmp_size)
383  tmp_fields = 6;
384 
385  ff_put_v(bc, tmp_flags);
386  ff_put_v(bc, tmp_fields);
387  if (tmp_fields > 0) put_s(bc, tmp_pts);
388  if (tmp_fields > 1) ff_put_v(bc, tmp_mul);
389  if (tmp_fields > 2) ff_put_v(bc, tmp_stream);
390  if (tmp_fields > 3) ff_put_v(bc, tmp_size);
391  if (tmp_fields > 4) ff_put_v(bc, 0 /*tmp_res*/);
392  if (tmp_fields > 5) ff_put_v(bc, j);
393  if (tmp_fields > 6) ff_put_v(bc, tmp_match);
394  if (tmp_fields > 7) ff_put_v(bc, tmp_head_idx);
395  }
396  ff_put_v(bc, nut->header_count - 1);
397  for (i = 1; i < nut->header_count; i++) {
398  ff_put_v(bc, nut->header_len[i]);
399  avio_write(bc, nut->header[i], nut->header_len[i]);
400  }
401  // flags had been effectively introduced in version 4
402  if (nut->version > 3)
403  ff_put_v(bc, nut->flags);
404 }
405 
407  AVStream *st, int i)
408 {
409  NUTContext *nut = avctx->priv_data;
410  AVCodecParameters *par = st->codecpar;
411 
412  ff_put_v(bc, i);
413  switch (par->codec_type) {
414  case AVMEDIA_TYPE_VIDEO: ff_put_v(bc, 0); break;
415  case AVMEDIA_TYPE_AUDIO: ff_put_v(bc, 1); break;
416  case AVMEDIA_TYPE_SUBTITLE: ff_put_v(bc, 2); break;
417  default: ff_put_v(bc, 3); break;
418  }
419  ff_put_v(bc, 4);
420 
421  if (par->codec_tag) {
422  avio_wl32(bc, par->codec_tag);
423  } else {
424  av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
425  return AVERROR(EINVAL);
426  }
427 
428  ff_put_v(bc, nut->stream[i].time_base - nut->time_base);
429  ff_put_v(bc, nut->stream[i].msb_pts_shift);
430  ff_put_v(bc, nut->stream[i].max_pts_distance);
431  ff_put_v(bc, par->video_delay);
432  avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
433 
434  ff_put_v(bc, par->extradata_size);
435  avio_write(bc, par->extradata, par->extradata_size);
436 
437  switch (par->codec_type) {
438  case AVMEDIA_TYPE_AUDIO:
439  ff_put_v(bc, par->sample_rate);
440  ff_put_v(bc, 1);
441  ff_put_v(bc, par->channels);
442  break;
443  case AVMEDIA_TYPE_VIDEO:
444  ff_put_v(bc, par->width);
445  ff_put_v(bc, par->height);
446 
447  if (st->sample_aspect_ratio.num <= 0 ||
448  st->sample_aspect_ratio.den <= 0) {
449  ff_put_v(bc, 0);
450  ff_put_v(bc, 0);
451  } else {
454  }
455  ff_put_v(bc, 0); /* csp type -- unknown */
456  break;
457  default:
458  break;
459  }
460  return 0;
461 }
462 
463 static int add_info(AVIOContext *bc, const char *type, const char *value)
464 {
465  put_str(bc, type);
466  put_s(bc, -1);
467  put_str(bc, value);
468  return 1;
469 }
470 
472 {
473  AVFormatContext *s = nut->avf;
474  AVDictionaryEntry *t = NULL;
475  AVIOContext *dyn_bc;
476  uint8_t *dyn_buf = NULL;
477  int count = 0, dyn_size;
478  int ret = avio_open_dyn_buf(&dyn_bc);
479  if (ret < 0)
480  return ret;
481 
483  while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
484  count += add_info(dyn_bc, t->key, t->value);
485 
486  ff_put_v(bc, 0); //stream_if_plus1
487  ff_put_v(bc, 0); //chapter_id
488  ff_put_v(bc, 0); //timestamp_start
489  ff_put_v(bc, 0); //length
490 
491  ff_put_v(bc, count);
492 
493  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
494  avio_write(bc, dyn_buf, dyn_size);
495  av_free(dyn_buf);
496  return 0;
497 }
498 
499 static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id) {
500  AVFormatContext *s= nut->avf;
501  AVStream* st = s->streams[stream_id];
502  AVDictionaryEntry *t = NULL;
503  AVIOContext *dyn_bc;
504  uint8_t *dyn_buf=NULL;
505  int count=0, dyn_size, i;
506  int ret = avio_open_dyn_buf(&dyn_bc);
507  if (ret < 0)
508  return ret;
509 
510  while ((t = av_dict_get(st->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
511  count += add_info(dyn_bc, t->key, t->value);
512  for (i=0; ff_nut_dispositions[i].flag; ++i) {
513  if (st->disposition & ff_nut_dispositions[i].flag)
514  count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
515  }
516  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
517  uint8_t buf[256];
518  if (st->r_frame_rate.num>0 && st->r_frame_rate.den>0)
519  snprintf(buf, sizeof(buf), "%d/%d", st->r_frame_rate.num, st->r_frame_rate.den);
520  else
521  snprintf(buf, sizeof(buf), "%d/%d", st->avg_frame_rate.num, st->avg_frame_rate.den);
522  count += add_info(dyn_bc, "r_frame_rate", buf);
523  }
524  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
525 
526  if (count) {
527  ff_put_v(bc, stream_id + 1); //stream_id_plus1
528  ff_put_v(bc, 0); //chapter_id
529  ff_put_v(bc, 0); //timestamp_start
530  ff_put_v(bc, 0); //length
531 
532  ff_put_v(bc, count);
533 
534  avio_write(bc, dyn_buf, dyn_size);
535  }
536 
537  av_free(dyn_buf);
538  return count;
539 }
540 
541 static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
542 {
543  AVIOContext *dyn_bc;
544  uint8_t *dyn_buf = NULL;
545  AVDictionaryEntry *t = NULL;
546  AVChapter *ch = nut->avf->chapters[id];
547  int ret, dyn_size, count = 0;
548 
549  ret = avio_open_dyn_buf(&dyn_bc);
550  if (ret < 0)
551  return ret;
552 
553  ff_put_v(bc, 0); // stream_id_plus1
554  put_s(bc, id + 1); // chapter_id
555  put_tt(nut, nut->chapter[id].time_base, bc, ch->start); // chapter_start
556  ff_put_v(bc, ch->end - ch->start); // chapter_len
557 
558  while ((t = av_dict_get(ch->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
559  count += add_info(dyn_bc, t->key, t->value);
560 
561  ff_put_v(bc, count);
562 
563  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
564  avio_write(bc, dyn_buf, dyn_size);
565  av_freep(&dyn_buf);
566  return 0;
567 }
568 
569 static int write_index(NUTContext *nut, AVIOContext *bc) {
570  int i;
571  Syncpoint dummy= { .pos= 0 };
572  Syncpoint *next_node[2] = { NULL };
573  int64_t startpos = avio_tell(bc);
574  int64_t payload_size;
575 
576  put_tt(nut, nut->max_pts_tb, bc, nut->max_pts);
577 
578  ff_put_v(bc, nut->sp_count);
579 
580  for (i=0; i<nut->sp_count; i++) {
581  av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp, (void**)next_node);
582  ff_put_v(bc, (next_node[1]->pos >> 4) - (dummy.pos>>4));
583  dummy.pos = next_node[1]->pos;
584  }
585 
586  for (i=0; i<nut->avf->nb_streams; i++) {
587  StreamContext *nus= &nut->stream[i];
588  int64_t last_pts= -1;
589  int j, k;
590  for (j=0; j<nut->sp_count; j++) {
591  int flag;
592  int n = 0;
593 
594  if (j && nus->keyframe_pts[j] == nus->keyframe_pts[j-1]) {
595  av_log(nut->avf, AV_LOG_WARNING, "Multiple keyframes with same PTS\n");
596  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
597  }
598 
599  flag = (nus->keyframe_pts[j] != AV_NOPTS_VALUE) ^ (j+1 == nut->sp_count);
600  for (; j<nut->sp_count && (nus->keyframe_pts[j] != AV_NOPTS_VALUE) == flag; j++)
601  n++;
602 
603  ff_put_v(bc, 1 + 2*flag + 4*n);
604  for (k= j - n; k<=j && k<nut->sp_count; k++) {
605  if (nus->keyframe_pts[k] == AV_NOPTS_VALUE)
606  continue;
607  av_assert0(nus->keyframe_pts[k] > last_pts);
608  ff_put_v(bc, nus->keyframe_pts[k] - last_pts);
609  last_pts = nus->keyframe_pts[k];
610  }
611  }
612  }
613 
614  payload_size = avio_tell(bc) - startpos + 8 + 4;
615 
616  avio_wb64(bc, 8 + payload_size + av_log2(payload_size) / 7 + 1 + 4*(payload_size > 4096));
617 
618  return 0;
619 }
620 
622 {
623  NUTContext *nut = avctx->priv_data;
624  AVIOContext *dyn_bc;
625  int i, ret;
626 
628 
629  ret = avio_open_dyn_buf(&dyn_bc);
630  if (ret < 0)
631  return ret;
632  write_mainheader(nut, dyn_bc);
633  put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE);
634 
635  for (i = 0; i < nut->avf->nb_streams; i++) {
636  ret = avio_open_dyn_buf(&dyn_bc);
637  if (ret < 0)
638  return ret;
639  ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i);
640  if (ret < 0)
641  return ret;
642  put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE);
643  }
644 
645  ret = avio_open_dyn_buf(&dyn_bc);
646  if (ret < 0)
647  return ret;
648  write_globalinfo(nut, dyn_bc);
649  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
650 
651  for (i = 0; i < nut->avf->nb_streams; i++) {
652  ret = avio_open_dyn_buf(&dyn_bc);
653  if (ret < 0)
654  return ret;
655  ret = write_streaminfo(nut, dyn_bc, i);
656  if (ret < 0)
657  return ret;
658  if (ret > 0)
659  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
660  else
661  ffio_free_dyn_buf(&dyn_bc);
662  }
663 
664  for (i = 0; i < nut->avf->nb_chapters; i++) {
665  ret = avio_open_dyn_buf(&dyn_bc);
666  if (ret < 0)
667  return ret;
668  ret = write_chapter(nut, dyn_bc, i);
669  if (ret < 0) {
670  ffio_free_dyn_buf(&dyn_bc);
671  return ret;
672  }
673  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
674  }
675 
676  nut->last_syncpoint_pos = INT_MIN;
677  nut->header_count++;
678  return 0;
679 }
680 
682 {
683  NUTContext *nut = s->priv_data;
684  AVIOContext *bc = s->pb;
685  int i, j, ret;
686 
687  nut->avf = s;
688 
689  nut->version = FFMAX(NUT_STABLE_VERSION, 3 + !!nut->flags);
691  av_log(s, AV_LOG_ERROR,
692  "The additional syncpoint modes require version %d, "
693  "that is currently not finalized, "
694  "please set -f_strict experimental in order to enable it.\n",
695  nut->version);
696  return AVERROR_EXPERIMENTAL;
697  }
698 
699  nut->stream = av_calloc(s->nb_streams, sizeof(*nut->stream ));
700  nut->chapter = av_calloc(s->nb_chapters, sizeof(*nut->chapter));
701  nut->time_base= av_calloc(s->nb_streams +
702  s->nb_chapters, sizeof(*nut->time_base));
703  if (!nut->stream || !nut->chapter || !nut->time_base) {
704  av_freep(&nut->stream);
705  av_freep(&nut->chapter);
706  av_freep(&nut->time_base);
707  return AVERROR(ENOMEM);
708  }
709 
710  for (i = 0; i < s->nb_streams; i++) {
711  AVStream *st = s->streams[i];
712  int ssize;
713  AVRational time_base;
714  ff_parse_specific_params(st, &time_base.den, &ssize, &time_base.num);
715 
717  time_base = (AVRational) {1, st->codecpar->sample_rate};
718  } else {
719  time_base = ff_choose_timebase(s, st, 48000);
720  }
721 
722  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
723 
724  for (j = 0; j < nut->time_base_count; j++)
725  if (!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))) {
726  break;
727  }
728  nut->time_base[j] = time_base;
729  nut->stream[i].time_base = &nut->time_base[j];
730  if (j == nut->time_base_count)
731  nut->time_base_count++;
732 
733  if (INT64_C(1000) * time_base.num >= time_base.den)
734  nut->stream[i].msb_pts_shift = 7;
735  else
736  nut->stream[i].msb_pts_shift = 14;
737  nut->stream[i].max_pts_distance =
738  FFMAX(time_base.den, time_base.num) / time_base.num;
739  }
740 
741  for (i = 0; i < s->nb_chapters; i++) {
742  AVChapter *ch = s->chapters[i];
743 
744  for (j = 0; j < nut->time_base_count; j++)
745  if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational)))
746  break;
747 
748  nut->time_base[j] = ch->time_base;
749  nut->chapter[i].time_base = &nut->time_base[j];
750  if (j == nut->time_base_count)
751  nut->time_base_count++;
752  }
753 
754  nut->max_distance = MAX_DISTANCE;
756  build_frame_code(s);
757  av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
758 
759  avio_write(bc, ID_STRING, strlen(ID_STRING));
760  avio_w8(bc, 0);
761 
762  if ((ret = write_headers(s, bc)) < 0)
763  return ret;
764 
765  if (s->avoid_negative_ts < 0)
766  s->avoid_negative_ts = 1;
767 
768  avio_flush(bc);
769 
770  return 0;
771 }
772 
774  AVPacket *pkt)
775 {
776  int flags = 0;
777 
778  if (pkt->flags & AV_PKT_FLAG_KEY)
779  flags |= FLAG_KEY;
780  if (pkt->stream_index != fc->stream_id)
781  flags |= FLAG_STREAM_ID;
782  if (pkt->size / fc->size_mul)
783  flags |= FLAG_SIZE_MSB;
784  if (pkt->pts - nus->last_pts != fc->pts_delta)
785  flags |= FLAG_CODED_PTS;
786  if (pkt->side_data_elems && nut->version > 3)
787  flags |= FLAG_SM_DATA;
788  if (pkt->size > 2 * nut->max_distance)
789  flags |= FLAG_CHECKSUM;
790  if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
791  flags |= FLAG_CHECKSUM;
792  if (pkt->size < nut->header_len[fc->header_idx] ||
793  (pkt->size > 4096 && fc->header_idx) ||
794  memcmp(pkt->data, nut->header[fc->header_idx],
795  nut->header_len[fc->header_idx]))
796  flags |= FLAG_HEADER_IDX;
797 
798  return flags | (fc->flags & FLAG_CODED);
799 }
800 
802 {
803  int i;
804  int best_i = 0;
805  int best_len = 0;
806 
807  if (pkt->size > 4096)
808  return 0;
809 
810  for (i = 1; i < nut->header_count; i++)
811  if (pkt->size >= nut->header_len[i]
812  && nut->header_len[i] > best_len
813  && !memcmp(pkt->data, nut->header[i], nut->header_len[i])) {
814  best_i = i;
815  best_len = nut->header_len[i];
816  }
817  return best_i;
818 }
819 
820 static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
821 {
822  int ret, i, dyn_size;
823  unsigned flags;
824  AVIOContext *dyn_bc;
825  int sm_data_count = 0;
826  uint8_t tmp[256];
827  uint8_t *dyn_buf;
828 
829  ret = avio_open_dyn_buf(&dyn_bc);
830  if (ret < 0)
831  return ret;
832 
833  for (i = 0; i<pkt->side_data_elems; i++) {
834  const uint8_t *data = pkt->side_data[i].data;
835  int size = pkt->side_data[i].size;
836  const uint8_t *data_end = data + size;
837 
838  if (is_meta) {
841  if (!size || data[size-1]) {
842  ret = AVERROR(EINVAL);
843  goto fail;
844  }
845  while (data < data_end) {
846  const uint8_t *key = data;
847  const uint8_t *val = data + strlen(key) + 1;
848 
849  if(val >= data_end) {
850  ret = AVERROR(EINVAL);
851  goto fail;
852  }
853  put_str(dyn_bc, key);
854  put_s(dyn_bc, -1);
855  put_str(dyn_bc, val);
856  data = val + strlen(val) + 1;
857  sm_data_count++;
858  }
859  }
860  } else {
861  switch (pkt->side_data[i].type) {
862  case AV_PKT_DATA_PALETTE:
865  default:
866  if (pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
867  put_str(dyn_bc, "Palette");
868  } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
869  put_str(dyn_bc, "Extradata");
870  } else if(pkt->side_data[i].type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
871  snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
872  put_str(dyn_bc, tmp);
873  } else {
874  snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
875  (s->flags & AVFMT_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
876  pkt->side_data[i].type);
877  put_str(dyn_bc, tmp);
878  }
879  put_s(dyn_bc, -2);
880  put_str(dyn_bc, "bin");
881  ff_put_v(dyn_bc, pkt->side_data[i].size);
882  avio_write(dyn_bc, data, pkt->side_data[i].size);
883  sm_data_count++;
884  break;
886  flags = bytestream_get_le32(&data);
888  put_str(dyn_bc, "Channels");
889  put_s(dyn_bc, bytestream_get_le32(&data));
890  sm_data_count++;
891  }
893  put_str(dyn_bc, "ChannelLayout");
894  put_s(dyn_bc, -2);
895  put_str(dyn_bc, "u64");
896  ff_put_v(bc, 8);
897  avio_write(dyn_bc, data, 8); data+=8;
898  sm_data_count++;
899  }
901  put_str(dyn_bc, "SampleRate");
902  put_s(dyn_bc, bytestream_get_le32(&data));
903  sm_data_count++;
904  }
906  put_str(dyn_bc, "Width");
907  put_s(dyn_bc, bytestream_get_le32(&data));
908  put_str(dyn_bc, "Height");
909  put_s(dyn_bc, bytestream_get_le32(&data));
910  sm_data_count+=2;
911  }
912  break;
914  if (AV_RL32(data)) {
915  put_str(dyn_bc, "SkipStart");
916  put_s(dyn_bc, (unsigned)AV_RL32(data));
917  sm_data_count++;
918  }
919  if (AV_RL32(data+4)) {
920  put_str(dyn_bc, "SkipEnd");
921  put_s(dyn_bc, (unsigned)AV_RL32(data+4));
922  sm_data_count++;
923  }
924  break;
928  // belongs into meta, not side data
929  break;
930  }
931  }
932  }
933 
934 fail:
935  ff_put_v(bc, sm_data_count);
936  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
937  avio_write(bc, dyn_buf, dyn_size);
938  av_freep(&dyn_buf);
939 
940  return ret;
941 }
942 
944 {
945  NUTContext *nut = s->priv_data;
946  StreamContext *nus = &nut->stream[pkt->stream_index];
947  AVIOContext *bc = s->pb, *dyn_bc, *sm_bc = NULL;
948  FrameCode *fc;
949  int64_t coded_pts;
950  int best_length, frame_code, flags, needed_flags, i, header_idx;
951  int best_header_idx;
952  int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
953  int store_sp = 0;
954  int ret = 0;
955  int sm_size = 0;
956  int data_size = pkt->size;
957  uint8_t *sm_buf = NULL;
958 
959  if (pkt->pts < 0) {
960  av_log(s, AV_LOG_ERROR,
961  "Negative pts not supported stream %d, pts %"PRId64"\n",
962  pkt->stream_index, pkt->pts);
963  if (pkt->pts == AV_NOPTS_VALUE)
964  av_log(s, AV_LOG_ERROR, "Try to enable the genpts flag\n");
965  return AVERROR(EINVAL);
966  }
967 
968  if (pkt->side_data_elems && nut->version > 3) {
969  ret = avio_open_dyn_buf(&sm_bc);
970  if (ret < 0)
971  return ret;
972  ret = write_sm_data(s, sm_bc, pkt, 0);
973  if (ret >= 0)
974  ret = write_sm_data(s, sm_bc, pkt, 1);
975  sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
976  if (ret < 0)
977  goto fail;
978  data_size += sm_size;
979  }
980 
981  if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
982  write_headers(s, bc);
983 
984  if (key_frame && !(nus->last_flags & FLAG_KEY))
985  store_sp = 1;
986 
987  if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
988  store_sp = 1;
989 
990 //FIXME: Ensure store_sp is 1 in the first place.
991 
992  if (store_sp &&
993  (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) {
994  int64_t sp_pos = INT64_MAX;
995 
996  ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
997  for (i = 0; i < s->nb_streams; i++) {
998  AVStream *st = s->streams[i];
999  int64_t dts_tb = av_rescale_rnd(pkt->dts,
1000  nus->time_base->num * (int64_t)nut->stream[i].time_base->den,
1001  nus->time_base->den * (int64_t)nut->stream[i].time_base->num,
1002  AV_ROUND_DOWN);
1003  int index = av_index_search_timestamp(st, dts_tb,
1005  if (index >= 0) {
1006  sp_pos = FFMIN(sp_pos, st->index_entries[index].pos);
1007  if (!nut->write_index && 2*index > st->nb_index_entries) {
1008  memmove(st->index_entries,
1009  st->index_entries + index,
1010  sizeof(*st->index_entries) * (st->nb_index_entries - index));
1011  st->nb_index_entries -= index;
1012  }
1013  }
1014  }
1015 
1016  nut->last_syncpoint_pos = avio_tell(bc);
1017  ret = avio_open_dyn_buf(&dyn_bc);
1018  if (ret < 0)
1019  goto fail;
1020  put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
1021  ff_put_v(dyn_bc, sp_pos != INT64_MAX ? (nut->last_syncpoint_pos - sp_pos) >> 4 : 0);
1022 
1023  if (nut->flags & NUT_BROADCAST) {
1024  put_tt(nut, nus->time_base, dyn_bc,
1026  }
1027  put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
1028 
1029  if (nut->write_index) {
1030  if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0)
1031  goto fail;
1032 
1033  if ((1ll<<60) % nut->sp_count == 0)
1034  for (i=0; i<s->nb_streams; i++) {
1035  int j;
1036  StreamContext *nus = &nut->stream[i];
1037  av_reallocp_array(&nus->keyframe_pts, 2*nut->sp_count, sizeof(*nus->keyframe_pts));
1038  if (!nus->keyframe_pts) {
1039  ret = AVERROR(ENOMEM);
1040  goto fail;
1041  }
1042  for (j=nut->sp_count == 1 ? 0 : nut->sp_count; j<2*nut->sp_count; j++)
1043  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
1044  }
1045  }
1046  }
1048 
1049  coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
1050  if (ff_lsb2full(nus, coded_pts) != pkt->pts)
1051  coded_pts = pkt->pts + (1 << nus->msb_pts_shift);
1052 
1053  best_header_idx = find_best_header_idx(nut, pkt);
1054 
1055  best_length = INT_MAX;
1056  frame_code = -1;
1057  for (i = 0; i < 256; i++) {
1058  int length = 0;
1059  FrameCode *fc = &nut->frame_code[i];
1060  int flags = fc->flags;
1061 
1062  if (flags & FLAG_INVALID)
1063  continue;
1064  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1065 
1066  if (flags & FLAG_CODED) {
1067  length++;
1068  flags = needed_flags;
1069  }
1070 
1071  if ((flags & needed_flags) != needed_flags)
1072  continue;
1073 
1074  if ((flags ^ needed_flags) & FLAG_KEY)
1075  continue;
1076 
1077  if (flags & FLAG_STREAM_ID)
1078  length += ff_get_v_length(pkt->stream_index);
1079 
1080  if (data_size % fc->size_mul != fc->size_lsb)
1081  continue;
1082  if (flags & FLAG_SIZE_MSB)
1083  length += ff_get_v_length(data_size / fc->size_mul);
1084 
1085  if (flags & FLAG_CHECKSUM)
1086  length += 4;
1087 
1088  if (flags & FLAG_CODED_PTS)
1089  length += ff_get_v_length(coded_pts);
1090 
1091  if ( (flags & FLAG_CODED)
1092  && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx] + 1) {
1093  flags |= FLAG_HEADER_IDX;
1094  }
1095 
1096  if (flags & FLAG_HEADER_IDX) {
1097  length += 1 - nut->header_len[best_header_idx];
1098  } else {
1099  length -= nut->header_len[fc->header_idx];
1100  }
1101 
1102  length *= 4;
1103  length += !(flags & FLAG_CODED_PTS);
1104  length += !(flags & FLAG_CHECKSUM);
1105 
1106  if (length < best_length) {
1107  best_length = length;
1108  frame_code = i;
1109  }
1110  }
1111  av_assert0(frame_code != -1);
1112 
1113  fc = &nut->frame_code[frame_code];
1114  flags = fc->flags;
1115  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1116  header_idx = fc->header_idx;
1117 
1119  avio_w8(bc, frame_code);
1120  if (flags & FLAG_CODED) {
1121  ff_put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
1122  flags = needed_flags;
1123  }
1124  if (flags & FLAG_STREAM_ID) ff_put_v(bc, pkt->stream_index);
1125  if (flags & FLAG_CODED_PTS) ff_put_v(bc, coded_pts);
1126  if (flags & FLAG_SIZE_MSB ) ff_put_v(bc, data_size / fc->size_mul);
1127  if (flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx = best_header_idx);
1128 
1129  if (flags & FLAG_CHECKSUM) avio_wl32(bc, ffio_get_checksum(bc));
1130  else ffio_get_checksum(bc);
1131 
1132  if (flags & FLAG_SM_DATA) {
1133  avio_write(bc, sm_buf, sm_size);
1134  }
1135  avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
1136 
1137  nus->last_flags = flags;
1138  nus->last_pts = pkt->pts;
1139 
1140  //FIXME just store one per syncpoint
1141  if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) {
1143  s->streams[pkt->stream_index],
1144  nut->last_syncpoint_pos,
1145  pkt->pts,
1146  0,
1147  0,
1149  if (nus->keyframe_pts && nus->keyframe_pts[nut->sp_count] == AV_NOPTS_VALUE)
1150  nus->keyframe_pts[nut->sp_count] = pkt->pts;
1151  }
1152 
1153  if (!nut->max_pts_tb || av_compare_ts(nut->max_pts, *nut->max_pts_tb, pkt->pts, *nus->time_base) < 0) {
1154  nut->max_pts = pkt->pts;
1155  nut->max_pts_tb = nus->time_base;
1156  }
1157 
1158 fail:
1159  av_freep(&sm_buf);
1160 
1161  return ret;
1162 }
1163 
1165 {
1166  NUTContext *nut = s->priv_data;
1167  AVIOContext *bc = s->pb, *dyn_bc;
1168  int ret;
1169 
1170  while (nut->header_count < 3)
1171  write_headers(s, bc);
1172 
1173  ret = avio_open_dyn_buf(&dyn_bc);
1174  if (ret >= 0 && nut->sp_count) {
1175  av_assert1(nut->write_index); // sp_count should be 0 if no index is going to be written
1176  write_index(nut, dyn_bc);
1177  put_packet(nut, bc, dyn_bc, 1, INDEX_STARTCODE);
1178  }
1179 
1180  return 0;
1181 }
1182 
1184 {
1185  NUTContext *nut = s->priv_data;
1186  int i;
1187 
1188  ff_nut_free_sp(nut);
1189  if (nut->stream)
1190  for (i=0; i<s->nb_streams; i++)
1191  av_freep(&nut->stream[i].keyframe_pts);
1192 
1193  av_freep(&nut->stream);
1194  av_freep(&nut->chapter);
1195  av_freep(&nut->time_base);
1196 }
1197 
1198 #define OFFSET(x) offsetof(NUTContext, x)
1199 #define E AV_OPT_FLAG_ENCODING_PARAM
1200 static const AVOption options[] = {
1201  { "syncpoints", "NUT syncpoint behaviour", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1202  { "default", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1203  { "none", "Disable syncpoints, low overhead and unseekable", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E, "syncpoints" },
1204  { "timestamped", "Extend syncpoints with a wallclock timestamp", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, "syncpoints" },
1205  { "write_index", "Write index", OFFSET(write_index), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E, },
1206  { NULL },
1207 };
1208 
1209 static const AVClass class = {
1210  .class_name = "nutenc",
1211  .item_name = av_default_item_name,
1212  .option = options,
1214 };
1215 
1217  .name = "nut",
1218  .long_name = NULL_IF_CONFIG_SMALL("NUT"),
1219  .mime_type = "video/x-nut",
1220  .extensions = "nut",
1221  .priv_data_size = sizeof(NUTContext),
1222  .audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
1223  CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
1224  .video_codec = AV_CODEC_ID_MPEG4,
1228  .deinit = nut_write_deinit,
1230  .codec_tag = ff_nut_codec_tags,
1231  .priv_class = &class,
1232 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2633
#define NUT_STABLE_VERSION
Definition: nut.h:40
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2511
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
uint8_t header_len[128]
Definition: nut.h:97
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
Bytestream IO Context.
Definition: avio.h:161
#define MAIN_STARTCODE
Definition: nut.h:29
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
A list of zero terminated key/value strings.
Definition: avcodec.h:1353
int64_t last_syncpoint_pos
Definition: nut.h:104
Definition: nut.h:65
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1413
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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: utils.c:2039
static void nut_write_deinit(AVFormatContext *s)
Definition: nutenc.c:1183
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4886
int64_t pos
Definition: avformat.h:810
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
Definition: nut.h:58
int av_log2(unsigned v)
Definition: intmath.c:26
GLint GLenum type
Definition: opengl_enc.c:104
void * av_tree_find(const AVTreeNode *t, void *key, int(*cmp)(const void *key, const void *b), void *next[2])
Definition: tree.c:39
const char * key
static AVPacket pkt
Definition: nut.h:91
int ff_nut_sp_pos_cmp(const void *a, const void *b)
Definition: nut.c:269
uint8_t stream_id
Definition: nut.h:67
AVDictionary * metadata
Definition: avformat.h:1319
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1384
mpeg audio layer common tables.
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1666
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
const uint8_t * header[128]
Definition: nut.h:98
Format I/O context.
Definition: avformat.h:1358
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:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
int write_index
Definition: nut.h:110
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:369
uint8_t
AVRational * time_base
Definition: nut.h:107
int width
Video only.
Definition: avcodec.h:4023
uint16_t flags
Definition: nut.h:66
AVOptions.
A tree container.
#define ID_STRING
Definition: ffmeta.h:25
static void build_elision_headers(AVFormatContext *s)
Definition: nutenc.c:122
#define f(width, name)
Definition: cbs_vp9.c:255
static void build_frame_code(AVFormatContext *s)
Definition: nutenc.c:144
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
static const AVOption options[]
Definition: nutenc.c:1200
const uint16_t avpriv_mpa_freq_tab[3]
Definition: mpegaudiodata.c:40
static int64_t last_pts
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define STREAM_STARTCODE
Definition: nut.h:30
static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val)
Definition: nutenc.c:280
#define NUT_PIPE
Definition: nut.h:114
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
const AVMetadataConv ff_nut_metadata_conv[]
Definition: nut.c:330
static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nutenc.c:943
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
uint8_t * data
Definition: avcodec.h:1477
int last_flags
Definition: nut.h:76
#define MAX_DISTANCE
Definition: nut.h:37
uint8_t * data
Definition: avcodec.h:1421
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
#define av_log(a,...)
AVFormatContext * avf
Definition: nut.h:93
int64_t last_pts
Definition: nut.h:78
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
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
AVOutputFormat ff_nut_muxer
Definition: nutenc.c:1216
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
void ff_nut_free_sp(NUTContext *nut)
Definition: nut.c:312
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2148
void ff_parse_specific_params(AVStream *st, int *au_rate, int *au_ssize, int *au_scale)
Definition: riffenc.c:265
#define NUT_BROADCAST
Definition: nut.h:113
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: avcodec.h:1216
static int nut_write_header(AVFormatContext *s)
Definition: nutenc.c:681
uint64_t pos
Definition: nut.h:59
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int video_delay
Video only.
Definition: avcodec.h:4052
#define OFFSET(x)
Definition: nutenc.c:1198
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVChapter ** chapters
Definition: avformat.h:1588
static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
Definition: nutenc.c:541
simple assert() macros that are a bit more flexible than ISO C assert().
enum AVPacketSideDataType type
Definition: avcodec.h:1423
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int sp_count
Definition: nut.h:109
int header_count
Definition: nut.h:106
int side_data_elems
Definition: avcodec.h:1489
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5670
GLsizei count
Definition: opengl_enc.c:108
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
#define FFMAX(a, b)
Definition: common.h:94
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:1726
#define fail()
Definition: checkasm.h:120
Definition: nut.h:44
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
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
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:205
int intra_only
Definition: mxfenc.c:2219
static void write_mainheader(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:326
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
#define LIBAVFORMAT_IDENT
Definition: version.h:46
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:626
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
AVRational * max_pts_tb
Definition: nut.h:112
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
void ff_nut_reset_ts(NUTContext *nut, AVRational time_base, int64_t val)
Definition: nut.c:251
int flags
Definition: nut.h:115
#define FFMIN(a, b)
Definition: common.h:96
#define E
Definition: nutenc.c:1199
uint8_t header_idx
Definition: nut.h:72
AVRational time_base
Definition: signature.h:103
This side data contains quality related information from the encoder.
Definition: avcodec.h:1276
uint16_t size_lsb
Definition: nut.h:69
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:600
int16_t pts_delta
Definition: nut.h:70
int64_t * keyframe_pts
Definition: nut.h:84
int64_t ff_lsb2full(StreamContext *stream, int64_t lsb)
Definition: nut.c:262
const char * name
Definition: avformat.h:505
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
struct AVTreeNode * syncpoints
Definition: nut.h:108
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1689
ChapterContext * chapter
Definition: nut.h:101
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:945
int dummy
Definition: motion.c:64
#define INDEX_STARTCODE
Definition: nut.h:32
uint16_t size_mul
Definition: nut.h:68
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
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
static int write_globalinfo(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:471
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:72
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1443
if(ret)
static const float pred[4]
Definition: siprdata.h:259
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
Stream structure.
Definition: avformat.h:881
int msb_pts_shift
Definition: nut.h:81
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1318
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1199
sample_rate
int frame_size
Definition: mxfenc.c:2216
A list of zero terminated key/value strings.
Definition: avcodec.h:1316
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
int max_pts_distance
Definition: nut.h:82
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id)
Definition: nutenc.c:499
static int write_index(NUTContext *nut, AVIOContext *bc)
Definition: nutenc.c:569
static int find_expected_header(AVCodecParameters *p, int size, int key_frame, uint8_t out[64])
Definition: nutenc.c:38
Definition: nut.h:54
void * buf
Definition: avisynth_c.h:766
Data found in BlockAdditional element of matroska container.
Definition: avcodec.h:1335
AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:102
int nb_index_entries
Definition: avformat.h:1112
static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
Definition: nutenc.c:820
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
int index
Definition: gxfenc.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int nut_write_trailer(AVFormatContext *s)
Definition: nutenc.c:1164
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1300
AVRational * time_base
Definition: nut.h:88
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:618
StreamContext * stream
Definition: nut.h:100
#define snprintf
Definition: snprintf.h:34
static void put_s(AVIOContext *bc, int64_t val)
Definition: nutenc.c:297
static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, AVStream *st, int i)
Definition: nutenc.c:406
Round toward -infinity.
Definition: mathematics.h:82
#define INFO_STARTCODE
Definition: nut.h:33
static int64_t pts
int ff_get_v_length(uint64_t val)
Get the length in bytes which is needed to store val as v.
Definition: aviobuf.c:437
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int version
Definition: nut.h:116
static int write_headers(AVFormatContext *avctx, AVIOContext *bc)
Definition: nutenc.c:621
int64_t start
Definition: avformat.h:1318
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: avcodec.h:4067
const Dispositions ff_nut_dispositions[]
Definition: nut.c:320
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:87
int64_t max_pts
Definition: nut.h:111
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: avcodec.h:1488
static int find_best_header_idx(NUTContext *nut, AVPacket *pkt)
Definition: nutenc.c:801
#define flag(name)
Definition: cbs_av1.c:553
FrameCode frame_code[256]
Definition: nut.h:96
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
int ff_nut_add_sp(NUTContext *nut, int64_t pos, int64_t back_ptr, int64_t ts)
Definition: nut.c:281
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1317
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define SYNCPOINT_STARTCODE
Definition: nut.h:31
int flag
Definition: nut.h:130
static void put_str(AVIOContext *bc, const char *string)
Store a string as vb.
Definition: nutenc.c:289
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
#define av_free(p)
char * value
Definition: dict.h:87
static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, int calculate_checksum, uint64_t startcode)
Definition: nutenc.c:303
void ff_put_v(AVIOContext *bc, uint64_t val)
Put val using a variable number of bytes.
Definition: aviobuf.c:447
int len
void * priv_data
Format private data.
Definition: avformat.h:1386
static int get_needed_flags(NUTContext *nut, StreamContext *nus, FrameCode *fc, AVPacket *pkt)
Definition: nutenc.c:773
static int find_header_idx(AVFormatContext *s, AVCodecParameters *p, int size, int frame_type)
Definition: nutenc.c:105
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
int channels
Audio only.
Definition: avcodec.h:4063
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
FILE * out
Definition: movenc.c:54
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
static int add_info(AVIOContext *bc, const char *type, const char *value)
Definition: nutenc.c:463
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
const uint16_t avpriv_mpa_bitrate_tab[2][3][15]
Definition: mpegaudiodata.c:30
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
int stream_index
Definition: avcodec.h:1479
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:1
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
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
const AVCodecTag *const ff_nut_codec_tags[]
Definition: nut.c:246
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1454
unsigned int time_base_count
Definition: nut.h:103
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
int minor_version
Definition: nut.h:117
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
unsigned int max_distance
Definition: nut.h:102
static uint8_t tmp[11]
Definition: aes_ctr.c:26