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  return AVERROR(ENOMEM);
708 
709  for (i = 0; i < s->nb_streams; i++) {
710  AVStream *st = s->streams[i];
711  int ssize;
712  AVRational time_base;
713  ff_parse_specific_params(st, &time_base.den, &ssize, &time_base.num);
714 
716  time_base = (AVRational) {1, st->codecpar->sample_rate};
717  } else {
718  time_base = ff_choose_timebase(s, st, 48000);
719  }
720 
721  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
722 
723  for (j = 0; j < nut->time_base_count; j++)
724  if (!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))) {
725  break;
726  }
727  nut->time_base[j] = time_base;
728  nut->stream[i].time_base = &nut->time_base[j];
729  if (j == nut->time_base_count)
730  nut->time_base_count++;
731 
732  if (INT64_C(1000) * time_base.num >= time_base.den)
733  nut->stream[i].msb_pts_shift = 7;
734  else
735  nut->stream[i].msb_pts_shift = 14;
736  nut->stream[i].max_pts_distance =
737  FFMAX(time_base.den, time_base.num) / time_base.num;
738  }
739 
740  for (i = 0; i < s->nb_chapters; i++) {
741  AVChapter *ch = s->chapters[i];
742 
743  for (j = 0; j < nut->time_base_count; j++)
744  if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational)))
745  break;
746 
747  nut->time_base[j] = ch->time_base;
748  nut->chapter[i].time_base = &nut->time_base[j];
749  if (j == nut->time_base_count)
750  nut->time_base_count++;
751  }
752 
753  nut->max_distance = MAX_DISTANCE;
755  build_frame_code(s);
756  av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
757 
758  avio_write(bc, ID_STRING, strlen(ID_STRING));
759  avio_w8(bc, 0);
760 
761  if ((ret = write_headers(s, bc)) < 0)
762  return ret;
763 
764  if (s->avoid_negative_ts < 0)
765  s->avoid_negative_ts = 1;
766 
767  return 0;
768 }
769 
771  AVPacket *pkt)
772 {
773  int flags = 0;
774 
775  if (pkt->flags & AV_PKT_FLAG_KEY)
776  flags |= FLAG_KEY;
777  if (pkt->stream_index != fc->stream_id)
778  flags |= FLAG_STREAM_ID;
779  if (pkt->size / fc->size_mul)
780  flags |= FLAG_SIZE_MSB;
781  if (pkt->pts - nus->last_pts != fc->pts_delta)
782  flags |= FLAG_CODED_PTS;
783  if (pkt->side_data_elems && nut->version > 3)
784  flags |= FLAG_SM_DATA;
785  if (pkt->size > 2 * nut->max_distance)
786  flags |= FLAG_CHECKSUM;
787  if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
788  flags |= FLAG_CHECKSUM;
789  if (fc->header_idx)
790  if (pkt->size < nut->header_len[fc->header_idx] ||
791  pkt->size > 4096 ||
792  memcmp(pkt->data, nut->header [fc->header_idx],
793  nut->header_len[fc->header_idx]))
794  flags |= FLAG_HEADER_IDX;
795 
796  return flags | (fc->flags & FLAG_CODED);
797 }
798 
800 {
801  int i;
802  int best_i = 0;
803  int best_len = 0;
804 
805  if (pkt->size > 4096)
806  return 0;
807 
808  for (i = 1; i < nut->header_count; i++)
809  if (pkt->size >= nut->header_len[i]
810  && nut->header_len[i] > best_len
811  && !memcmp(pkt->data, nut->header[i], nut->header_len[i])) {
812  best_i = i;
813  best_len = nut->header_len[i];
814  }
815  return best_i;
816 }
817 
818 static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
819 {
820  int ret, i, dyn_size;
821  unsigned flags;
822  AVIOContext *dyn_bc;
823  int sm_data_count = 0;
824  uint8_t tmp[256];
825  uint8_t *dyn_buf;
826 
827  ret = avio_open_dyn_buf(&dyn_bc);
828  if (ret < 0)
829  return ret;
830 
831  for (i = 0; i<pkt->side_data_elems; i++) {
832  const uint8_t *data = pkt->side_data[i].data;
833  int size = pkt->side_data[i].size;
834  const uint8_t *data_end = data + size;
835 
836  if (is_meta) {
839  if (!size || data[size-1]) {
840  ret = AVERROR(EINVAL);
841  goto fail;
842  }
843  while (data < data_end) {
844  const uint8_t *key = data;
845  const uint8_t *val = data + strlen(key) + 1;
846 
847  if(val >= data_end) {
848  ret = AVERROR(EINVAL);
849  goto fail;
850  }
851  put_str(dyn_bc, key);
852  put_s(dyn_bc, -1);
853  put_str(dyn_bc, val);
854  data = val + strlen(val) + 1;
855  sm_data_count++;
856  }
857  }
858  } else {
859  switch (pkt->side_data[i].type) {
860  case AV_PKT_DATA_PALETTE:
863  default:
864  if (pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
865  put_str(dyn_bc, "Palette");
866  } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
867  put_str(dyn_bc, "Extradata");
868  } else if(pkt->side_data[i].type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
869  snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
870  put_str(dyn_bc, tmp);
871  } else {
872  snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
873  (s->flags & AVFMT_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
874  pkt->side_data[i].type);
875  put_str(dyn_bc, tmp);
876  }
877  put_s(dyn_bc, -2);
878  put_str(dyn_bc, "bin");
879  ff_put_v(dyn_bc, pkt->side_data[i].size);
880  avio_write(dyn_bc, data, pkt->side_data[i].size);
881  sm_data_count++;
882  break;
884  flags = bytestream_get_le32(&data);
886  put_str(dyn_bc, "Channels");
887  put_s(dyn_bc, bytestream_get_le32(&data));
888  sm_data_count++;
889  }
891  put_str(dyn_bc, "ChannelLayout");
892  put_s(dyn_bc, -2);
893  put_str(dyn_bc, "u64");
894  ff_put_v(bc, 8);
895  avio_write(dyn_bc, data, 8); data+=8;
896  sm_data_count++;
897  }
899  put_str(dyn_bc, "SampleRate");
900  put_s(dyn_bc, bytestream_get_le32(&data));
901  sm_data_count++;
902  }
904  put_str(dyn_bc, "Width");
905  put_s(dyn_bc, bytestream_get_le32(&data));
906  put_str(dyn_bc, "Height");
907  put_s(dyn_bc, bytestream_get_le32(&data));
908  sm_data_count+=2;
909  }
910  break;
912  if (AV_RL32(data)) {
913  put_str(dyn_bc, "SkipStart");
914  put_s(dyn_bc, (unsigned)AV_RL32(data));
915  sm_data_count++;
916  }
917  if (AV_RL32(data+4)) {
918  put_str(dyn_bc, "SkipEnd");
919  put_s(dyn_bc, (unsigned)AV_RL32(data+4));
920  sm_data_count++;
921  }
922  break;
926  // belongs into meta, not side data
927  break;
928  }
929  }
930  }
931 
932 fail:
933  ff_put_v(bc, sm_data_count);
934  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
935  avio_write(bc, dyn_buf, dyn_size);
936  av_freep(&dyn_buf);
937 
938  return ret;
939 }
940 
942 {
943  NUTContext *nut = s->priv_data;
944  StreamContext *nus = &nut->stream[pkt->stream_index];
945  AVIOContext *bc = s->pb, *dyn_bc, *sm_bc = NULL;
946  FrameCode *fc;
947  int64_t coded_pts;
948  int best_length, frame_code, flags, needed_flags, i, header_idx;
949  int best_header_idx;
950  int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
951  int store_sp = 0;
952  int ret = 0;
953  int sm_size = 0;
954  int data_size = pkt->size;
955  uint8_t *sm_buf = NULL;
956 
957  if (pkt->pts < 0) {
958  av_log(s, AV_LOG_ERROR,
959  "Negative pts not supported stream %d, pts %"PRId64"\n",
960  pkt->stream_index, pkt->pts);
961  if (pkt->pts == AV_NOPTS_VALUE)
962  av_log(s, AV_LOG_ERROR, "Try to enable the genpts flag\n");
963  return AVERROR(EINVAL);
964  }
965 
966  if (pkt->side_data_elems && nut->version > 3) {
967  ret = avio_open_dyn_buf(&sm_bc);
968  if (ret < 0)
969  return ret;
970  ret = write_sm_data(s, sm_bc, pkt, 0);
971  if (ret >= 0)
972  ret = write_sm_data(s, sm_bc, pkt, 1);
973  sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
974  if (ret < 0)
975  goto fail;
976  data_size += sm_size;
977  }
978 
979  if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
980  write_headers(s, bc);
981 
982  if (key_frame && !(nus->last_flags & FLAG_KEY))
983  store_sp = 1;
984 
985  if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
986  store_sp = 1;
987 
988 //FIXME: Ensure store_sp is 1 in the first place.
989 
990  if (store_sp &&
991  (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) {
992  int64_t sp_pos = INT64_MAX;
993 
994  ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
995  for (i = 0; i < s->nb_streams; i++) {
996  AVStream *st = s->streams[i];
997  int64_t dts_tb = av_rescale_rnd(pkt->dts,
998  nus->time_base->num * (int64_t)nut->stream[i].time_base->den,
999  nus->time_base->den * (int64_t)nut->stream[i].time_base->num,
1000  AV_ROUND_DOWN);
1001  int index = av_index_search_timestamp(st, dts_tb,
1003  if (index >= 0) {
1004  sp_pos = FFMIN(sp_pos, st->index_entries[index].pos);
1005  if (!nut->write_index && 2*index > st->nb_index_entries) {
1006  memmove(st->index_entries,
1007  st->index_entries + index,
1008  sizeof(*st->index_entries) * (st->nb_index_entries - index));
1009  st->nb_index_entries -= index;
1010  }
1011  }
1012  }
1013 
1014  nut->last_syncpoint_pos = avio_tell(bc);
1015  ret = avio_open_dyn_buf(&dyn_bc);
1016  if (ret < 0)
1017  goto fail;
1018  put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
1019  ff_put_v(dyn_bc, sp_pos != INT64_MAX ? (nut->last_syncpoint_pos - sp_pos) >> 4 : 0);
1020 
1021  if (nut->flags & NUT_BROADCAST) {
1022  put_tt(nut, nus->time_base, dyn_bc,
1024  }
1025  put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
1026 
1027  if (nut->write_index) {
1028  if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0)
1029  goto fail;
1030 
1031  if ((1ll<<60) % nut->sp_count == 0)
1032  for (i=0; i<s->nb_streams; i++) {
1033  int j;
1034  StreamContext *nus = &nut->stream[i];
1035  av_reallocp_array(&nus->keyframe_pts, 2*nut->sp_count, sizeof(*nus->keyframe_pts));
1036  if (!nus->keyframe_pts) {
1037  ret = AVERROR(ENOMEM);
1038  goto fail;
1039  }
1040  for (j=nut->sp_count == 1 ? 0 : nut->sp_count; j<2*nut->sp_count; j++)
1041  nus->keyframe_pts[j] = AV_NOPTS_VALUE;
1042  }
1043  }
1044  }
1046 
1047  coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
1048  if (ff_lsb2full(nus, coded_pts) != pkt->pts)
1049  coded_pts = pkt->pts + (1 << nus->msb_pts_shift);
1050 
1051  best_header_idx = find_best_header_idx(nut, pkt);
1052 
1053  best_length = INT_MAX;
1054  frame_code = -1;
1055  for (i = 0; i < 256; i++) {
1056  int length = 0;
1057  FrameCode *fc = &nut->frame_code[i];
1058  int flags = fc->flags;
1059 
1060  if (flags & FLAG_INVALID)
1061  continue;
1062  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1063 
1064  if (flags & FLAG_CODED) {
1065  length++;
1066  flags = needed_flags;
1067  }
1068 
1069  if ((flags & needed_flags) != needed_flags)
1070  continue;
1071 
1072  if ((flags ^ needed_flags) & FLAG_KEY)
1073  continue;
1074 
1075  if (flags & FLAG_STREAM_ID)
1076  length += ff_get_v_length(pkt->stream_index);
1077 
1078  if (data_size % fc->size_mul != fc->size_lsb)
1079  continue;
1080  if (flags & FLAG_SIZE_MSB)
1081  length += ff_get_v_length(data_size / fc->size_mul);
1082 
1083  if (flags & FLAG_CHECKSUM)
1084  length += 4;
1085 
1086  if (flags & FLAG_CODED_PTS)
1087  length += ff_get_v_length(coded_pts);
1088 
1089  if ( (flags & FLAG_CODED)
1090  && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx] + 1) {
1091  flags |= FLAG_HEADER_IDX;
1092  }
1093 
1094  if (flags & FLAG_HEADER_IDX) {
1095  length += 1 - nut->header_len[best_header_idx];
1096  } else {
1097  length -= nut->header_len[fc->header_idx];
1098  }
1099 
1100  length *= 4;
1101  length += !(flags & FLAG_CODED_PTS);
1102  length += !(flags & FLAG_CHECKSUM);
1103 
1104  if (length < best_length) {
1105  best_length = length;
1106  frame_code = i;
1107  }
1108  }
1109  av_assert0(frame_code != -1);
1110 
1111  fc = &nut->frame_code[frame_code];
1112  flags = fc->flags;
1113  needed_flags = get_needed_flags(nut, nus, fc, pkt);
1114  header_idx = fc->header_idx;
1115 
1117  avio_w8(bc, frame_code);
1118  if (flags & FLAG_CODED) {
1119  ff_put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
1120  flags = needed_flags;
1121  }
1122  if (flags & FLAG_STREAM_ID) ff_put_v(bc, pkt->stream_index);
1123  if (flags & FLAG_CODED_PTS) ff_put_v(bc, coded_pts);
1124  if (flags & FLAG_SIZE_MSB ) ff_put_v(bc, data_size / fc->size_mul);
1125  if (flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx = best_header_idx);
1126 
1127  if (flags & FLAG_CHECKSUM) avio_wl32(bc, ffio_get_checksum(bc));
1128  else ffio_get_checksum(bc);
1129 
1130  if (flags & FLAG_SM_DATA) {
1131  avio_write(bc, sm_buf, sm_size);
1132  }
1133  avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
1134 
1135  nus->last_flags = flags;
1136  nus->last_pts = pkt->pts;
1137 
1138  //FIXME just store one per syncpoint
1139  if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) {
1141  s->streams[pkt->stream_index],
1142  nut->last_syncpoint_pos,
1143  pkt->pts,
1144  0,
1145  0,
1147  if (nus->keyframe_pts && nus->keyframe_pts[nut->sp_count] == AV_NOPTS_VALUE)
1148  nus->keyframe_pts[nut->sp_count] = pkt->pts;
1149  }
1150 
1151  if (!nut->max_pts_tb || av_compare_ts(nut->max_pts, *nut->max_pts_tb, pkt->pts, *nus->time_base) < 0) {
1152  nut->max_pts = pkt->pts;
1153  nut->max_pts_tb = nus->time_base;
1154  }
1155 
1156 fail:
1157  av_freep(&sm_buf);
1158 
1159  return ret;
1160 }
1161 
1163 {
1164  NUTContext *nut = s->priv_data;
1165  AVIOContext *bc = s->pb, *dyn_bc;
1166  int ret;
1167 
1168  while (nut->header_count < 3)
1169  write_headers(s, bc);
1170 
1171  if (!nut->sp_count)
1172  return 0;
1173 
1174  ret = avio_open_dyn_buf(&dyn_bc);
1175  if (ret >= 0) {
1176  av_assert1(nut->write_index); // sp_count should be 0 if no index is going to be written
1177  write_index(nut, dyn_bc);
1178  put_packet(nut, bc, dyn_bc, 1, INDEX_STARTCODE);
1179  }
1180 
1181  return 0;
1182 }
1183 
1185 {
1186  NUTContext *nut = s->priv_data;
1187  int i;
1188 
1189  ff_nut_free_sp(nut);
1190  if (nut->stream)
1191  for (i=0; i<s->nb_streams; i++)
1192  av_freep(&nut->stream[i].keyframe_pts);
1193 
1194  av_freep(&nut->stream);
1195  av_freep(&nut->chapter);
1196  av_freep(&nut->time_base);
1197 }
1198 
1199 #define OFFSET(x) offsetof(NUTContext, x)
1200 #define E AV_OPT_FLAG_ENCODING_PARAM
1201 static const AVOption options[] = {
1202  { "syncpoints", "NUT syncpoint behaviour", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1203  { "default", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" },
1204  { "none", "Disable syncpoints, low overhead and unseekable", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E, "syncpoints" },
1205  { "timestamped", "Extend syncpoints with a wallclock timestamp", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, "syncpoints" },
1206  { "write_index", "Write index", OFFSET(write_index), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E, },
1207  { NULL },
1208 };
1209 
1210 static const AVClass class = {
1211  .class_name = "nutenc",
1212  .item_name = av_default_item_name,
1213  .option = options,
1215 };
1216 
1218  .name = "nut",
1219  .long_name = NULL_IF_CONFIG_SMALL("NUT"),
1220  .mime_type = "video/x-nut",
1221  .extensions = "nut",
1222  .priv_data_size = sizeof(NUTContext),
1223  .audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
1224  CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
1225  .video_codec = AV_CODEC_ID_MPEG4,
1229  .deinit = nut_write_deinit,
1231  .codec_tag = ff_nut_codec_tags,
1232  .priv_class = &class,
1233 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1581
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2689
#define NUT_STABLE_VERSION
Definition: nut.h:40
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:698
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2515
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:461
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:1396
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:1410
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:1184
#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:4943
int64_t pos
Definition: avformat.h:804
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:937
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1534
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1104
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:1313
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1376
mpeg audio layer common tables.
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1660
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
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:1352
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:367
uint8_t
AVRational * time_base
Definition: nut.h:107
int width
Video only.
Definition: avcodec.h:4102
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:1201
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:1420
const AVMetadataConv ff_nut_metadata_conv[]
Definition: nut.c:332
static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: nutenc.c:941
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:1483
uint8_t * data
Definition: avcodec.h:1533
int last_flags
Definition: nut.h:76
#define MAX_DISTANCE
Definition: nut.h:37
uint8_t * data
Definition: avcodec.h:1477
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:213
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1500
#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:1565
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:1217
#define AVINDEX_KEYFRAME
Definition: avformat.h:811
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:554
#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:1592
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:1233
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2166
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:1259
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:4131
unsigned int pos
Definition: spdifenc.c:410
#define OFFSET(x)
Definition: nutenc.c:1199
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:578
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
AVChapter ** chapters
Definition: avformat.h:1582
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:1479
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:1545
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5726
GLsizei count
Definition: opengl_enc.c:108
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:948
#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:1752
#define fail()
Definition: checkasm.h:122
Definition: nut.h:44
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
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:4054
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:2143
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:1408
#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:624
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:1200
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:1319
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:461
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:598
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:500
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:1683
ChapterContext * chapter
Definition: nut.h:101
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:939
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:222
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:1440
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:875
int msb_pts_shift
Definition: nut.h:81
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1312
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1242
sample_rate
int frame_size
Definition: mxfenc.c:2140
A list of zero terminated key/value strings.
Definition: avcodec.h:1359
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1394
int max_pts_distance
Definition: nut.h:82
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:191
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:1378
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:1106
static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
Definition: nutenc.c:818
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:1162
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1343
AVRational * time_base
Definition: nut.h:88
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:616
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:435
#define flags(name, subs,...)
Definition: cbs_av1.c:564
int version
Definition: nut.h:116
static int write_headers(AVFormatContext *avctx, AVIOContext *bc)
Definition: nutenc.c:621
int64_t start
Definition: avformat.h:1312
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:4146
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:1544
static int find_best_header_idx(NUTContext *nut, AVPacket *pkt)
Definition: nutenc.c:799
#define flag(name)
Definition: cbs_av1.c:556
FrameCode frame_code[256]
Definition: nut.h:96
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:928
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:1311
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:465
#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:445
int len
void * priv_data
Format private data.
Definition: avformat.h:1380
static int get_needed_flags(NUTContext *nut, StreamContext *nus, FrameCode *fc, AVPacket *pkt)
Definition: nutenc.c:770
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:346
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
int channels
Audio only.
Definition: avcodec.h:4142
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
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:1022
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:4040
int stream_index
Definition: avcodec.h:1535
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:999
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:1510
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:1526
int minor_version
Definition: nut.h:117
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
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
unsigned int max_distance
Definition: nut.h:102
static uint8_t tmp[11]
Definition: aes_ctr.c:26