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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/mathematics.h"
24 #include "libavutil/tree.h"
25 #include "libavutil/dict.h"
27 #include "nut.h"
28 #include "internal.h"
29 #include "avio_internal.h"
30 #include "riff.h"
31 
32 static int find_expected_header(AVCodecContext *c, int size, int key_frame,
33  uint8_t out[64])
34 {
35  int sample_rate = c->sample_rate;
36 
37  if (size > 4096)
38  return 0;
39 
40  AV_WB24(out, 1);
41 
42  if (c->codec_id == AV_CODEC_ID_MPEG4) {
43  if (key_frame) {
44  return 3;
45  } else {
46  out[3] = 0xB6;
47  return 4;
48  }
49  } else if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
51  return 3;
52  } else if (c->codec_id == AV_CODEC_ID_H264) {
53  return 3;
54  } else if (c->codec_id == AV_CODEC_ID_MP3 ||
55  c->codec_id == AV_CODEC_ID_MP2) {
56  int lsf, mpeg25, sample_rate_index, bitrate_index, frame_size;
57  int layer = c->codec_id == AV_CODEC_ID_MP3 ? 3 : 2;
58  unsigned int header = 0xFFF00000;
59 
60  lsf = sample_rate < (24000 + 32000) / 2;
61  mpeg25 = sample_rate < (12000 + 16000) / 2;
62  sample_rate <<= lsf + mpeg25;
63  if (sample_rate < (32000 + 44100) / 2)
64  sample_rate_index = 2;
65  else if (sample_rate < (44100 + 48000) / 2)
66  sample_rate_index = 0;
67  else
68  sample_rate_index = 1;
69 
70  sample_rate = avpriv_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25);
71 
72  for (bitrate_index = 2; bitrate_index < 30; bitrate_index++) {
73  frame_size =
74  avpriv_mpa_bitrate_tab[lsf][layer - 1][bitrate_index >> 1];
75  frame_size = (frame_size * 144000) / (sample_rate << lsf) +
76  (bitrate_index & 1);
77 
78  if (frame_size == size)
79  break;
80  }
81 
82  header |= (!lsf) << 19;
83  header |= (4 - layer) << 17;
84  header |= 1 << 16; //no crc
85  AV_WB32(out, header);
86  if (size <= 0)
87  return 2; //we guess there is no crc, if there is one the user clearly does not care about overhead
88  if (bitrate_index == 30)
89  return -1; //something is wrong ...
90 
91  header |= (bitrate_index >> 1) << 12;
92  header |= sample_rate_index << 10;
93  header |= (bitrate_index & 1) << 9;
94 
95  return 2; //FIXME actually put the needed ones in build_elision_headers()
96  return 3; //we guess that the private bit is not set
97 //FIXME the above assumptions should be checked, if these turn out false too often something should be done
98  }
99  return 0;
100 }
101 
103  int frame_type)
104 {
105  NUTContext *nut = s->priv_data;
106  uint8_t out[64];
107  int i;
108  int len = find_expected_header(c, size, frame_type, out);
109 
110  for (i = 1; i < nut->header_count; i++) {
111  if (len == nut->header_len[i] && !memcmp(out, nut->header[i], len)) {
112  return i;
113  }
114  }
115 
116  return 0;
117 }
118 
120 {
121  NUTContext *nut = s->priv_data;
122  int i;
123  //FIXME this is lame
124  //FIXME write a 2pass mode to find the maximal headers
125  static const uint8_t headers[][5] = {
126  { 3, 0x00, 0x00, 0x01 },
127  { 4, 0x00, 0x00, 0x01, 0xB6},
128  { 2, 0xFF, 0xFA }, //mp3+crc
129  { 2, 0xFF, 0xFB }, //mp3
130  { 2, 0xFF, 0xFC }, //mp2+crc
131  { 2, 0xFF, 0xFD }, //mp2
132  };
133 
134  nut->header_count = 7;
135  for (i = 1; i < nut->header_count; i++) {
136  nut->header_len[i] = headers[i - 1][0];
137  nut->header[i] = &headers[i - 1][1];
138  }
139 }
140 
142 {
143  NUTContext *nut = s->priv_data;
144  int key_frame, index, pred, stream_id;
145  int start = 1;
146  int end = 254;
147  int keyframe_0_esc = s->nb_streams > 2;
148  int pred_table[10];
149  FrameCode *ft;
150 
151  ft = &nut->frame_code[start];
152  ft->flags = FLAG_CODED;
153  ft->size_mul = 1;
154  ft->pts_delta = 1;
155  start++;
156 
157  if (keyframe_0_esc) {
158  /* keyframe = 0 escape */
159  FrameCode *ft = &nut->frame_code[start];
161  ft->size_mul = 1;
162  start++;
163  }
164 
165  for (stream_id = 0; stream_id < s->nb_streams; stream_id++) {
166  int start2 = start + (end - start) * stream_id / s->nb_streams;
167  int end2 = start + (end - start) * (stream_id + 1) / s->nb_streams;
168  AVCodecContext *codec = s->streams[stream_id]->codec;
169  int is_audio = codec->codec_type == AVMEDIA_TYPE_AUDIO;
170  int intra_only = /*codec->intra_only || */ is_audio;
171  int pred_count;
172 
173  for (key_frame = 0; key_frame < 2; key_frame++) {
174  if (!intra_only || !keyframe_0_esc || key_frame != 0) {
175  FrameCode *ft = &nut->frame_code[start2];
176  ft->flags = FLAG_KEY * key_frame;
178  ft->stream_id = stream_id;
179  ft->size_mul = 1;
180  if (is_audio)
181  ft->header_idx = find_header_idx(s, codec, -1, key_frame);
182  start2++;
183  }
184  }
185 
186  key_frame = intra_only;
187  if (is_audio) {
188  int frame_bytes = codec->frame_size * (int64_t)codec->bit_rate /
189  (8 * codec->sample_rate);
190  int pts;
191  for (pts = 0; pts < 2; pts++)
192  for (pred = 0; pred < 2; pred++) {
193  FrameCode *ft = &nut->frame_code[start2];
194  ft->flags = FLAG_KEY * key_frame;
195  ft->stream_id = stream_id;
196  ft->size_mul = frame_bytes + 2;
197  ft->size_lsb = frame_bytes + pred;
198  ft->pts_delta = pts;
199  ft->header_idx = find_header_idx(s, codec, frame_bytes + pred, key_frame);
200  start2++;
201  }
202  } else {
203  FrameCode *ft = &nut->frame_code[start2];
204  ft->flags = FLAG_KEY | FLAG_SIZE_MSB;
205  ft->stream_id = stream_id;
206  ft->size_mul = 1;
207  ft->pts_delta = 1;
208  start2++;
209  }
210 
211  if (codec->has_b_frames) {
212  pred_count = 5;
213  pred_table[0] = -2;
214  pred_table[1] = -1;
215  pred_table[2] = 1;
216  pred_table[3] = 3;
217  pred_table[4] = 4;
218  } else if (codec->codec_id == AV_CODEC_ID_VORBIS) {
219  pred_count = 3;
220  pred_table[0] = 2;
221  pred_table[1] = 9;
222  pred_table[2] = 16;
223  } else {
224  pred_count = 1;
225  pred_table[0] = 1;
226  }
227 
228  for (pred = 0; pred < pred_count; pred++) {
229  int start3 = start2 + (end2 - start2) * pred / pred_count;
230  int end3 = start2 + (end2 - start2) * (pred + 1) / pred_count;
231 
232  for (index = start3; index < end3; index++) {
233  FrameCode *ft = &nut->frame_code[index];
234  ft->flags = FLAG_KEY * key_frame;
235  ft->flags |= FLAG_SIZE_MSB;
236  ft->stream_id = stream_id;
237 //FIXME use single byte size and pred from last
238  ft->size_mul = end3 - start3;
239  ft->size_lsb = index - start3;
240  ft->pts_delta = pred_table[pred];
241  if (is_audio)
242  ft->header_idx = find_header_idx(s, codec, -1, key_frame);
243  }
244  }
245  }
246  memmove(&nut->frame_code['N' + 1], &nut->frame_code['N'],
247  sizeof(FrameCode) * (255 - 'N'));
248  nut->frame_code[0].flags =
249  nut->frame_code[255].flags =
250  nut->frame_code['N'].flags = FLAG_INVALID;
251 }
252 
253 static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc,
254  uint64_t val)
255 {
256  val *= nut->time_base_count;
257  val += time_base - nut->time_base;
258  ff_put_v(bc, val);
259 }
263 static void put_str(AVIOContext *bc, const char *string)
264 {
265  int len = strlen(string);
266 
267  ff_put_v(bc, len);
268  avio_write(bc, string, len);
269 }
270 
271 static void put_s(AVIOContext *bc, int64_t val)
272 {
273  ff_put_v(bc, 2 * FFABS(val) - (val > 0));
274 }
275 
276 #ifdef TRACE
277 static inline void ff_put_v_trace(AVIOContext *bc, uint64_t v, const char *file,
278  const char *func, int line)
279 {
280  av_log(NULL, AV_LOG_DEBUG, "ff_put_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
281 
282  ff_put_v(bc, v);
283 }
284 
285 static inline void put_s_trace(AVIOContext *bc, int64_t v, const char *file,
286  const char *func, int line)
287 {
288  av_log(NULL, AV_LOG_DEBUG, "put_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
289 
290  put_s(bc, v);
291 }
292 #define ff_put_v(bc, v) ff_put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
293 #define put_s(bc, v) put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
294 #endif
295 
296 //FIXME remove calculate_checksum
297 static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc,
298  int calculate_checksum, uint64_t startcode)
299 {
300  uint8_t *dyn_buf = NULL;
301  int dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
302  int forw_ptr = dyn_size + 4 * calculate_checksum;
303 
304  if (forw_ptr > 4096)
306  avio_wb64(bc, startcode);
307  ff_put_v(bc, forw_ptr);
308  if (forw_ptr > 4096)
309  avio_wl32(bc, ffio_get_checksum(bc));
310 
311  if (calculate_checksum)
313  avio_write(bc, dyn_buf, dyn_size);
314  if (calculate_checksum)
315  avio_wl32(bc, ffio_get_checksum(bc));
316 
317  av_free(dyn_buf);
318 }
319 
321 {
322  int i, j, tmp_pts, tmp_flags, tmp_stream, tmp_mul, tmp_size, tmp_fields,
323  tmp_head_idx;
324  int64_t tmp_match;
325 
326  ff_put_v(bc, 3); /* version */
327  ff_put_v(bc, nut->avf->nb_streams);
328  ff_put_v(bc, nut->max_distance);
329  ff_put_v(bc, nut->time_base_count);
330 
331  for (i = 0; i < nut->time_base_count; i++) {
332  ff_put_v(bc, nut->time_base[i].num);
333  ff_put_v(bc, nut->time_base[i].den);
334  }
335 
336  tmp_pts = 0;
337  tmp_mul = 1;
338  tmp_stream = 0;
339  tmp_match = 1 - (1LL << 62);
340  tmp_head_idx = 0;
341  for (i = 0; i < 256; ) {
342  tmp_fields = 0;
343  tmp_size = 0;
344 // tmp_res=0;
345  if (tmp_pts != nut->frame_code[i].pts_delta)
346  tmp_fields = 1;
347  if (tmp_mul != nut->frame_code[i].size_mul)
348  tmp_fields = 2;
349  if (tmp_stream != nut->frame_code[i].stream_id)
350  tmp_fields = 3;
351  if (tmp_size != nut->frame_code[i].size_lsb)
352  tmp_fields = 4;
353 // if(tmp_res != nut->frame_code[i].res ) tmp_fields=5;
354  if (tmp_head_idx != nut->frame_code[i].header_idx)
355  tmp_fields = 8;
356 
357  tmp_pts = nut->frame_code[i].pts_delta;
358  tmp_flags = nut->frame_code[i].flags;
359  tmp_stream = nut->frame_code[i].stream_id;
360  tmp_mul = nut->frame_code[i].size_mul;
361  tmp_size = nut->frame_code[i].size_lsb;
362 // tmp_res = nut->frame_code[i].res;
363  tmp_head_idx = nut->frame_code[i].header_idx;
364 
365  for (j = 0; i < 256; j++, i++) {
366  if (i == 'N') {
367  j--;
368  continue;
369  }
370  if (nut->frame_code[i].pts_delta != tmp_pts ||
371  nut->frame_code[i].flags != tmp_flags ||
372  nut->frame_code[i].stream_id != tmp_stream ||
373  nut->frame_code[i].size_mul != tmp_mul ||
374  nut->frame_code[i].size_lsb != tmp_size + j ||
375 // nut->frame_code[i].res != tmp_res ||
376  nut->frame_code[i].header_idx != tmp_head_idx)
377  break;
378  }
379  if (j != tmp_mul - tmp_size)
380  tmp_fields = 6;
381 
382  ff_put_v(bc, tmp_flags);
383  ff_put_v(bc, tmp_fields);
384  if (tmp_fields > 0)
385  put_s(bc, tmp_pts);
386  if (tmp_fields > 1)
387  ff_put_v(bc, tmp_mul);
388  if (tmp_fields > 2)
389  ff_put_v(bc, tmp_stream);
390  if (tmp_fields > 3)
391  ff_put_v(bc, tmp_size);
392  if (tmp_fields > 4)
393  ff_put_v(bc, 0 /*tmp_res*/);
394  if (tmp_fields > 5)
395  ff_put_v(bc, j);
396  if (tmp_fields > 6)
397  ff_put_v(bc, tmp_match);
398  if (tmp_fields > 7)
399  ff_put_v(bc, tmp_head_idx);
400  }
401  ff_put_v(bc, nut->header_count - 1);
402  for (i = 1; i < nut->header_count; i++) {
403  ff_put_v(bc, nut->header_len[i]);
404  avio_write(bc, nut->header[i], nut->header_len[i]);
405  }
406 }
407 
409  AVStream *st, int i)
410 {
411  NUTContext *nut = avctx->priv_data;
412  AVCodecContext *codec = st->codec;
413  unsigned codec_tag = av_codec_get_tag(ff_nut_codec_tags, codec->codec_id);
414 
415  ff_put_v(bc, i);
416  switch (codec->codec_type) {
417  case AVMEDIA_TYPE_VIDEO:
418  ff_put_v(bc, 0);
419  break;
420  case AVMEDIA_TYPE_AUDIO:
421  ff_put_v(bc, 1);
422  break;
424  ff_put_v(bc, 2);
425  break;
426  default:
427  ff_put_v(bc, 3);
428  break;
429  }
430  ff_put_v(bc, 4);
431 
432  if (!codec_tag || codec->codec_id == AV_CODEC_ID_RAWVIDEO)
433  codec_tag = codec->codec_tag;
434 
435  if (codec_tag) {
436  avio_wl32(bc, codec_tag);
437  } else {
438  av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
439  return AVERROR(EINVAL);
440  }
441 
442  ff_put_v(bc, nut->stream[i].time_base - nut->time_base);
443  ff_put_v(bc, nut->stream[i].msb_pts_shift);
444  ff_put_v(bc, nut->stream[i].max_pts_distance);
445  ff_put_v(bc, codec->has_b_frames);
446  avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
447 
448  ff_put_v(bc, codec->extradata_size);
449  avio_write(bc, codec->extradata, codec->extradata_size);
450 
451  switch (codec->codec_type) {
452  case AVMEDIA_TYPE_AUDIO:
453  ff_put_v(bc, codec->sample_rate);
454  ff_put_v(bc, 1);
455  ff_put_v(bc, codec->channels);
456  break;
457  case AVMEDIA_TYPE_VIDEO:
458  ff_put_v(bc, codec->width);
459  ff_put_v(bc, codec->height);
460 
461  if (st->sample_aspect_ratio.num <= 0 ||
462  st->sample_aspect_ratio.den <= 0) {
463  ff_put_v(bc, 0);
464  ff_put_v(bc, 0);
465  } else {
468  }
469  ff_put_v(bc, 0); /* csp type -- unknown */
470  break;
471  default:
472  break;
473  }
474  return 0;
475 }
476 
477 static int add_info(AVIOContext *bc, const char *type, const char *value)
478 {
479  put_str(bc, type);
480  put_s(bc, -1);
481  put_str(bc, value);
482  return 1;
483 }
484 
486 {
487  AVFormatContext *s = nut->avf;
489  AVIOContext *dyn_bc;
490  uint8_t *dyn_buf = NULL;
491  int count = 0, dyn_size;
492  int ret = avio_open_dyn_buf(&dyn_bc);
493  if (ret < 0)
494  return ret;
495 
496  while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
497  count += add_info(dyn_bc, t->key, t->value);
498 
499  ff_put_v(bc, 0); //stream_if_plus1
500  ff_put_v(bc, 0); //chapter_id
501  ff_put_v(bc, 0); //timestamp_start
502  ff_put_v(bc, 0); //length
503 
504  ff_put_v(bc, count);
505 
506  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
507  avio_write(bc, dyn_buf, dyn_size);
508  av_free(dyn_buf);
509  return 0;
510 }
511 
512 static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
513  AVFormatContext *s= nut->avf;
514  AVStream* st = s->streams[stream_id];
515  AVIOContext *dyn_bc;
516  uint8_t *dyn_buf=NULL;
517  int count=0, dyn_size, i;
518  int ret = avio_open_dyn_buf(&dyn_bc);
519  if(ret < 0)
520  return ret;
521 
522  for (i=0; ff_nut_dispositions[i].flag; ++i) {
523  if (st->disposition & ff_nut_dispositions[i].flag)
524  count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
525  }
526  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
527 
528  if (count) {
529  ff_put_v(bc, stream_id + 1); //stream_id_plus1
530  ff_put_v(bc, 0); //chapter_id
531  ff_put_v(bc, 0); //timestamp_start
532  ff_put_v(bc, 0); //length
533 
534  ff_put_v(bc, count);
535 
536  avio_write(bc, dyn_buf, dyn_size);
537  }
538 
539  av_free(dyn_buf);
540  return count;
541 }
542 
543 static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
544 {
545  AVIOContext *dyn_bc;
546  uint8_t *dyn_buf = NULL;
548  AVChapter *ch = nut->avf->chapters[id];
549  int ret, dyn_size, count = 0;
550 
551  ret = avio_open_dyn_buf(&dyn_bc);
552  if (ret < 0)
553  return ret;
554 
555  ff_put_v(bc, 0); // stream_id_plus1
556  put_s(bc, id + 1); // chapter_id
557  put_tt(nut, nut->chapter[id].time_base, bc, ch->start); // chapter_start
558  ff_put_v(bc, ch->end - ch->start); // chapter_len
559 
560  while ((t = av_dict_get(ch->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
561  count += add_info(dyn_bc, t->key, t->value);
562 
563  ff_put_v(bc, count);
564 
565  dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
566  avio_write(bc, dyn_buf, dyn_size);
567  av_freep(&dyn_buf);
568  return 0;
569 }
570 
572 {
573  NUTContext *nut = avctx->priv_data;
574  AVIOContext *dyn_bc;
575  int i, ret;
576 
578 
579  ret = avio_open_dyn_buf(&dyn_bc);
580  if (ret < 0)
581  return ret;
582  write_mainheader(nut, dyn_bc);
583  put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE);
584 
585  for (i = 0; i < nut->avf->nb_streams; i++) {
586  ret = avio_open_dyn_buf(&dyn_bc);
587  if (ret < 0)
588  return ret;
589  ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i);
590  if (ret < 0)
591  return ret;
592  put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE);
593  }
594 
595  ret = avio_open_dyn_buf(&dyn_bc);
596  if (ret < 0)
597  return ret;
598  write_globalinfo(nut, dyn_bc);
599  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
600 
601  for (i = 0; i < nut->avf->nb_streams; i++) {
602  ret = avio_open_dyn_buf(&dyn_bc);
603  if (ret < 0)
604  return ret;
605  ret = write_streaminfo(nut, dyn_bc, i);
606  if (ret < 0)
607  return ret;
608  if (ret > 0)
609  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
610  else {
611  uint8_t *buf;
612  avio_close_dyn_buf(dyn_bc, &buf);
613  av_free(buf);
614  }
615  }
616 
617  for (i = 0; i < nut->avf->nb_chapters; i++) {
618  ret = avio_open_dyn_buf(&dyn_bc);
619  if (ret < 0)
620  return ret;
621  ret = write_chapter(nut, dyn_bc, i);
622  if (ret < 0) {
623  uint8_t *buf;
624  avio_close_dyn_buf(dyn_bc, &buf);
625  av_freep(&buf);
626  return ret;
627  }
628  put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
629  }
630 
631  nut->last_syncpoint_pos = INT_MIN;
632  nut->header_count++;
633  return 0;
634 }
635 
637 {
638  NUTContext *nut = s->priv_data;
639  AVIOContext *bc = s->pb;
640  int i, j, ret;
641 
642  nut->avf = s;
643 
644  nut->stream = av_mallocz(sizeof(StreamContext) * s->nb_streams);
645  if (s->nb_chapters)
646  nut->chapter = av_mallocz(sizeof(ChapterContext) * s->nb_chapters);
647  nut->time_base = av_mallocz(sizeof(AVRational) * (s->nb_streams +
648  s->nb_chapters));
649  if (!nut->stream || (s->nb_chapters && !nut->chapter) || !nut->time_base) {
650  av_freep(&nut->stream);
651  av_freep(&nut->chapter);
652  av_freep(&nut->time_base);
653  return AVERROR(ENOMEM);
654  }
655 
656  for (i = 0; i < s->nb_streams; i++) {
657  AVStream *st = s->streams[i];
658  int ssize;
659  AVRational time_base;
660  ff_parse_specific_params(st->codec, &time_base.den, &ssize,
661  &time_base.num);
662 
663  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
664 
665  for (j = 0; j < nut->time_base_count; j++)
666  if (!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))) {
667  break;
668  }
669  nut->time_base[j] = time_base;
670  nut->stream[i].time_base = &nut->time_base[j];
671  if (j == nut->time_base_count)
672  nut->time_base_count++;
673 
674  if (INT64_C(1000) * time_base.num >= time_base.den)
675  nut->stream[i].msb_pts_shift = 7;
676  else
677  nut->stream[i].msb_pts_shift = 14;
678  nut->stream[i].max_pts_distance =
679  FFMAX(time_base.den, time_base.num) / time_base.num;
680  }
681 
682  for (i = 0; i < s->nb_chapters; i++) {
683  AVChapter *ch = s->chapters[i];
684 
685  for (j = 0; j < nut->time_base_count; j++)
686  if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational)))
687  break;
688 
689  nut->time_base[j] = ch->time_base;
690  nut->chapter[i].time_base = &nut->time_base[j];
691  if (j == nut->time_base_count)
692  nut->time_base_count++;
693  }
694 
695  nut->max_distance = MAX_DISTANCE;
697  build_frame_code(s);
698  assert(nut->frame_code['N'].flags == FLAG_INVALID);
699 
700  avio_write(bc, ID_STRING, strlen(ID_STRING));
701  avio_w8(bc, 0);
702 
703  if ((ret = write_headers(s, bc)) < 0)
704  return ret;
705 
706  avio_flush(bc);
707 
708  //FIXME index
709 
710  return 0;
711 }
712 
714  AVPacket *pkt)
715 {
716  int flags = 0;
717 
718  if (pkt->flags & AV_PKT_FLAG_KEY)
719  flags |= FLAG_KEY;
720  if (pkt->stream_index != fc->stream_id)
721  flags |= FLAG_STREAM_ID;
722  if (pkt->size / fc->size_mul)
723  flags |= FLAG_SIZE_MSB;
724  if (pkt->pts - nus->last_pts != fc->pts_delta)
725  flags |= FLAG_CODED_PTS;
726  if (pkt->size > 2 * nut->max_distance)
727  flags |= FLAG_CHECKSUM;
728  if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
729  flags |= FLAG_CHECKSUM;
730  if (pkt->size < nut->header_len[fc->header_idx] ||
731  (pkt->size > 4096 && fc->header_idx) ||
732  memcmp(pkt->data, nut->header[fc->header_idx],
733  nut->header_len[fc->header_idx]))
734  flags |= FLAG_HEADER_IDX;
735 
736  return flags | (fc->flags & FLAG_CODED);
737 }
738 
740 {
741  int i;
742  int best_i = 0;
743  int best_len = 0;
744 
745  if (pkt->size > 4096)
746  return 0;
747 
748  for (i = 1; i < nut->header_count; i++)
749  if (pkt->size >= nut->header_len[i]
750  && nut->header_len[i] > best_len
751  && !memcmp(pkt->data, nut->header[i], nut->header_len[i])) {
752  best_i = i;
753  best_len = nut->header_len[i];
754  }
755  return best_i;
756 }
757 
759 {
760  NUTContext *nut = s->priv_data;
761  StreamContext *nus = &nut->stream[pkt->stream_index];
762  AVIOContext *bc = s->pb, *dyn_bc;
763  FrameCode *fc;
764  int64_t coded_pts;
765  int best_length, frame_code, flags, needed_flags, i, header_idx,
766  best_header_idx;
767  int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
768  int store_sp = 0;
769  int ret;
770 
771  if (pkt->pts < 0) {
772  av_log(s, AV_LOG_ERROR,
773  "Negative pts not supported stream %d, pts %"PRId64"\n",
774  pkt->stream_index, pkt->pts);
775  return AVERROR_INVALIDDATA;
776  }
777 
778  if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
779  write_headers(s, bc);
780 
781  if (key_frame && !(nus->last_flags & FLAG_KEY))
782  store_sp = 1;
783 
784  if (pkt->size + 30 /*FIXME check*/ + avio_tell(bc) >=
785  nut->last_syncpoint_pos + nut->max_distance)
786  store_sp = 1;
787 
788 //FIXME: Ensure store_sp is 1 in the first place.
789 
790  if (store_sp) {
791  Syncpoint *sp, dummy = { .pos = INT64_MAX };
792 
793  ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
794  for (i = 0; i < s->nb_streams; i++) {
795  AVStream *st = s->streams[i];
796  int64_t dts_tb = av_rescale_rnd(pkt->dts,
797  nus->time_base->num * (int64_t)nut->stream[i].time_base->den,
798  nus->time_base->den * (int64_t)nut->stream[i].time_base->num,
799  AV_ROUND_DOWN);
800  int index = av_index_search_timestamp(st, dts_tb,
802  if (index >= 0)
803  dummy.pos = FFMIN(dummy.pos, st->index_entries[index].pos);
804  }
805  if (dummy.pos == INT64_MAX)
806  dummy.pos = 0;
807  sp = av_tree_find(nut->syncpoints, &dummy, (void *)ff_nut_sp_pos_cmp,
808  NULL);
809 
810  nut->last_syncpoint_pos = avio_tell(bc);
811  ret = avio_open_dyn_buf(&dyn_bc);
812  if (ret < 0)
813  return ret;
814  put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
815  ff_put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos) >> 4 : 0);
816  put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
817 
818  ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts);
819  }
820  assert(nus->last_pts != AV_NOPTS_VALUE);
821 
822  coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
823  if (ff_lsb2full(nus, coded_pts) != pkt->pts)
824  coded_pts = pkt->pts + (1 << nus->msb_pts_shift);
825 
826  best_header_idx = find_best_header_idx(nut, pkt);
827 
828  best_length = INT_MAX;
829  frame_code = -1;
830  for (i = 0; i < 256; i++) {
831  int length = 0;
832  FrameCode *fc = &nut->frame_code[i];
833  int flags = fc->flags;
834 
835  if (flags & FLAG_INVALID)
836  continue;
837  needed_flags = get_needed_flags(nut, nus, fc, pkt);
838 
839  if (flags & FLAG_CODED) {
840  length++;
841  flags = needed_flags;
842  }
843 
844  if ((flags & needed_flags) != needed_flags)
845  continue;
846 
847  if ((flags ^ needed_flags) & FLAG_KEY)
848  continue;
849 
850  if (flags & FLAG_STREAM_ID)
851  length += ff_get_v_length(pkt->stream_index);
852 
853  if (pkt->size % fc->size_mul != fc->size_lsb)
854  continue;
855  if (flags & FLAG_SIZE_MSB)
856  length += ff_get_v_length(pkt->size / fc->size_mul);
857 
858  if (flags & FLAG_CHECKSUM)
859  length += 4;
860 
861  if (flags & FLAG_CODED_PTS)
862  length += ff_get_v_length(coded_pts);
863 
864  if ((flags & FLAG_CODED)
865  && nut->header_len[best_header_idx] >
866  nut->header_len[fc->header_idx] + 1) {
867  flags |= FLAG_HEADER_IDX;
868  }
869 
870  if (flags & FLAG_HEADER_IDX) {
871  length += 1 - nut->header_len[best_header_idx];
872  } else {
873  length -= nut->header_len[fc->header_idx];
874  }
875 
876  length *= 4;
877  length += !(flags & FLAG_CODED_PTS);
878  length += !(flags & FLAG_CHECKSUM);
879 
880  if (length < best_length) {
881  best_length = length;
882  frame_code = i;
883  }
884  }
885  assert(frame_code != -1);
886  fc = &nut->frame_code[frame_code];
887  flags = fc->flags;
888  needed_flags = get_needed_flags(nut, nus, fc, pkt);
889  header_idx = fc->header_idx;
890 
892  avio_w8(bc, frame_code);
893  if (flags & FLAG_CODED) {
894  ff_put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
895  flags = needed_flags;
896  }
897  if (flags & FLAG_STREAM_ID)
898  ff_put_v(bc, pkt->stream_index);
899  if (flags & FLAG_CODED_PTS)
900  ff_put_v(bc, coded_pts);
901  if (flags & FLAG_SIZE_MSB)
902  ff_put_v(bc, pkt->size / fc->size_mul);
903  if (flags & FLAG_HEADER_IDX)
904  ff_put_v(bc, header_idx = best_header_idx);
905 
906  if (flags & FLAG_CHECKSUM)
907  avio_wl32(bc, ffio_get_checksum(bc));
908  else
909  ffio_get_checksum(bc);
910 
911  avio_write(bc, pkt->data + nut->header_len[header_idx],
912  pkt->size - nut->header_len[header_idx]);
913  nus->last_flags = flags;
914  nus->last_pts = pkt->pts;
915 
916  //FIXME just store one per syncpoint
917  if (flags & FLAG_KEY)
919  s->streams[pkt->stream_index],
920  nut->last_syncpoint_pos,
921  pkt->pts,
922  0,
923  0,
925 
926  return 0;
927 }
928 
930 {
931  NUTContext *nut = s->priv_data;
932  AVIOContext *bc = s->pb;
933 
934  while (nut->header_count < 3)
935  write_headers(s, bc);
936 
937  ff_nut_free_sp(nut);
938  av_freep(&nut->stream);
939  av_freep(&nut->chapter);
940  av_freep(&nut->time_base);
941 
942  return 0;
943 }
944 
946  .name = "nut",
947  .long_name = NULL_IF_CONFIG_SMALL("NUT"),
948  .mime_type = "video/x-nut",
949  .extensions = "nut",
950  .priv_data_size = sizeof(NUTContext),
951  .audio_codec = CONFIG_LIBVORBIS ? AV_CODEC_ID_VORBIS :
953  .video_codec = AV_CODEC_ID_MPEG4,
958  .codec_tag = ff_nut_codec_tags,
959 };