Merge commit '07eea5a5ded1141632aefecfa59dcdc26de2d7ea'
authorClément Bœsch <u@pkh.me>
Fri, 24 Mar 2017 12:21:04 +0000 (13:21 +0100)
committerClément Bœsch <u@pkh.me>
Fri, 24 Mar 2017 12:21:04 +0000 (13:21 +0100)
* commit '07eea5a5ded1141632aefecfa59dcdc26de2d7ea':
  nut: Drop pointless TRACE level debug code

Merged-by: Clément Bœsch <u@pkh.me>
1  2 
libavformat/nutdec.c
libavformat/nutenc.c

diff --combined libavformat/nutdec.c
index ca34e35f74114e9f38c4995bc85d9b0ff50db4b2,25076631bfd7b2d592d8f162f60d4587e6ce1de1..4272f8816c9b4e956b3c35b97c54535615472353
@@@ -3,41 -3,37 +3,41 @@@
   * Copyright (c) 2004-2006 Michael Niedermayer
   * Copyright (c) 2003 Alex Beregszaszi
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/avstring.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/bswap.h"
  #include "libavutil/dict.h"
 +#include "libavutil/intreadwrite.h"
  #include "libavutil/mathematics.h"
  #include "libavutil/tree.h"
 +#include "libavcodec/bytestream.h"
  #include "avio_internal.h"
 +#include "isom.h"
  #include "nut.h"
  #include "riff.h"
  
 -#undef NDEBUG
 -#include <assert.h>
 -
  #define NUT_MAX_STREAMS 256    /* arbitrary sanity check value */
  
 +static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,
 +                                  int64_t *pos_arg, int64_t pos_limit);
 +
  static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)
  {
      unsigned int len = ffio_read_varlen(bc);
      while (len > maxlen) {
          avio_r8(bc);
          len--;
 +        if (bc->eof_reached)
 +            len = maxlen;
      }
  
      if (maxlen)
          string[FFMIN(len, maxlen - 1)] = 0;
  
 +    if (bc->eof_reached)
 +        return AVERROR_EOF;
      if (maxlen == len)
          return -1;
      else
@@@ -80,52 -72,14 +80,16 @@@ static uint64_t get_fourcc(AVIOContext 
          return avio_rl16(bc);
      else if (len == 4)
          return avio_rl32(bc);
 -    else
 +    else {
 +        av_log(NULL, AV_LOG_ERROR, "Unsupported fourcc length %d\n", len);
          return -1;
 +    }
  }
  
- #ifdef TRACE
- static inline uint64_t get_v_trace(AVIOContext *bc, const char *file,
-                                    const char *func, int line)
- {
-     uint64_t v = ffio_read_varlen(bc);
-     av_log(NULL, AV_LOG_DEBUG, "get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-            v, v, file, func, line);
-     return v;
- }
- static inline int64_t get_s_trace(AVIOContext *bc, const char *file,
-                                   const char *func, int line)
- {
-     int64_t v = get_s(bc);
-     av_log(NULL, AV_LOG_DEBUG, "get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-            v, v, file, func, line);
-     return v;
- }
- static inline uint64_t get_4cc_trace(AVIOContext *bc, char *file,
-                                     char *func, int line)
- {
-     uint64_t v = get_fourcc(bc);
-     av_log(NULL, AV_LOG_DEBUG, "get_fourcc %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-            v, v, file, func, line);
-     return v;
- }
- #define ffio_read_varlen(bc) get_v_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #define get_s(bc)            get_s_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #define get_fourcc(bc)       get_4cc_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #endif
  static int get_packetheader(NUTContext *nut, AVIOContext *bc,
                              int calculate_checksum, uint64_t startcode)
  {
      int64_t size;
- //    start = avio_tell(bc) - 8;
  
      startcode = av_be2ne64(startcode);
      startcode = ff_crc04C11DB7_update(0, (uint8_t*) &startcode, 8);
@@@ -150,7 -104,7 +114,7 @@@ static uint64_t find_any_startcode(AVIO
          /* Note, this may fail if the stream is not seekable, but that should
           * not matter, as in this case we simply start where we currently are */
          avio_seek(bc, pos, SEEK_SET);
 -    while (!bc->eof_reached) {
 +    while (!avio_feof(bc)) {
          state = (state << 8) | avio_r8(bc);
          if ((state >> 56) != 'N')
              continue;
@@@ -188,11 -142,11 +152,11 @@@ static int64_t find_startcode(AVIOConte
  static int nut_probe(AVProbeData *p)
  {
      int i;
 -    uint64_t code = 0;
  
 -    for (i = 0; i < p->buf_size; i++) {
 -        code = (code << 8) | p->buf[i];
 -        if (code == MAIN_STARTCODE)
 +    for (i = 0; i < p->buf_size-8; i++) {
 +        if (AV_RB32(p->buf+i) != MAIN_STARTCODE>>32)
 +            continue;
 +        if (AV_RB32(p->buf+i+4) == (MAIN_STARTCODE & 0xFFFFFFFF))
              return AVPROBE_SCORE_MAX;
      }
      return 0;
          tmp = ffio_read_varlen(bc);                                           \
          if (!(check)) {                                                       \
              av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp);  \
 -            return AVERROR_INVALIDDATA;                                       \
 +            ret = AVERROR_INVALIDDATA;                                        \
 +            goto fail;                                                        \
          }                                                                     \
          dst = tmp;                                                            \
      } while (0)
@@@ -216,11 -169,8 +180,11 @@@ static int skip_reserved(AVIOContext *b
          avio_seek(bc, pos, SEEK_CUR);
          return AVERROR_INVALIDDATA;
      } else {
 -        while (pos--)
 +        while (pos--) {
 +            if (bc->eof_reached)
 +                return AVERROR_INVALIDDATA;
              avio_r8(bc);
 +        }
          return 0;
      }
  }
@@@ -231,7 -181,7 +195,7 @@@ static int decode_main_header(NUTContex
      AVIOContext *bc    = s->pb;
      uint64_t tmp, end;
      unsigned int stream_count;
 -    int i, j, count;
 +    int i, j, count, ret;
      int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;
  
      end  = get_packetheader(nut, bc, 1, MAIN_STARTCODE);
                 nut->version);
          return AVERROR(ENOSYS);
      }
 +    if (nut->version > 3)
 +        nut->minor_version = ffio_read_varlen(bc);
  
      GET_V(stream_count, tmp > 0 && tmp <= NUT_MAX_STREAMS);
  
      }
  
      GET_V(nut->time_base_count, tmp > 0 && tmp < INT_MAX / sizeof(AVRational));
 -    nut->time_base = av_malloc(nut->time_base_count * sizeof(AVRational));
 +    nut->time_base = av_malloc_array(nut->time_base_count, sizeof(AVRational));
      if (!nut->time_base)
          return AVERROR(ENOMEM);
  
              av_log(s, AV_LOG_ERROR, "invalid time base %d/%d\n",
                     nut->time_base[i].num,
                     nut->time_base[i].den);
 -            return AVERROR_INVALIDDATA;
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
          }
      }
      tmp_pts      = 0;
          if (tmp_fields > 7)
              tmp_head_idx = ffio_read_varlen(bc);
  
 -        while (tmp_fields-- > 8)
 +        while (tmp_fields-- > 8) {
 +            if (bc->eof_reached) {
 +                av_log(s, AV_LOG_ERROR, "reached EOF while decoding main header\n");
 +                ret = AVERROR_INVALIDDATA;
 +                goto fail;
 +            }
              ffio_read_varlen(bc);
 +        }
  
 -        if (count == 0 || i + count > 256) {
 +        if (count <= 0 || count > 256 - (i <= 'N') - i) {
              av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);
 -            return AVERROR_INVALIDDATA;
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
          }
          if (tmp_stream >= stream_count) {
              av_log(s, AV_LOG_ERROR, "illegal stream number %d >= %d\n",
                     tmp_stream, stream_count);
 -            return AVERROR_INVALIDDATA;
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
          }
  
          for (j = 0; j < count; j++, i++) {
              nut->frame_code[i].header_idx     = tmp_head_idx;
          }
      }
 -    assert(nut->frame_code['N'].flags == FLAG_INVALID);
 +    av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
  
      if (end > avio_tell(bc) + 4) {
          int rem = 1024;
                  av_log(s, AV_LOG_ERROR,
                         "invalid elision header %d : %d > %d\n",
                         i, nut->header_len[i], rem);
 -                return AVERROR_INVALIDDATA;
 +                ret = AVERROR_INVALIDDATA;
 +                goto fail;
              }
              rem -= nut->header_len[i];
              hdr = av_malloc(nut->header_len[i]);
 -            if (!hdr)
 -                return AVERROR(ENOMEM);
 +            if (!hdr) {
 +                ret = AVERROR(ENOMEM);
 +                goto fail;
 +            }
              avio_read(bc, hdr, nut->header_len[i]);
              nut->header[i] = hdr;
          }
 -        assert(nut->header_len[0] == 0);
 +        av_assert0(nut->header_len[0] == 0);
      }
  
      // flags had been effectively introduced in version 4
 -    if (nut->version > NUT_STABLE_VERSION) {
 +    if (nut->version > 3 && end > avio_tell(bc) + 4) {
          nut->flags = ffio_read_varlen(bc);
      }
  
      if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
          av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n");
 -        return AVERROR_INVALIDDATA;
 +        ret = AVERROR_INVALIDDATA;
 +        goto fail;
      }
  
 -    nut->stream = av_mallocz(sizeof(StreamContext) * stream_count);
 -    if (!nut->stream)
 -        return AVERROR(ENOMEM);
 +    nut->stream = av_calloc(stream_count, sizeof(StreamContext));
 +    if (!nut->stream) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
      for (i = 0; i < stream_count; i++)
          avformat_new_stream(s, NULL);
  
      return 0;
 +fail:
 +    av_freep(&nut->time_base);
 +    for (i = 1; i < nut->header_count; i++) {
 +        av_freep(&nut->header[i]);
 +    }
 +    nut->header_count = 0;
 +    return ret;
  }
  
  static int decode_stream_header(NUTContext *nut)
      AVFormatContext *s = nut->avf;
      AVIOContext *bc    = s->pb;
      StreamContext *stc;
 -    int class, stream_id;
 +    int class, stream_id, ret;
      uint64_t tmp, end;
 -    AVStream *st;
 +    AVStream *st = NULL;
  
      end  = get_packetheader(nut, bc, 1, STREAM_STARTCODE);
      end += avio_tell(bc);
          st->codecpar->codec_id   = av_codec_get_id((const AVCodecTag * const []) {
                                                      ff_nut_video_tags,
                                                      ff_codec_bmp_tags,
 +                                                    ff_codec_movvideo_tags,
                                                      0
                                                  },
                                                  tmp);
          st->codecpar->codec_id   = av_codec_get_id((const AVCodecTag * const []) {
                                                      ff_nut_audio_tags,
                                                      ff_codec_wav_tags,
 +                                                    ff_nut_audio_extra_tags,
                                                      0
                                                  },
                                                  tmp);
      GET_V(stc->msb_pts_shift, tmp < 16);
      stc->max_pts_distance = ffio_read_varlen(bc);
      GET_V(stc->decode_delay, tmp < 1000); // sanity limit, raise this if Moore's law is true
 +    st->codecpar->video_delay = stc->decode_delay;
      ffio_read_varlen(bc); // stream flags
  
      GET_V(st->codecpar->extradata_size, tmp < (1 << 30));
      if (st->codecpar->extradata_size) {
 -        st->codecpar->extradata = av_mallocz(st->codecpar->extradata_size +
 -                                             AV_INPUT_BUFFER_PADDING_SIZE);
 -        if (!st->codecpar->extradata)
 +        if (ff_get_extradata(s, st->codecpar, bc, st->codecpar->extradata_size) < 0)
              return AVERROR(ENOMEM);
 -        avio_read(bc, st->codecpar->extradata, st->codecpar->extradata_size);
      }
  
      if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
          if ((!st->sample_aspect_ratio.num) != (!st->sample_aspect_ratio.den)) {
              av_log(s, AV_LOG_ERROR, "invalid aspect ratio %d/%d\n",
                     st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
 -            return AVERROR_INVALIDDATA;
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
          }
          ffio_read_varlen(bc); /* csp type */
      } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
      if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {
          av_log(s, AV_LOG_ERROR,
                 "stream header %d checksum mismatch\n", stream_id);
 -        return AVERROR_INVALIDDATA;
 +        ret = AVERROR_INVALIDDATA;
 +        goto fail;
      }
      stc->time_base = &nut->time_base[stc->time_base_id];
      avpriv_set_pts_info(s->streams[stream_id], 63, stc->time_base->num,
                          stc->time_base->den);
      return 0;
 +fail:
 +    if (st && st->codecpar) {
 +        av_freep(&st->codecpar->extradata);
 +        st->codecpar->extradata_size = 0;
 +    }
 +    return ret;
  }
  
  static void set_disposition_bits(AVFormatContext *avf, char *value,
@@@ -523,7 -441,7 +487,7 @@@ static int decode_info_header(NUTContex
      AVIOContext *bc    = s->pb;
      uint64_t tmp, chapter_start, chapter_len;
      unsigned int stream_id_plus1, count;
 -    int chapter_id, i;
 +    int chapter_id, i, ret = 0;
      int64_t value, end;
      char name[256], str_value[1024], type_str[256];
      const char *type;
      }
  
      for (i = 0; i < count; i++) {
 -        get_str(bc, name, sizeof(name));
 +        ret = get_str(bc, name, sizeof(name));
 +        if (ret < 0) {
 +            av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
 +            return ret;
 +        }
          value = get_s(bc);
 +        str_value[0] = 0;
 +
          if (value == -1) {
              type = "UTF-8";
 -            get_str(bc, str_value, sizeof(str_value));
 +            ret = get_str(bc, str_value, sizeof(str_value));
          } else if (value == -2) {
 -            get_str(bc, type_str, sizeof(type_str));
 +            ret = get_str(bc, type_str, sizeof(type_str));
 +            if (ret < 0) {
 +                av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
 +                return ret;
 +            }
              type = type_str;
 -            get_str(bc, str_value, sizeof(str_value));
 +            ret = get_str(bc, str_value, sizeof(str_value));
          } else if (value == -3) {
              type  = "s";
              value = get_s(bc);
              type = "v";
          }
  
 +        if (ret < 0) {
 +            av_log(s, AV_LOG_ERROR, "get_str failed while decoding info header\n");
 +            return ret;
 +        }
 +
          if (stream_id_plus1 > s->nb_streams) {
              av_log(s, AV_LOG_WARNING,
                     "invalid stream id %d for info packet\n",
                  set_disposition_bits(s, str_value, stream_id_plus1 - 1);
                  continue;
              }
 +
 +            if (stream_id_plus1 && !strcmp(name, "r_frame_rate")) {
 +                sscanf(str_value, "%d/%d", &st->r_frame_rate.num, &st->r_frame_rate.den);
 +                if (st->r_frame_rate.num >= 1000LL*st->r_frame_rate.den ||
 +                    st->r_frame_rate.num < 0 || st->r_frame_rate.num < 0)
 +                    st->r_frame_rate.num = st->r_frame_rate.den = 0;
 +                continue;
 +            }
 +
              if (metadata && av_strcasecmp(name, "Uses") &&
                  av_strcasecmp(name, "Depends") && av_strcasecmp(name, "Replaces")) {
                  if (event_flags)
          av_log(s, AV_LOG_ERROR, "info header checksum mismatch\n");
          return AVERROR_INVALIDDATA;
      }
 -    return 0;
 +fail:
 +    return FFMIN(ret, 0);
  }
  
  static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)
  {
      AVFormatContext *s = nut->avf;
      AVIOContext *bc    = s->pb;
 -    int64_t end, tmp;
 +    int64_t end;
 +    uint64_t tmp;
      int ret;
  
      nut->last_syncpoint_pos = avio_tell(bc) - 8;
      tmp       = ffio_read_varlen(bc);
      *back_ptr = nut->last_syncpoint_pos - 16 * ffio_read_varlen(bc);
      if (*back_ptr < 0)
 -        return -1;
 +        return AVERROR_INVALIDDATA;
  
      ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count],
                      tmp / nut->time_base_count);
          return AVERROR_INVALIDDATA;
      }
  
 -    *ts = tmp / s->nb_streams *
 -          av_q2d(nut->time_base[tmp % s->nb_streams]) * AV_TIME_BASE;
 +    *ts = tmp / nut->time_base_count *
 +          av_q2d(nut->time_base[tmp % nut->time_base_count]) * AV_TIME_BASE;
  
      if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, *back_ptr, *ts)) < 0)
          return ret;
      return 0;
  }
  
 +//FIXME calculate exactly, this is just a good approximation.
 +static int64_t find_duration(NUTContext *nut, int64_t filesize)
 +{
 +    AVFormatContext *s = nut->avf;
 +    int64_t duration = 0;
 +
 +    ff_find_last_ts(s, -1, &duration, NULL, nut_read_timestamp);
 +
 +    if(duration > 0)
 +        s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
 +    return duration;
 +}
 +
  static int find_and_decode_index(NUTContext *nut)
  {
      AVFormatContext *s = nut->avf;
      uint64_t tmp, end;
      int i, j, syncpoint_count;
      int64_t filesize = avio_size(bc);
 -    int64_t *syncpoints;
 -    int8_t *has_keyframe;
 +    int64_t *syncpoints = NULL;
 +    uint64_t max_pts;
 +    int8_t *has_keyframe = NULL;
      int ret = AVERROR_INVALIDDATA;
  
 +    if(filesize <= 0)
 +        return -1;
 +
      avio_seek(bc, filesize - 12, SEEK_SET);
      avio_seek(bc, filesize - avio_rb64(bc), SEEK_SET);
      if (avio_rb64(bc) != INDEX_STARTCODE) {
          av_log(s, AV_LOG_WARNING, "no index at the end\n");
 +
 +        if(s->duration<=0)
 +            s->duration = find_duration(nut, filesize);
          return ret;
      }
  
      end  = get_packetheader(nut, bc, 1, INDEX_STARTCODE);
      end += avio_tell(bc);
  
 -    ffio_read_varlen(bc); // max_pts
 +    max_pts = ffio_read_varlen(bc);
 +    s->duration = av_rescale_q(max_pts / nut->time_base_count,
 +                               nut->time_base[max_pts % nut->time_base_count],
 +                               AV_TIME_BASE_Q);
 +    s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
 +
      GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0);
 -    syncpoints   = av_malloc(sizeof(int64_t) *  syncpoint_count);
 -    has_keyframe = av_malloc(sizeof(int8_t)  * (syncpoint_count + 1));
 +    syncpoints   = av_malloc_array(syncpoint_count, sizeof(int64_t));
 +    has_keyframe = av_malloc_array(syncpoint_count + 1, sizeof(int8_t));
      if (!syncpoints || !has_keyframe) {
          ret = AVERROR(ENOMEM);
          goto fail;
                  int flag = x & 1;
                  x >>= 1;
                  if (n + x >= syncpoint_count + 1) {
 -                    av_log(s, AV_LOG_ERROR, "index overflow A\n");
 +                    av_log(s, AV_LOG_ERROR, "index overflow A %d + %"PRIu64" >= %d\n", n, x, syncpoint_count + 1);
                      goto fail;
                  }
                  while (x--)
                      has_keyframe[n++] = flag;
                  has_keyframe[n++] = !flag;
              } else {
 +                if (x <= 1) {
 +                    av_log(s, AV_LOG_ERROR, "index: x %"PRIu64" is invalid\n", x);
 +                    goto fail;
 +                }
                  while (x != 1) {
                      if (n >= syncpoint_count + 1) {
                          av_log(s, AV_LOG_ERROR, "index overflow B\n");
                  av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");
                  goto fail;
              }
 -            assert(n <= syncpoint_count + 1);
 +            av_assert0(n <= syncpoint_count + 1);
              for (; j < n && j < syncpoint_count; j++) {
                  if (has_keyframe[j]) {
                      uint64_t B, A = ffio_read_varlen(bc);
@@@ -881,7 -744,7 +845,7 @@@ static int nut_read_header(AVFormatCont
          find_and_decode_index(nut);
          avio_seek(bc, orig_pos, SEEK_SET);
      }
 -    assert(nut->next_startcode == SYNCPOINT_STARTCODE);
 +    av_assert0(nut->next_startcode == SYNCPOINT_STARTCODE);
  
      ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);
  
@@@ -893,138 -756,13 +857,138 @@@ fail
      return AVERROR_INVALIDDATA;
  }
  
 +static int read_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta, int64_t maxpos)
 +{
 +    int count = ffio_read_varlen(bc);
 +    int skip_start = 0;
 +    int skip_end = 0;
 +    int channels = 0;
 +    int64_t channel_layout = 0;
 +    int sample_rate = 0;
 +    int width = 0;
 +    int height = 0;
 +    int i, ret;
 +
 +    for (i=0; i<count; i++) {
 +        uint8_t name[256], str_value[256], type_str[256];
 +        int value;
 +        if (avio_tell(bc) >= maxpos)
 +            return AVERROR_INVALIDDATA;
 +        ret = get_str(bc, name, sizeof(name));
 +        if (ret < 0) {
 +            av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
 +            return ret;
 +        }
 +        value = get_s(bc);
 +
 +        if (value == -1) {
 +            ret = get_str(bc, str_value, sizeof(str_value));
 +            if (ret < 0) {
 +                av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
 +                return ret;
 +            }
 +            av_log(s, AV_LOG_WARNING, "Unknown string %s / %s\n", name, str_value);
 +        } else if (value == -2) {
 +            uint8_t *dst = NULL;
 +            int64_t v64, value_len;
 +
 +            ret = get_str(bc, type_str, sizeof(type_str));
 +            if (ret < 0) {
 +                av_log(s, AV_LOG_ERROR, "get_str failed while reading sm data\n");
 +                return ret;
 +            }
 +            value_len = ffio_read_varlen(bc);
 +            if (value_len < 0 || value_len >= maxpos - avio_tell(bc))
 +                return AVERROR_INVALIDDATA;
 +            if (!strcmp(name, "Palette")) {
 +                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, value_len);
 +            } else if (!strcmp(name, "Extradata")) {
 +                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, value_len);
 +            } else if (sscanf(name, "CodecSpecificSide%"SCNd64"", &v64) == 1) {
 +                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, value_len + 8);
 +                if(!dst)
 +                    return AVERROR(ENOMEM);
 +                AV_WB64(dst, v64);
 +                dst += 8;
 +            } else if (!strcmp(name, "ChannelLayout") && value_len == 8) {
 +                channel_layout = avio_rl64(bc);
 +                continue;
 +            } else {
 +                av_log(s, AV_LOG_WARNING, "Unknown data %s / %s\n", name, type_str);
 +                avio_skip(bc, value_len);
 +                continue;
 +            }
 +            if(!dst)
 +                return AVERROR(ENOMEM);
 +            avio_read(bc, dst, value_len);
 +        } else if (value == -3) {
 +            value = get_s(bc);
 +        } else if (value == -4) {
 +            value = ffio_read_varlen(bc);
 +        } else if (value < -4) {
 +            get_s(bc);
 +        } else {
 +            if (!strcmp(name, "SkipStart")) {
 +                skip_start = value;
 +            } else if (!strcmp(name, "SkipEnd")) {
 +                skip_end = value;
 +            } else if (!strcmp(name, "Channels")) {
 +                channels = value;
 +            } else if (!strcmp(name, "SampleRate")) {
 +                sample_rate = value;
 +            } else if (!strcmp(name, "Width")) {
 +                width = value;
 +            } else if (!strcmp(name, "Height")) {
 +                height = value;
 +            } else {
 +                av_log(s, AV_LOG_WARNING, "Unknown integer %s\n", name);
 +            }
 +        }
 +    }
 +
 +    if (channels || channel_layout || sample_rate || width || height) {
 +        uint8_t *dst = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, 28);
 +        if (!dst)
 +            return AVERROR(ENOMEM);
 +        bytestream_put_le32(&dst,
 +                            AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT*(!!channels) +
 +                            AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT*(!!channel_layout) +
 +                            AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE*(!!sample_rate) +
 +                            AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS*(!!(width|height))
 +                           );
 +        if (channels)
 +            bytestream_put_le32(&dst, channels);
 +        if (channel_layout)
 +            bytestream_put_le64(&dst, channel_layout);
 +        if (sample_rate)
 +            bytestream_put_le32(&dst, sample_rate);
 +        if (width || height){
 +            bytestream_put_le32(&dst, width);
 +            bytestream_put_le32(&dst, height);
 +        }
 +    }
 +
 +    if (skip_start || skip_end) {
 +        uint8_t *dst = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
 +        if (!dst)
 +            return AVERROR(ENOMEM);
 +        AV_WL32(dst, skip_start);
 +        AV_WL32(dst+4, skip_end);
 +    }
 +
 +    if (avio_tell(bc) >= maxpos)
 +        return AVERROR_INVALIDDATA;
 +
 +    return 0;
 +}
 +
  static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id,
                                 uint8_t *header_idx, int frame_code)
  {
      AVFormatContext *s = nut->avf;
      AVIOContext *bc    = s->pb;
      StreamContext *stc;
 -    int size, flags, size_mul, pts_delta, i, reserved_count;
 +    int size, flags, size_mul, pts_delta, i, reserved_count, ret;
      uint64_t tmp;
  
      if (!(nut->flags & NUT_PIPE) &&
          if (coded_pts < (1 << stc->msb_pts_shift)) {
              *pts = ff_lsb2full(stc, coded_pts);
          } else
 -            *pts = coded_pts - (1 << stc->msb_pts_shift);
 +            *pts = coded_pts - (1LL << stc->msb_pts_shift);
      } else
          *pts = stc->last_pts + pts_delta;
      if (flags & FLAG_SIZE_MSB)
          *header_idx = ffio_read_varlen(bc);
      if (flags & FLAG_RESERVED)
          reserved_count = ffio_read_varlen(bc);
 -    for (i = 0; i < reserved_count; i++)
 +    for (i = 0; i < reserved_count; i++) {
 +        if (bc->eof_reached) {
 +            av_log(s, AV_LOG_ERROR, "reached EOF while decoding frame header\n");
 +            return AVERROR_INVALIDDATA;
 +        }
          ffio_read_varlen(bc);
 +    }
  
      if (*header_idx >= (unsigned)nut->header_count) {
          av_log(s, AV_LOG_ERROR, "header_idx invalid\n");
      stc->last_flags = flags;
  
      return size;
 +fail:
 +    return ret;
  }
  
  static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)
      if (nut->header[header_idx])
          memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
      pkt->pos = avio_tell(bc); // FIXME
 -    avio_read(bc, pkt->data + nut->header_len[header_idx], size);
 +    if (stc->last_flags & FLAG_SM_DATA) {
 +        int sm_size;
 +        if (read_sm_data(s, bc, pkt, 0, pkt->pos + size) < 0) {
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
 +        }
 +        if (read_sm_data(s, bc, pkt, 1, pkt->pos + size) < 0) {
 +            ret = AVERROR_INVALIDDATA;
 +            goto fail;
 +        }
 +        sm_size = avio_tell(bc) - pkt->pos;
 +        size      -= sm_size;
 +        pkt->size -= sm_size;
 +    }
 +
 +    ret = avio_read(bc, pkt->data + nut->header_len[header_idx], size);
 +    if (ret != size) {
 +        if (ret < 0)
 +            goto fail;
 +    }
 +    av_shrink_packet(pkt, nut->header_len[header_idx] + ret);
  
      pkt->stream_index = stream_id;
      if (stc->last_flags & FLAG_KEY)
      pkt->pts = pts;
  
      return 0;
 +fail:
 +    av_packet_unref(pkt);
 +    return ret;
  }
  
  static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
              pos -= 8;
          } else {
              frame_code = avio_r8(bc);
 -            if (bc->eof_reached)
 +            if (avio_feof(bc))
                  return AVERROR_EOF;
              if (frame_code == 'N') {
                  tmp = frame_code;
          default:
  resync:
              av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);
 -            tmp = find_any_startcode(bc, nut->last_syncpoint_pos + 1);
 +            tmp = find_any_startcode(bc, FFMAX(nut->last_syncpoint_pos, nut->last_resync_pos) + 1);
 +            nut->last_resync_pos = avio_tell(bc);
              if (tmp == 0)
                  return AVERROR_INVALIDDATA;
              av_log(s, AV_LOG_DEBUG, "sync\n");
@@@ -1240,18 -947,21 +1204,18 @@@ static int64_t nut_read_timestamp(AVFor
      do {
          pos = find_startcode(bc, SYNCPOINT_STARTCODE, pos) + 1;
          if (pos < 1) {
 -            assert(nut->next_startcode == 0);
              av_log(s, AV_LOG_ERROR, "read_timestamp failed.\n");
              return AV_NOPTS_VALUE;
          }
      } while (decode_syncpoint(nut, &pts, &back_ptr) < 0);
      *pos_arg = pos - 1;
 -    assert(nut->last_syncpoint_pos == *pos_arg);
 +    av_assert0(nut->last_syncpoint_pos == *pos_arg);
  
      av_log(s, AV_LOG_DEBUG, "return %"PRId64" %"PRId64"\n", pts, back_ptr);
 -    if (stream_index == -1)
 -        return pts;
 -    else if (stream_index == -2)
 +    if (stream_index == -2)
          return back_ptr;
 -
 -    return AV_NOPTS_VALUE;
 +    av_assert0(stream_index == -1);
 +    return pts;
  }
  
  static int read_seek(AVFormatContext *s, int stream_index,
  
      if (st->index_entries) {
          int index = av_index_search_timestamp(st, pts, flags);
 +        if (index < 0)
 +            index = av_index_search_timestamp(st, pts, flags ^ AVSEEK_FLAG_BACKWARD);
          if (index < 0)
              return -1;
  
          pos2 = st->index_entries[index].pos;
          ts   = st->index_entries[index].timestamp;
      } else {
 -        av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pts_cmp,
 +        av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pts_cmp,
                       (void **) next_node);
          av_log(s, AV_LOG_DEBUG, "%"PRIu64"-%"PRIu64" %"PRId64"-%"PRId64"\n",
                 next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,
                              next_node[1]->pos, next_node[1]->pos,
                              next_node[0]->ts, next_node[1]->ts,
                              AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);
 +        if (pos < 0)
 +            return pos;
  
          if (!(flags & AVSEEK_FLAG_BACKWARD)) {
              dummy.pos    = pos + 16;
              next_node[1] = &nopts_sp;
 -            av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,
 +            av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp,
                           (void **) next_node);
              pos2 = ff_gen_search(s, -2, dummy.pos, next_node[0]->pos,
                                   next_node[1]->pos, next_node[1]->pos,
              // FIXME dir but I think it does not matter
          }
          dummy.pos = pos;
 -        sp = av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,
 +        sp = av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp,
                            NULL);
  
 -        assert(sp);
 +        av_assert0(sp);
          pos2 = sp->back_ptr - 15;
      }
      av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos2);
      pos = find_startcode(s->pb, SYNCPOINT_STARTCODE, pos2);
      avio_seek(s->pb, pos, SEEK_SET);
 +    nut->last_syncpoint_pos = pos;
      av_log(NULL, AV_LOG_DEBUG, "SP: %"PRId64"\n", pos);
      if (pos2 > pos || pos2 + 15 < pos)
          av_log(NULL, AV_LOG_ERROR, "no syncpoint at backptr pos\n");
      for (i = 0; i < s->nb_streams; i++)
          nut->stream[i].skip_until_key_frame = 1;
  
 +    nut->last_resync_pos = 0;
 +
      return 0;
  }
  
  AVInputFormat ff_nut_demuxer = {
      .name           = "nut",
      .long_name      = NULL_IF_CONFIG_SMALL("NUT"),
 +    .flags          = AVFMT_SEEK_TO_PTS,
      .priv_data_size = sizeof(NUTContext),
      .read_probe     = nut_probe,
      .read_header    = nut_read_header,
diff --combined libavformat/nutenc.c
index 9e422e1aa8718911dd168f306a2502bd80c624bd,3c824a600d8b2ab3c3c48dcdd9382b0b6c5b0390..a92ff55c01373bd7db36088114888a1c1d15ef69
@@@ -2,20 -2,20 +2,20 @@@
   * nut muxer
   * Copyright (c) 2004-2007 Michael Niedermayer
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/mathematics.h"
  #include "libavutil/tree.h"
  #include "libavutil/dict.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/time.h"
  #include "libavutil/opt.h"
 +#include "libavcodec/bytestream.h"
  #include "libavcodec/mpegaudiodata.h"
  #include "nut.h"
  #include "internal.h"
@@@ -66,9 -64,12 +66,9 @@@ static int find_expected_header(AVCodec
          lsf           = sample_rate < (24000 + 32000) / 2;
          mpeg25        = sample_rate < (12000 + 16000) / 2;
          sample_rate <<= lsf + mpeg25;
 -        if (sample_rate < (32000 + 44100) / 2)
 -            sample_rate_index = 2;
 -        else if (sample_rate < (44100 + 48000) / 2)
 -            sample_rate_index = 0;
 -        else
 -            sample_rate_index = 1;
 +        if      (sample_rate < (32000 + 44100) / 2) sample_rate_index = 2;
 +        else if (sample_rate < (44100 + 48000) / 2) sample_rate_index = 0;
 +        else                                        sample_rate_index = 1;
  
          sample_rate = avpriv_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25);
  
@@@ -168,23 -169,11 +168,23 @@@ static void build_frame_code(AVFormatCo
      for (stream_id = 0; stream_id < s->nb_streams; stream_id++) {
          int start2 = start + (end - start) * stream_id       / s->nb_streams;
          int end2   = start + (end - start) * (stream_id + 1) / s->nb_streams;
 -        AVCodecParameters *par = s->streams[stream_id]->codecpar;
 -        const AVCodecDescriptor *desc = avcodec_descriptor_get(par->codec_id);
 -        int is_audio          = par->codec_type == AVMEDIA_TYPE_AUDIO;
 +        AVCodecParameters *par        = s->streams[stream_id]->codecpar;
 +        int is_audio                  = par->codec_type == AVMEDIA_TYPE_AUDIO;
          int intra_only        = /*codec->intra_only || */ is_audio;
          int pred_count;
 +        int frame_size = 0;
 +
 +        if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
 +            frame_size = av_get_audio_frame_duration2(par, 0);
 +            if (par->codec_id == AV_CODEC_ID_VORBIS && !frame_size)
 +                frame_size = 64;
 +        } else {
 +            AVRational f = av_div_q(av_inv_q(s->streams[stream_id]->avg_frame_rate), *nut->stream[stream_id].time_base);
 +            if (f.den == 1 && f.num>0)
 +                frame_size = f.num;
 +        }
 +        if (!frame_size)
 +            frame_size = 1;
  
          for (key_frame = 0; key_frame < 2; key_frame++) {
              if (!intra_only || !keyframe_0_esc || key_frame != 0) {
          }
  
          key_frame = intra_only;
 +#if 1
          if (is_audio) {
              int frame_bytes;
              int pts;
                  frame_bytes = frame_size * (int64_t)par->bit_rate / (8 * par->sample_rate);
              }
  
 -            for (pts = 0; pts < 2; pts++)
 +            for (pts = 0; pts < 2; pts++) {
                  for (pred = 0; pred < 2; pred++) {
 -                    FrameCode *ft = &nut->frame_code[start2];
 +                    FrameCode *ft  = &nut->frame_code[start2];
                      ft->flags      = FLAG_KEY * key_frame;
                      ft->stream_id  = stream_id;
                      ft->size_mul   = frame_bytes + 2;
                      ft->size_lsb   = frame_bytes + pred;
 -                    ft->pts_delta  = pts;
 +                    ft->pts_delta  = pts * frame_size;
                      ft->header_idx = find_header_idx(s, par, frame_bytes + pred, key_frame);
                      start2++;
                  }
 +            }
          } else {
              FrameCode *ft = &nut->frame_code[start2];
              ft->flags     = FLAG_KEY | FLAG_SIZE_MSB;
              ft->stream_id = stream_id;
              ft->size_mul  = 1;
 -            ft->pts_delta = 1;
 +            ft->pts_delta = frame_size;
              start2++;
          }
 +#endif
  
 -        if (desc && desc->props & AV_CODEC_PROP_REORDER) {
 +        if (par->video_delay) {
              pred_count    = 5;
              pred_table[0] = -2;
              pred_table[1] = -1;
              int start3 = start2 + (end2 - start2) * pred / pred_count;
              int end3   = start2 + (end2 - start2) * (pred + 1) / pred_count;
  
 +            pred_table[pred] *= frame_size;
 +
              for (index = start3; index < end3; index++) {
                  FrameCode *ft = &nut->frame_code[index];
                  ft->flags     = FLAG_KEY * key_frame;
              }
          }
      }
 -    memmove(&nut->frame_code['N' + 1], &nut->frame_code['N'],
 -            sizeof(FrameCode) * (255 - 'N'));
 +    memmove(&nut->frame_code['N' + 1], &nut->frame_code['N'], sizeof(FrameCode) * (255 - 'N'));
      nut->frame_code[0].flags       =
          nut->frame_code[255].flags =
          nut->frame_code['N'].flags = FLAG_INVALID;
  }
  
 -static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc,
 -                   uint64_t val)
 +static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val)
  {
      val *= nut->time_base_count;
      val += time_base - nut->time_base;
   */
  static void put_str(AVIOContext *bc, const char *string)
  {
 -    int len = strlen(string);
 +    size_t len = strlen(string);
  
      ff_put_v(bc, len);
      avio_write(bc, string, len);
@@@ -299,25 -285,6 +299,6 @@@ static void put_s(AVIOContext *bc, int6
      ff_put_v(bc, 2 * FFABS(val) - (val > 0));
  }
  
- #ifdef TRACE
- static inline void ff_put_v_trace(AVIOContext *bc, uint64_t v, const char *file,
-                                   const char *func, int line)
- {
-     av_log(NULL, AV_LOG_DEBUG, "ff_put_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
-     ff_put_v(bc, v);
- }
- static inline void put_s_trace(AVIOContext *bc, int64_t v, const char *file, const char *func, int line)
- {
-     av_log(NULL, AV_LOG_DEBUG, "put_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
-     put_s(bc, v);
- }
- #define ff_put_v(bc, v)  ff_put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #define put_s(bc, v)  put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
- #endif
  //FIXME remove calculate_checksum
  static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc,
                         int calculate_checksum, uint64_t startcode)
@@@ -349,8 -316,6 +330,8 @@@ static void write_mainheader(NUTContex
      int64_t tmp_match;
  
      ff_put_v(bc, nut->version);
 +    if (nut->version > 3)
 +        ff_put_v(bc, nut->minor_version = 1);
      ff_put_v(bc, nut->avf->nb_streams);
      ff_put_v(bc, nut->max_distance);
      ff_put_v(bc, nut->time_base_count);
          tmp_fields = 0;
          tmp_size   = 0;
  //        tmp_res=0;
 -        if (tmp_pts != nut->frame_code[i].pts_delta)
 -            tmp_fields = 1;
 -        if (tmp_mul != nut->frame_code[i].size_mul)
 -            tmp_fields = 2;
 -        if (tmp_stream != nut->frame_code[i].stream_id)
 -            tmp_fields = 3;
 -        if (tmp_size != nut->frame_code[i].size_lsb)
 -            tmp_fields = 4;
 -//        if(tmp_res    != nut->frame_code[i].res            ) tmp_fields=5;
 -        if (tmp_head_idx != nut->frame_code[i].header_idx)
 -            tmp_fields = 8;
 +        if (tmp_pts      != nut->frame_code[i].pts_delta ) tmp_fields = 1;
 +        if (tmp_mul      != nut->frame_code[i].size_mul  ) tmp_fields = 2;
 +        if (tmp_stream   != nut->frame_code[i].stream_id ) tmp_fields = 3;
 +        if (tmp_size     != nut->frame_code[i].size_lsb  ) tmp_fields = 4;
 +//        if (tmp_res    != nut->frame_code[i].res            ) tmp_fields=5;
 +        if (tmp_head_idx != nut->frame_code[i].header_idx) tmp_fields = 8;
  
          tmp_pts    = nut->frame_code[i].pts_delta;
          tmp_flags  = nut->frame_code[i].flags;
  
          ff_put_v(bc, tmp_flags);
          ff_put_v(bc, tmp_fields);
 -        if (tmp_fields > 0)
 -            put_s(bc, tmp_pts);
 -        if (tmp_fields > 1)
 -            ff_put_v(bc, tmp_mul);
 -        if (tmp_fields > 2)
 -            ff_put_v(bc, tmp_stream);
 -        if (tmp_fields > 3)
 -            ff_put_v(bc, tmp_size);
 -        if (tmp_fields > 4)
 -            ff_put_v(bc, 0 /*tmp_res*/);
 -        if (tmp_fields > 5)
 -            ff_put_v(bc, j);
 -        if (tmp_fields > 6)
 -            ff_put_v(bc, tmp_match);
 -        if (tmp_fields > 7)
 -            ff_put_v(bc, tmp_head_idx);
 +        if (tmp_fields > 0) put_s(bc, tmp_pts);
 +        if (tmp_fields > 1) ff_put_v(bc, tmp_mul);
 +        if (tmp_fields > 2) ff_put_v(bc, tmp_stream);
 +        if (tmp_fields > 3) ff_put_v(bc, tmp_size);
 +        if (tmp_fields > 4) ff_put_v(bc, 0 /*tmp_res*/);
 +        if (tmp_fields > 5) ff_put_v(bc, j);
 +        if (tmp_fields > 6) ff_put_v(bc, tmp_match);
 +        if (tmp_fields > 7) ff_put_v(bc, tmp_head_idx);
      }
      ff_put_v(bc, nut->header_count - 1);
      for (i = 1; i < nut->header_count; i++) {
          avio_write(bc, nut->header[i], nut->header_len[i]);
      }
      // flags had been effectively introduced in version 4
 -    if (nut->version > NUT_STABLE_VERSION)
 +    if (nut->version > 3)
          ff_put_v(bc, nut->flags);
  }
  
@@@ -427,18 -405,32 +408,18 @@@ static int write_streamheader(AVFormatC
  {
      NUTContext *nut       = avctx->priv_data;
      AVCodecParameters *par = st->codecpar;
 -    const AVCodecDescriptor *desc = avcodec_descriptor_get(par->codec_id);
 -    unsigned codec_tag    = av_codec_get_tag(ff_nut_codec_tags, par->codec_id);
  
      ff_put_v(bc, i);
      switch (par->codec_type) {
 -    case AVMEDIA_TYPE_VIDEO:
 -        ff_put_v(bc, 0);
 -        break;
 -    case AVMEDIA_TYPE_AUDIO:
 -        ff_put_v(bc, 1);
 -        break;
 -    case AVMEDIA_TYPE_SUBTITLE:
 -        ff_put_v(bc, 2);
 -        break;
 -    default:
 -        ff_put_v(bc, 3);
 -        break;
 +    case AVMEDIA_TYPE_VIDEO:    ff_put_v(bc, 0); break;
 +    case AVMEDIA_TYPE_AUDIO:    ff_put_v(bc, 1); break;
 +    case AVMEDIA_TYPE_SUBTITLE: ff_put_v(bc, 2); break;
 +    default:                    ff_put_v(bc, 3); break;
      }
      ff_put_v(bc, 4);
  
 -    if (av_codec_get_id(ff_nut_codec_tags, par->codec_tag) == par->codec_id ||
 -        !codec_tag || par->codec_id == AV_CODEC_ID_RAWVIDEO)
 -        codec_tag = par->codec_tag;
 -
 -    if (codec_tag) {
 -        avio_wl32(bc, codec_tag);
 +    if (par->codec_tag) {
 +        avio_wl32(bc, par->codec_tag);
      } else {
          av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i);
          return AVERROR(EINVAL);
      ff_put_v(bc, nut->stream[i].time_base - nut->time_base);
      ff_put_v(bc, nut->stream[i].msb_pts_shift);
      ff_put_v(bc, nut->stream[i].max_pts_distance);
 -    ff_put_v(bc, (desc && desc->props & AV_CODEC_PROP_REORDER) ? 16 : 0);
 +    ff_put_v(bc, par->video_delay);
      avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
  
      ff_put_v(bc, par->extradata_size);
@@@ -498,7 -490,6 +479,7 @@@ static int write_globalinfo(NUTContext 
      if (ret < 0)
          return ret;
  
 +    ff_standardize_creation_time(s);
      while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
          count += add_info(dyn_bc, t->key, t->value);
  
      return 0;
  }
  
 -static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
 +static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id) {
      AVFormatContext *s= nut->avf;
      AVStream* st = s->streams[stream_id];
 +    AVDictionaryEntry *t = NULL;
      AVIOContext *dyn_bc;
      uint8_t *dyn_buf=NULL;
      int count=0, dyn_size, i;
      int ret = avio_open_dyn_buf(&dyn_bc);
 -    if(ret < 0)
 +    if (ret < 0)
          return ret;
  
 +    while ((t = av_dict_get(st->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
 +        count += add_info(dyn_bc, t->key, t->value);
      for (i=0; ff_nut_dispositions[i].flag; ++i) {
          if (st->disposition & ff_nut_dispositions[i].flag)
              count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
      }
 +    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
 +        uint8_t buf[256];
 +        if (st->r_frame_rate.num>0 && st->r_frame_rate.den>0)
 +            snprintf(buf, sizeof(buf), "%d/%d", st->r_frame_rate.num, st->r_frame_rate.den);
 +        else
 +            snprintf(buf, sizeof(buf), "%d/%d", st->avg_frame_rate.num, st->avg_frame_rate.den);
 +        count += add_info(dyn_bc, "r_frame_rate", buf);
 +    }
      dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
  
      if (count) {
@@@ -585,58 -565,6 +566,58 @@@ static int write_chapter(NUTContext *nu
      return 0;
  }
  
 +static int write_index(NUTContext *nut, AVIOContext *bc) {
 +    int i;
 +    Syncpoint dummy= { .pos= 0 };
 +    Syncpoint *next_node[2] = { NULL };
 +    int64_t startpos = avio_tell(bc);
 +    int64_t payload_size;
 +
 +    put_tt(nut, nut->max_pts_tb, bc, nut->max_pts);
 +
 +    ff_put_v(bc, nut->sp_count);
 +
 +    for (i=0; i<nut->sp_count; i++) {
 +        av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp, (void**)next_node);
 +        ff_put_v(bc, (next_node[1]->pos >> 4) - (dummy.pos>>4));
 +        dummy.pos = next_node[1]->pos;
 +    }
 +
 +    for (i=0; i<nut->avf->nb_streams; i++) {
 +        StreamContext *nus= &nut->stream[i];
 +        int64_t last_pts= -1;
 +        int j, k;
 +        for (j=0; j<nut->sp_count; j++) {
 +            int flag;
 +            int n = 0;
 +
 +            if (j && nus->keyframe_pts[j] == nus->keyframe_pts[j-1]) {
 +                av_log(nut->avf, AV_LOG_WARNING, "Multiple keyframes with same PTS\n");
 +                nus->keyframe_pts[j] = AV_NOPTS_VALUE;
 +            }
 +
 +            flag = (nus->keyframe_pts[j] != AV_NOPTS_VALUE) ^ (j+1 == nut->sp_count);
 +            for (; j<nut->sp_count && (nus->keyframe_pts[j] != AV_NOPTS_VALUE) == flag; j++)
 +                n++;
 +
 +            ff_put_v(bc, 1 + 2*flag + 4*n);
 +            for (k= j - n; k<=j && k<nut->sp_count; k++) {
 +                if (nus->keyframe_pts[k] == AV_NOPTS_VALUE)
 +                    continue;
 +                av_assert0(nus->keyframe_pts[k] > last_pts);
 +                ff_put_v(bc, nus->keyframe_pts[k] - last_pts);
 +                last_pts = nus->keyframe_pts[k];
 +            }
 +        }
 +    }
 +
 +    payload_size = avio_tell(bc) - startpos + 8 + 4;
 +
 +    avio_wb64(bc, 8 + payload_size + av_log2(payload_size) / 7 + 1 + 4*(payload_size > 4096));
 +
 +    return 0;
 +}
 +
  static int write_headers(AVFormatContext *avctx, AVIOContext *bc)
  {
      NUTContext *nut = avctx->priv_data;
@@@ -705,8 -633,8 +686,8 @@@ static int nut_write_header(AVFormatCon
  
      nut->avf = s;
  
 -    nut->version = NUT_STABLE_VERSION + !!nut->flags;
 -    if (nut->flags && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 +    nut->version = FFMAX(NUT_STABLE_VERSION, 3 + !!nut->flags);
 +    if (nut->version > 3 && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
          av_log(s, AV_LOG_ERROR,
                 "The additional syncpoint modes require version %d, "
                 "that is currently not finalized, "
          return AVERROR_EXPERIMENTAL;
      }
  
 -    nut->stream = av_mallocz(sizeof(StreamContext) * s->nb_streams);
 -    if (s->nb_chapters)
 -        nut->chapter = av_mallocz(sizeof(ChapterContext) * s->nb_chapters);
 -    nut->time_base = av_mallocz(sizeof(AVRational) * (s->nb_streams +
 -                                                      s->nb_chapters));
 -    if (!nut->stream || (s->nb_chapters && !nut->chapter) || !nut->time_base) {
 +    nut->stream   = av_calloc(s->nb_streams,  sizeof(*nut->stream ));
 +    nut->chapter  = av_calloc(s->nb_chapters, sizeof(*nut->chapter));
 +    nut->time_base= av_calloc(s->nb_streams +
 +                              s->nb_chapters, sizeof(*nut->time_base));
 +    if (!nut->stream || !nut->chapter || !nut->time_base) {
          av_freep(&nut->stream);
          av_freep(&nut->chapter);
          av_freep(&nut->time_base);
          AVStream *st = s->streams[i];
          int ssize;
          AVRational time_base;
 -        ff_parse_specific_params(st, &time_base.den, &ssize,
 -                                 &time_base.num);
 +        ff_parse_specific_params(st, &time_base.den, &ssize, &time_base.num);
 +
 +        if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate) {
 +            time_base = (AVRational) {1, st->codecpar->sample_rate};
 +        } else {
 +            time_base = ff_choose_timebase(s, st, 48000);
 +        }
  
          avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
  
      nut->max_distance = MAX_DISTANCE;
      build_elision_headers(s);
      build_frame_code(s);
 -    assert(nut->frame_code['N'].flags == FLAG_INVALID);
 +    av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);
  
      avio_write(bc, ID_STRING, strlen(ID_STRING));
      avio_w8(bc, 0);
      if ((ret = write_headers(s, bc)) < 0)
          return ret;
  
 -    avio_flush(bc);
 +    if (s->avoid_negative_ts < 0)
 +        s->avoid_negative_ts = 1;
  
 -    //FIXME index
 +    avio_flush(bc);
  
      return 0;
  }
@@@ -802,8 -725,6 +783,8 @@@ static int get_needed_flags(NUTContext 
          flags |= FLAG_SIZE_MSB;
      if (pkt->pts - nus->last_pts != fc->pts_delta)
          flags |= FLAG_CODED_PTS;
 +    if (pkt->side_data_elems && nut->version > 3)
 +        flags |= FLAG_SM_DATA;
      if (pkt->size > 2 * nut->max_distance)
          flags |= FLAG_CHECKSUM;
      if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
@@@ -836,165 -757,24 +817,165 @@@ static int find_best_header_idx(NUTCont
      return best_i;
  }
  
 +static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
 +{
 +    int ret, i, dyn_size;
 +    unsigned flags;
 +    AVIOContext *dyn_bc;
 +    int sm_data_count = 0;
 +    uint8_t tmp[256];
 +    uint8_t *dyn_buf;
 +
 +    ret = avio_open_dyn_buf(&dyn_bc);
 +    if (ret < 0)
 +        return ret;
 +
 +    for (i = 0; i<pkt->side_data_elems; i++) {
 +        const uint8_t *data = pkt->side_data[i].data;
 +        int size = pkt->side_data[i].size;
 +        const uint8_t *data_end = data + size;
 +
 +        if (is_meta) {
 +            if (   pkt->side_data[i].type == AV_PKT_DATA_METADATA_UPDATE
 +                || pkt->side_data[i].type == AV_PKT_DATA_STRINGS_METADATA) {
 +                if (!size || data[size-1]) {
 +                    ret = AVERROR(EINVAL);
 +                    goto fail;
 +                }
 +                while (data < data_end) {
 +                    const uint8_t *key = data;
 +                    const uint8_t *val = data + strlen(key) + 1;
 +
 +                    if(val >= data_end) {
 +                        ret = AVERROR(EINVAL);
 +                        goto fail;
 +                    }
 +                    put_str(dyn_bc, key);
 +                    put_s(dyn_bc, -1);
 +                    put_str(dyn_bc, val);
 +                    data = val + strlen(val) + 1;
 +                    sm_data_count++;
 +                }
 +            }
 +        } else {
 +            switch (pkt->side_data[i].type) {
 +            case AV_PKT_DATA_PALETTE:
 +            case AV_PKT_DATA_NEW_EXTRADATA:
 +            case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL:
 +            default:
 +                if (pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
 +                    put_str(dyn_bc, "Palette");
 +                } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
 +                    put_str(dyn_bc, "Extradata");
 +                } else if(pkt->side_data[i].type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
 +                    snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
 +                    put_str(dyn_bc, tmp);
 +                } else {
 +                    snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
 +                            (s->flags & AVFMT_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
 +                            pkt->side_data[i].type);
 +                    put_str(dyn_bc, tmp);
 +                }
 +                put_s(dyn_bc, -2);
 +                put_str(dyn_bc, "bin");
 +                ff_put_v(dyn_bc, pkt->side_data[i].size);
 +                avio_write(dyn_bc, data, pkt->side_data[i].size);
 +                sm_data_count++;
 +                break;
 +            case AV_PKT_DATA_PARAM_CHANGE:
 +                flags = bytestream_get_le32(&data);
 +                if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
 +                    put_str(dyn_bc, "Channels");
 +                    put_s(dyn_bc, bytestream_get_le32(&data));
 +                    sm_data_count++;
 +                }
 +                if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
 +                    put_str(dyn_bc, "ChannelLayout");
 +                    put_s(dyn_bc, -2);
 +                    put_str(dyn_bc, "u64");
 +                    ff_put_v(bc, 8);
 +                    avio_write(dyn_bc, data, 8); data+=8;
 +                    sm_data_count++;
 +                }
 +                if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
 +                    put_str(dyn_bc, "SampleRate");
 +                    put_s(dyn_bc, bytestream_get_le32(&data));
 +                    sm_data_count++;
 +                }
 +                if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
 +                    put_str(dyn_bc, "Width");
 +                    put_s(dyn_bc, bytestream_get_le32(&data));
 +                    put_str(dyn_bc, "Height");
 +                    put_s(dyn_bc, bytestream_get_le32(&data));
 +                    sm_data_count+=2;
 +                }
 +                break;
 +            case AV_PKT_DATA_SKIP_SAMPLES:
 +                if (AV_RL32(data)) {
 +                    put_str(dyn_bc, "SkipStart");
 +                    put_s(dyn_bc, (unsigned)AV_RL32(data));
 +                    sm_data_count++;
 +                }
 +                if (AV_RL32(data+4)) {
 +                    put_str(dyn_bc, "SkipEnd");
 +                    put_s(dyn_bc, (unsigned)AV_RL32(data+4));
 +                    sm_data_count++;
 +                }
 +                break;
 +            case AV_PKT_DATA_METADATA_UPDATE:
 +            case AV_PKT_DATA_STRINGS_METADATA:
 +            case AV_PKT_DATA_QUALITY_STATS:
 +                // belongs into meta, not side data
 +                break;
 +            }
 +        }
 +    }
 +
 +fail:
 +    ff_put_v(bc, sm_data_count);
 +    dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
 +    avio_write(bc, dyn_buf, dyn_size);
 +    av_freep(&dyn_buf);
 +
 +    return ret;
 +}
 +
  static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
  {
      NUTContext *nut    = s->priv_data;
      StreamContext *nus = &nut->stream[pkt->stream_index];
 -    AVIOContext *bc    = s->pb, *dyn_bc;
 +    AVIOContext *bc    = s->pb, *dyn_bc, *sm_bc = NULL;
      FrameCode *fc;
      int64_t coded_pts;
 -    int best_length, frame_code, flags, needed_flags, i, header_idx,
 -        best_header_idx;
 +    int best_length, frame_code, flags, needed_flags, i, header_idx;
 +    int best_header_idx;
      int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
      int store_sp  = 0;
 -    int ret;
 +    int ret = 0;
 +    int sm_size = 0;
 +    int data_size = pkt->size;
 +    uint8_t *sm_buf = NULL;
  
      if (pkt->pts < 0) {
          av_log(s, AV_LOG_ERROR,
                 "Negative pts not supported stream %d, pts %"PRId64"\n",
                 pkt->stream_index, pkt->pts);
 -        return AVERROR_INVALIDDATA;
 +        if (pkt->pts == AV_NOPTS_VALUE)
 +            av_log(s, AV_LOG_ERROR, "Try to enable the genpts flag\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (pkt->side_data_elems && nut->version > 3) {
 +        ret = avio_open_dyn_buf(&sm_bc);
 +        if (ret < 0)
 +            return ret;
 +        ret = write_sm_data(s, sm_bc, pkt, 0);
 +        if (ret >= 0)
 +            ret = write_sm_data(s, sm_bc, pkt, 1);
 +        sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
 +        if (ret < 0)
 +            goto fail;
 +        data_size += sm_size;
      }
  
      if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
      if (key_frame && !(nus->last_flags & FLAG_KEY))
          store_sp = 1;
  
 -    if (pkt->size + 30 /*FIXME check*/ + avio_tell(bc) >=
 -        nut->last_syncpoint_pos + nut->max_distance)
 +    if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
          store_sp = 1;
  
  //FIXME: Ensure store_sp is 1 in the first place.
  
      if (store_sp &&
          (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) {
 -        Syncpoint *sp, dummy = { .pos = INT64_MAX };
 +        int64_t sp_pos = INT64_MAX;
  
          ff_nut_reset_ts(nut, *nus->time_base, pkt->dts);
          for (i = 0; i < s->nb_streams; i++) {
                  AV_ROUND_DOWN);
              int index = av_index_search_timestamp(st, dts_tb,
                                                    AVSEEK_FLAG_BACKWARD);
 -            if (index >= 0)
 -                dummy.pos = FFMIN(dummy.pos, st->index_entries[index].pos);
 +            if (index >= 0) {
 +                sp_pos = FFMIN(sp_pos, st->index_entries[index].pos);
 +                if (!nut->write_index && 2*index > st->nb_index_entries) {
 +                    memmove(st->index_entries,
 +                            st->index_entries + index,
 +                            sizeof(*st->index_entries) * (st->nb_index_entries - index));
 +                    st->nb_index_entries -=  index;
 +                }
 +            }
          }
 -        if (dummy.pos == INT64_MAX)
 -            dummy.pos = 0;
 -        sp = av_tree_find(nut->syncpoints, &dummy, (void *)ff_nut_sp_pos_cmp,
 -                          NULL);
  
          nut->last_syncpoint_pos = avio_tell(bc);
          ret                     = avio_open_dyn_buf(&dyn_bc);
          if (ret < 0)
 -            return ret;
 +            goto fail;
          put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
 -        ff_put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos) >> 4 : 0);
 +        ff_put_v(dyn_bc, sp_pos != INT64_MAX ? (nut->last_syncpoint_pos - sp_pos) >> 4 : 0);
  
          if (nut->flags & NUT_BROADCAST) {
              put_tt(nut, nus->time_base, dyn_bc,
          }
          put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
  
 +        if (nut->write_index) {
          if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0)
 -            return ret;
 +            goto fail;
 +
 +        if ((1ll<<60) % nut->sp_count == 0)
 +            for (i=0; i<s->nb_streams; i++) {
 +                int j;
 +                StreamContext *nus = &nut->stream[i];
 +                av_reallocp_array(&nus->keyframe_pts, 2*nut->sp_count, sizeof(*nus->keyframe_pts));
 +                if (!nus->keyframe_pts) {
 +                    ret = AVERROR(ENOMEM);
 +                    goto fail;
 +                }
 +                for (j=nut->sp_count == 1 ? 0 : nut->sp_count; j<2*nut->sp_count; j++)
 +                    nus->keyframe_pts[j] = AV_NOPTS_VALUE;
 +        }
 +        }
      }
 -    assert(nus->last_pts != AV_NOPTS_VALUE);
 +    av_assert0(nus->last_pts != AV_NOPTS_VALUE);
  
      coded_pts = pkt->pts & ((1 << nus->msb_pts_shift) - 1);
      if (ff_lsb2full(nus, coded_pts) != pkt->pts)
          if (flags & FLAG_STREAM_ID)
              length += ff_get_v_length(pkt->stream_index);
  
 -        if (pkt->size % fc->size_mul != fc->size_lsb)
 +        if (data_size % fc->size_mul != fc->size_lsb)
              continue;
          if (flags & FLAG_SIZE_MSB)
 -            length += ff_get_v_length(pkt->size / fc->size_mul);
 +            length += ff_get_v_length(data_size / fc->size_mul);
  
          if (flags & FLAG_CHECKSUM)
              length += 4;
          if (flags & FLAG_CODED_PTS)
              length += ff_get_v_length(coded_pts);
  
 -        if ((flags & FLAG_CODED)
 -            && nut->header_len[best_header_idx] >
 -            nut->header_len[fc->header_idx] + 1) {
 +        if (   (flags & FLAG_CODED)
 +            && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx] + 1) {
              flags |= FLAG_HEADER_IDX;
          }
  
              frame_code  = i;
          }
      }
 -
 -    if (frame_code < 0)
 -        return AVERROR_BUG;
 +    av_assert0(frame_code != -1);
  
      fc           = &nut->frame_code[frame_code];
      flags        = fc->flags;
          ff_put_v(bc, (flags ^ needed_flags) & ~(FLAG_CODED));
          flags = needed_flags;
      }
 -    if (flags & FLAG_STREAM_ID)
 -        ff_put_v(bc, pkt->stream_index);
 -    if (flags & FLAG_CODED_PTS)
 -        ff_put_v(bc, coded_pts);
 -    if (flags & FLAG_SIZE_MSB)
 -        ff_put_v(bc, pkt->size / fc->size_mul);
 -    if (flags & FLAG_HEADER_IDX)
 -        ff_put_v(bc, header_idx = best_header_idx);
 +    if (flags & FLAG_STREAM_ID)  ff_put_v(bc, pkt->stream_index);
 +    if (flags & FLAG_CODED_PTS)  ff_put_v(bc, coded_pts);
 +    if (flags & FLAG_SIZE_MSB )  ff_put_v(bc, data_size / fc->size_mul);
 +    if (flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx = best_header_idx);
  
 -    if (flags & FLAG_CHECKSUM)
 -        avio_wl32(bc, ffio_get_checksum(bc));
 -    else
 -        ffio_get_checksum(bc);
 +    if (flags & FLAG_CHECKSUM)   avio_wl32(bc, ffio_get_checksum(bc));
 +    else                         ffio_get_checksum(bc);
 +
 +    if (flags & FLAG_SM_DATA) {
 +        avio_write(bc, sm_buf, sm_size);
 +    }
 +    avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
  
 -    avio_write(bc, pkt->data + nut->header_len[header_idx],
 -               pkt->size - nut->header_len[header_idx]);
      nus->last_flags = flags;
      nus->last_pts   = pkt->pts;
  
      //FIXME just store one per syncpoint
 -    if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE))
 +    if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) {
          av_add_index_entry(
              s->streams[pkt->stream_index],
              nut->last_syncpoint_pos,
              0,
              0,
              AVINDEX_KEYFRAME);
 +        if (nus->keyframe_pts && nus->keyframe_pts[nut->sp_count] == AV_NOPTS_VALUE)
 +            nus->keyframe_pts[nut->sp_count] = pkt->pts;
 +    }
  
 -    return 0;
 +    if (!nut->max_pts_tb || av_compare_ts(nut->max_pts, *nut->max_pts_tb, pkt->pts, *nus->time_base) < 0) {
 +        nut->max_pts = pkt->pts;
 +        nut->max_pts_tb = nus->time_base;
 +    }
 +
 +fail:
 +    av_freep(&sm_buf);
 +
 +    return ret;
  }
  
  static int nut_write_trailer(AVFormatContext *s)
  {
      NUTContext *nut = s->priv_data;
 -    AVIOContext *bc = s->pb;
 +    AVIOContext *bc = s->pb, *dyn_bc;
 +    int ret;
  
      while (nut->header_count < 3)
          write_headers(s, bc);
  
 +    ret = avio_open_dyn_buf(&dyn_bc);
 +    if (ret >= 0 && nut->sp_count) {
 +        av_assert1(nut->write_index);
 +        write_index(nut, dyn_bc);
 +        put_packet(nut, bc, dyn_bc, 1, INDEX_STARTCODE);
 +    }
 +
 +    return 0;
 +}
 +
 +static void nut_write_deinit(AVFormatContext *s)
 +{
 +    NUTContext *nut = s->priv_data;
 +    int i;
 +
      ff_nut_free_sp(nut);
 +    if (nut->stream)
 +        for (i=0; i<s->nb_streams; i++)
 +            av_freep(&nut->stream[i].keyframe_pts);
 +
      av_freep(&nut->stream);
      av_freep(&nut->chapter);
      av_freep(&nut->time_base);
 -
 -    return 0;
  }
  
  #define OFFSET(x) offsetof(NUTContext, x)
@@@ -1221,7 -961,6 +1202,7 @@@ static const AVOption options[] = 
      { "default",     "",                                                0,             AV_OPT_TYPE_CONST, {.i64 = 0},             INT_MIN, INT_MAX, E, "syncpoints" },
      { "none",        "Disable syncpoints, low overhead and unseekable", 0,             AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE},      INT_MIN, INT_MAX, E, "syncpoints" },
      { "timestamped", "Extend syncpoints with a wallclock timestamp",    0,             AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, "syncpoints" },
 +    { "write_index", "Write index",                               OFFSET(write_index), AV_OPT_TYPE_BOOL,  {.i64 = 1},                   0,       1, E, },
      { NULL },
  };
  
@@@ -1244,7 -983,6 +1225,7 @@@ AVOutputFormat ff_nut_muxer = 
      .write_header   = nut_write_header,
      .write_packet   = nut_write_packet,
      .write_trailer  = nut_write_trailer,
 +    .deinit         = nut_write_deinit,
      .flags          = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
      .codec_tag      = ff_nut_codec_tags,
      .priv_class     = &class,