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  ffio_free_dyn_buf(&dyn_bc);
642  return ret;
643  }
644  put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE);
645  }
646 
647  ret = avio_open_dyn_buf(&dyn_bc);
648  if (ret < 0)
649  return ret;
650  write_globalinfo(nut, dyn_bc);
651  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
652 
653  for (i = 0; i < nut->avf->nb_streams; i++) {
654  ret = avio_open_dyn_buf(&dyn_bc);
655  if (ret < 0)
656  return ret;
657  ret = write_streaminfo(nut, dyn_bc, i);
658  if (ret > 0)
659  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
660  else {
661  ffio_free_dyn_buf(&dyn_bc);
662  if (ret < 0)
663  return ret;
664  }
665  }
666 
667  for (i = 0; i < nut->avf->nb_chapters; i++) {
668  ret = avio_open_dyn_buf(&dyn_bc);
669  if (ret < 0)
670  return ret;
671  ret = write_chapter(nut, dyn_bc, i);
672  if (ret < 0) {
673  ffio_free_dyn_buf(&dyn_bc);
674  return ret;
675  }
676  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
677  }
678 
679  nut->last_syncpoint_pos = INT_MIN;
680  nut->header_count++;
681  return 0;
682 }
683 
685 {
686  NUTContext *nut = s->priv_data;
687  AVIOContext *bc = s->pb;
688  int i, j, ret;
689 
690  nut->avf = s;
691 
692  nut->version = FFMAX(NUT_STABLE_VERSION, 3 + !!nut->flags);
694  av_log(s, AV_LOG_ERROR,
695  "The additional syncpoint modes require version %d, "
696  "that is currently not finalized, "
697  "please set -f_strict experimental in order to enable it.\n",
698  nut->version);
699  return AVERROR_EXPERIMENTAL;
700  }
701 
702  nut->stream = av_calloc(s->nb_streams, sizeof(*nut->stream ));
703  nut->chapter = av_calloc(s->nb_chapters, sizeof(*nut->chapter));
704  nut->time_base= av_calloc(s->nb_streams +
705  s->nb_chapters, sizeof(*nut->time_base));
706  if (!nut->stream || !nut->chapter || !nut->time_base) {
707  av_freep(&nut->stream);
708  av_freep(&nut->chapter);
709  av_freep(&nut->time_base);
710  return AVERROR(ENOMEM);
711  }
712 
713  for (i = 0; i < s->nb_streams; i++) {
714  AVStream *st = s->streams[i];
715  int ssize;
716  AVRational time_base;
717  ff_parse_specific_params(st, &time_base.den, &ssize, &time_base.num);
718 
720  time_base = (AVRational) {1, st->codecpar->sample_rate};
721  } else {
722  time_base = ff_choose_timebase(s, st, 48000);
723  }
724 
725  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
726 
727  for (j = 0; j < nut->time_base_count; j++)
728  if (!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))) {
729  break;
730  }
731  nut->time_base[j] = time_base;
732  nut->stream[i].time_base = &nut->time_base[j];
733  if (j == nut->time_base_count)
734  nut->time_base_count++;
735 
736  if (INT64_C(1000) * time_base.num >= time_base.den)
737  nut->stream[i].msb_pts_shift = 7;
738  else
739  nut->stream[i].msb_pts_shift = 14;
740  nut->stream[i].max_pts_distance =
741  FFMAX(time_base.den, time_base.num) / time_base.num;
742  }
743 
744  for (i = 0; i < s->nb_chapters; i++) {
745  AVChapter *ch = s->chapters[i];
746 
747  for (j = 0; j < nut->time_base_count; j++)
748  if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational)))
749  break;
750 
751  nut->time_base[j] = ch->time_base;
752  nut->chapter[i].time_base = &nut->time_base[j];
753  if (j == nut->time_base_count)
754  nut->time_base_count++;
755  }
756 
757  nut->max_distance = MAX_DISTANCE;
759  build_frame_code(s);
760  av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
761 
762  avio_write(bc, ID_STRING, strlen(ID_STRING));
763  avio_w8(bc, 0);
764 
765  if ((ret = write_headers(s, bc)) < 0)
766  return ret;
767 
768  if (s->avoid_negative_ts < 0)
769  s->avoid_negative_ts = 1;
770 
771  avio_flush(bc);
772 
773  return 0;
774 }
775 
777  AVPacket *pkt)
778 {
779  int flags = 0;
780 
781  if (pkt->flags & AV_PKT_FLAG_KEY)
782  flags |= FLAG_KEY;
783  if (pkt->stream_index != fc->stream_id)
784  flags |= FLAG_STREAM_ID;
785  if (pkt->size / fc->size_mul)
786  flags |= FLAG_SIZE_MSB;
787  if (pkt->pts - nus->last_pts != fc->pts_delta)
788  flags |= FLAG_CODED_PTS;
789  if (pkt->side_data_elems && nut->version > 3)
790  flags |= FLAG_SM_DATA;
791  if (pkt->size > 2 * nut->max_distance)
792  flags |= FLAG_CHECKSUM;
793  if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
794  flags |= FLAG_CHECKSUM;
795  if (fc->header_idx)
796  if (pkt->size < nut->header_len[fc->header_idx] ||
797  pkt->size > 4096 ||
798  memcmp(pkt->data, nut->header [fc->header_idx],
799  nut->header_len[fc->header_idx]))
800  flags |= FLAG_HEADER_IDX;
801 
802  return flags | (fc->flags & FLAG_CODED);
803 }
804 
806 {
807  int i;
808  int best_i = 0;
809  int best_len = 0;
810 
811  if (pkt->size > 4096)
812  return 0;
813 
814  for (i = 1; i < nut->header_count; i++)
815  if (pkt->size >= nut->header_len[i]
816  && nut->header_len[i] > best_len
817  && !memcmp(pkt->data, nut->header[i], nut->header_len[i])) {
818  best_i = i;
819  best_len = nut->header_len[i];
820  }
821  return best_i;
822 }
823 
824 static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
825 {
826  int ret, i, dyn_size;
827  unsigned flags;
828  AVIOContext *dyn_bc;
829  int sm_data_count = 0;
830  uint8_t tmp[256];
831  uint8_t *dyn_buf;
832 
833  ret = avio_open_dyn_buf(&dyn_bc);
834  if (ret < 0)
835  return ret;
836 
837  for (i = 0; i<pkt->side_data_elems; i++) {
838  const uint8_t *data = pkt->side_data[i].data;
839  int size = pkt->side_data[i].size;
840  const uint8_t *data_end = data + size;
841 
842  if (is_meta) {
845  if (!size || data[size-1]) {
846  ret = AVERROR(EINVAL);
847  goto fail;
848  }
849  while (data < data_end) {
850  const uint8_t *key = data;
851  const uint8_t *val = data + strlen(key) + 1;
852 
853  if(val >= data_end) {
854  ret = AVERROR(EINVAL);
855  goto fail;
856  }
857  put_str(dyn_bc, key);
858  put_s(dyn_bc, -1);
859  put_str(dyn_bc, val);
860  data = val + strlen(val) + 1;
861  sm_data_count++;
862  }
863  }
864  } else {
865  switch (pkt->side_data[i].type) {
866  case AV_PKT_DATA_PALETTE:
869  default:
870  if (pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
871  put_str(dyn_bc, "Palette");
872  } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
873  put_str(dyn_bc, "Extradata");
874  } else if(pkt->side_data[i].type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
875  snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
876  put_str(dyn_bc, tmp);
877  } else {
878  snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
879  (s->flags & AVFMT_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
880  pkt->side_data[i].type);
881  put_str(dyn_bc, tmp);
882  }
883  put_s(dyn_bc, -2);
884  put_str(dyn_bc, "bin");
885  ff_put_v(dyn_bc, pkt->side_data[i].size);
886  avio_write(dyn_bc, data, pkt->side_data[i].size);
887  sm_data_count++;
888  break;
890  flags = bytestream_get_le32(&data);
892  put_str(dyn_bc, "Channels");
893  put_s(dyn_bc, bytestream_get_le32(&data));
894  sm_data_count++;
895  }
897  put_str(dyn_bc, "ChannelLayout");
898  put_s(dyn_bc, -2);
899  put_str(dyn_bc, "u64");
900  ff_put_v(bc, 8);
901  avio_write(dyn_bc, data, 8); data+=8;
902  sm_data_count++;
903  }
905  put_str(dyn_bc, "SampleRate");
906  put_s(dyn_bc, bytestream_get_le32(&data));
907  sm_data_count++;
908  }
910  put_str(dyn_bc, "Width");
911  put_s(dyn_bc, bytestream_get_le32(&data));
912  put_str(dyn_bc, "Height");
913  put_s(dyn_bc, bytestream_get_le32(&data));
914  sm_data_count+=2;
915  }
916  break;
918  if (AV_RL32(data)) {
919  put_str(dyn_bc, "SkipStart");
920  put_s(dyn_bc, (unsigned)AV_RL32(data));
921  sm_data_count++;
922  }
923  if (AV_RL32(data+4)) {
924  put_str(dyn_bc, "SkipEnd");
925  put_s(dyn_bc, (unsigned)AV_RL32(data+4));
926  sm_data_count++;
927  }
928  break;
932  // belongs into meta, not side data
933  break;
934  }
935  }
936  }
937 
938 fail:
939  ff_put_v(bc, sm_data_count);
940  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
941  avio_write(bc, dyn_buf, dyn_size);
942  av_freep(&dyn_buf);
943 
944  return ret;
945 }
946 
948 {
949  NUTContext *nut = s->priv_data;
950  StreamContext *nus = &nut->stream[pkt->stream_index];
951  AVIOContext *bc = s->pb, *dyn_bc, *sm_bc = NULL;
952  FrameCode *fc;
953  int64_t coded_pts;
954  int best_length, frame_code, flags, needed_flags, i, header_idx;
955  int best_header_idx;
956  int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
957  int store_sp = 0;
958  int ret = 0;
959  int sm_size = 0;
960  int data_size = pkt->size;
961  uint8_t *sm_buf = NULL;
962 
963  if (pkt->pts < 0) {
964  av_log(s, AV_LOG_ERROR,
965  "Negative pts not supported stream %d, pts %"PRId64"\n",
966  pkt->stream_index, pkt->pts);
967  if (pkt->pts == AV_NOPTS_VALUE)
968  av_log(s, AV_LOG_ERROR, "Try to enable the genpts flag\n");
969  return AVERROR(EINVAL);
970  }
971 
972  if (pkt->side_data_elems && nut->version > 3) {
973  ret = avio_open_dyn_buf(&sm_bc);
974  if (ret < 0)
975  return ret;
976  ret = write_sm_data(s, sm_bc, pkt, 0);
977  if (ret >= 0)
978  ret = write_sm_data(s, sm_bc, pkt, 1);
979  sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
980  if (ret < 0)
981  goto fail;
982  data_size += sm_size;
983  }
984 
985  if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
986  write_headers(s, bc);
987 
988  if (key_frame && !(nus->last_flags & FLAG_KEY))
989  store_sp = 1;
990 
991  if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
992  store_sp = 1;
993 
994 //FIXME: Ensure store_sp is 1 in the first place.
995 
996  if (store_sp &&
997  (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) {
998  int64_t sp_pos = INT64_MAX;
999 
1000  ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
1001  for (i = 0; i < s->nb_streams; i++) {
1002  AVStream *st = s->streams[i];
1003  int64_t dts_tb = av_rescale_rnd(pkt->dts,
1004  nus->time_base->num * (int64_t)nut->stream[i].time_base->den,
1005  nus->time_base->den * (int64_t)nut->stream[i].time_base->num,
1006  AV_ROUND_DOWN);
1007  int index = av_index_search_timestamp(st, dts_tb,
1009  if (index >= 0) {
1010  sp_pos = FFMIN(sp_pos, st->index_entries[index].pos);
1011  if (!nut->write_index && 2*index > st->nb_index_entries) {
1012  memmove(st->index_entries,
1013  st->index_entries + index,
1014  sizeof(*st->index_entries) * (st->nb_index_entries - index));
1015  st->nb_index_entries -= index;
1016  }
1017  }
1018  }
1019 
1020  nut->last_syncpoint_pos = avio_tell(bc);
1021  ret = avio_open_dyn_buf(&dyn_bc);
1022  if (ret < 0)
1023  goto fail;
1024  put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
1025  ff_put_v(dyn_bc, sp_pos != INT64_MAX ? (nut->last_syncpoint_pos - sp_pos) >> 4 : 0);
1026 
1027  if (nut->flags & NUT_BROADCAST) {
1028  put_tt(nut, nus->time_base, dyn_bc,
1030  }
1031  put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
1032 
1033  if (nut->write_index) {
1034  if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0)
1035  goto fail;
1036 
1037  if ((1ll<<60) % nut->sp_count == 0)
1038  for (i=0; i<s->nb_streams; i++) {
1039  int j;
1040  StreamContext *nus = &nut->stream[i];
1041  av_reallocp_array(&nus->keyframe_pts, 2*nut->sp_count, sizeof(*nus->keyframe_pts));
1042  if (!nus->keyframe_pts) {
1043  ret = AVERROR(ENOMEM);
1044  goto fail;
1045  }
1046  for (j=nut->sp_count == 1 ? 0 : nut->sp_count; j<2*nut->sp_count; j++)
1047  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
1048  }
1049  }
1050  }
1052 
1053  coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
1054  if (ff_lsb2full(nus, coded_pts) != pkt->pts)
1055  coded_pts = pkt->pts + (1 << nus->msb_pts_shift);
1056 
1057  best_header_idx = find_best_header_idx(nut, pkt);
1058 
1059  best_length = INT_MAX;
1060  frame_code = -1;
1061  for (i = 0; i < 256; i++) {
1062  int length = 0;
1063  FrameCode *fc = &nut->frame_code[i];
1064  int flags = fc->flags;
1065 
1066  if (flags & FLAG_INVALID)
1067  continue;
1068  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1069 
1070  if (flags & FLAG_CODED) {
1071  length++;
1072  flags = needed_flags;
1073  }
1074 
1075  if ((flags & needed_flags) != needed_flags)
1076  continue;
1077 
1078  if ((flags ^ needed_flags) & FLAG_KEY)
1079  continue;
1080 
1081  if (flags & FLAG_STREAM_ID)
1082  length += ff_get_v_length(pkt->stream_index);
1083 
1084  if (data_size % fc->size_mul != fc->size_lsb)
1085  continue;
1086  if (flags & FLAG_SIZE_MSB)
1087  length += ff_get_v_length(data_size / fc->size_mul);
1088 
1089  if (flags & FLAG_CHECKSUM)
1090  length += 4;
1091 
1092  if (flags & FLAG_CODED_PTS)
1093  length += ff_get_v_length(coded_pts);
1094 
1095  if ( (flags & FLAG_CODED)
1096  && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx] + 1) {
1097  flags |= FLAG_HEADER_IDX;
1098  }
1099 
1100  if (flags & FLAG_HEADER_IDX) {
1101  length += 1 - nut->header_len[best_header_idx];
1102  } else {
1103  length -= nut->header_len[fc->header_idx];
1104  }
1105 
1106  length *= 4;
1107  length += !(flags & FLAG_CODED_PTS);
1108  length += !(flags & FLAG_CHECKSUM);
1109 
1110  if (length < best_length) {
1111  best_length = length;
1112  frame_code = i;
1113  }
1114  }
1115  av_assert0(frame_code != -1);
1116 
1117  fc = &nut->frame_code[frame_code];
1118  flags = fc->flags;
1119  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1120  header_idx = fc->header_idx;
1121 
1123  avio_w8(bc, frame_code);
1124  if (flags & FLAG_CODED) {
1125  ff_put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
1126  flags = needed_flags;
1127  }
1128  if (flags & FLAG_STREAM_ID) ff_put_v(bc, pkt->stream_index);
1129  if (flags & FLAG_CODED_PTS) ff_put_v(bc, coded_pts);
1130  if (flags & FLAG_SIZE_MSB ) ff_put_v(bc, data_size / fc->size_mul);
1131  if (flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx = best_header_idx);
1132 
1133  if (flags & FLAG_CHECKSUM) avio_wl32(bc, ffio_get_checksum(bc));
1134  else ffio_get_checksum(bc);
1135 
1136  if (flags & FLAG_SM_DATA) {
1137  avio_write(bc, sm_buf, sm_size);
1138  }
1139  avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
1140 
1141  nus->last_flags = flags;
1142  nus->last_pts = pkt->pts;
1143 
1144  //FIXME just store one per syncpoint
1145  if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) {
1147  s->streams[pkt->stream_index],
1148  nut->last_syncpoint_pos,
1149  pkt->pts,
1150  0,
1151  0,
1153  if (nus->keyframe_pts && nus->keyframe_pts[nut->sp_count] == AV_NOPTS_VALUE)
1154  nus->keyframe_pts[nut->sp_count] = pkt->pts;
1155  }
1156 
1157  if (!nut->max_pts_tb || av_compare_ts(nut->max_pts, *nut->max_pts_tb, pkt->pts, *nus->time_base) < 0) {
1158  nut->max_pts = pkt->pts;
1159  nut->max_pts_tb = nus->time_base;
1160  }
1161 
1162 fail:
1163  av_freep(&sm_buf);
1164 
1165  return ret;
1166 }
1167 
1169 {
1170  NUTContext *nut = s->priv_data;
1171  AVIOContext *bc = s->pb, *dyn_bc;
1172  int ret;
1173 
1174  while (nut->header_count < 3)
1175  write_headers(s, bc);
1176 
1177  if (!nut->sp_count)
1178  return 0;
1179 
1180  ret = avio_open_dyn_buf(&dyn_bc);
1181  if (ret >= 0) {
1182  av_assert1(nut->write_index); // sp_count should be 0 if no index is going to be written
1183  write_index(nut, dyn_bc);
1184  put_packet(nut, bc, dyn_bc, 1, INDEX_STARTCODE);
1185  }
1186 
1187  return 0;
1188 }
1189 
1191 {
1192  NUTContext *nut = s->priv_data;
1193  int i;
1194 
1195  ff_nut_free_sp(nut);
1196  if (nut->stream)
1197  for (i=0; i<s->nb_streams; i++)
1198  av_freep(&nut->stream[i].keyframe_pts);
1199 
1200  av_freep(&nut->stream);
1201  av_freep(&nut->chapter);
1202  av_freep(&nut->time_base);
1203 }
1204 
1205 #define OFFSET(x) offsetof(NUTContext, x)
1206 #define E AV_OPT_FLAG_ENCODING_PARAM
1207 static const AVOption options[] = {
1208  { "syncpoints", "NUT syncpoint behaviour", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1209  { "default", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1210  { "none", "Disable syncpoints, low overhead and unseekable", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E, "syncpoints" },
1211  { "timestamped", "Extend syncpoints with a wallclock timestamp", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, "syncpoints" },
1212  { "write_index", "Write index", OFFSET(write_index), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E, },
1213  { NULL },
1214 };
1215 
1216 static const AVClass class = {
1217  .class_name = "nutenc",
1218  .item_name = av_default_item_name,
1219  .option = options,
1221 };
1222 
1224  .name = "nut",
1225  .long_name = NULL_IF_CONFIG_SMALL("NUT"),
1226  .mime_type = "video/x-nut",
1227  .extensions = "nut",
1228  .priv_data_size = sizeof(NUTContext),
1229  .audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
1230  CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
1231  .video_codec = AV_CODEC_ID_MPEG4,
1235  .deinit = nut_write_deinit,
1237  .codec_tag = ff_nut_codec_tags,
1238  .priv_class = &class,
1239 };
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:2636
#define NUT_STABLE_VERSION
Definition: nut.h:40
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:690
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2518
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:466
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:1356
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:1459
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:2049
static void nut_write_deinit(AVFormatContext *s)
Definition: nutenc.c:1190
#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:4929
int64_t pos
Definition: avformat.h:810
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
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:1481
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:271
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:1430
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:3960
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:372
uint8_t
AVRational * time_base
Definition: nut.h:107
int width
Video only.
Definition: avcodec.h:4034
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:1207
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:332
static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nutenc.c:947
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:1480
int last_flags
Definition: nut.h:76
#define MAX_DISTANCE
Definition: nut.h:37
uint8_t * data
Definition: avcodec.h:1424
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:1512
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:1223
#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:314
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1193
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2164
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:1219
static int nut_write_header(AVFormatContext *s)
Definition: nutenc.c:684
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:4063
#define OFFSET(x)
Definition: nutenc.c:1205
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:566
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
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:1426
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:1492
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5713
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:1746
#define fail()
Definition: checkasm.h:122
Definition: nut.h:44
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
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:3986
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:2226
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:629
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:253
int flags
Definition: nut.h:115
#define FFMIN(a, b)
Definition: common.h:96
#define E
Definition: nutenc.c:1206
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:1279
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:603
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:264
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:1489
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:1202
sample_rate
int frame_size
Definition: mxfenc.c:2223
A list of zero terminated key/value strings.
Definition: avcodec.h:1319
#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:1338
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:824
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:1168
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1303
AVRational * time_base
Definition: nut.h:88
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:621
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
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
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/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_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 *(UINT64_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 *(UINT64_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
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:440
#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:4078
const Dispositions ff_nut_dispositions[]
Definition: nut.c:322
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:1491
static int find_best_header_idx(NUTContext *nut, AVPacket *pkt)
Definition: nutenc.c:805
#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:283
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:450
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:776
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:349
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
int channels
Audio only.
Definition: avcodec.h:4074
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
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:3972
int stream_index
Definition: avcodec.h:1482
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:248
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:1457
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:1473
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