falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
42069 Commits
32 Branches
896MB
Tree: e2c95e6bd8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e2c95e6bd8'
${ noResults }
FFmpeg/libavformat/nutdec.c

1006 lines
32KB
Raw Blame History 

  1. /*

  2.  * "NUT" Container Format demuxer

  3.  * Copyright (c) 2004-2006 Michael Niedermayer

  4.  * Copyright (c) 2003 Alex Beregszaszi

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with FFmpeg; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. #include "libavutil/avstring.h"

  24. #include "libavutil/avassert.h"

  25. #include "libavutil/bswap.h"

  26. #include "libavutil/dict.h"

  27. #include "libavutil/mathematics.h"

  28. #include "libavutil/tree.h"

  29. #include "avio_internal.h"

  30. #include "nut.h"

  31. 

  32. #define NUT_MAX_STREAMS 256    /* arbitrary sanity check value */

  33. 

  34. static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)

  35. {

  36.     unsigned int len = ffio_read_varlen(bc);

  37. 

  38.     if (len && maxlen)

  39.         avio_read(bc, string, FFMIN(len, maxlen));

  40.     while (len > maxlen) {

  41.         avio_r8(bc);

  42.         len--;

  43.     }

  44. 

  45.     if (maxlen)

  46.         string[FFMIN(len, maxlen - 1)] = 0;

  47. 

  48.     if (maxlen == len)

  49.         return -1;

  50.     else

  51.         return 0;

  52. }

  53. 

  54. static int64_t get_s(AVIOContext *bc)

  55. {

  56.     int64_t v = ffio_read_varlen(bc) + 1;

  57. 

  58.     if (v & 1)

  59.         return -(v >> 1);

  60.     else

  61.         return  (v >> 1);

  62. }

  63. 

  64. static uint64_t get_fourcc(AVIOContext *bc)

  65. {

  66.     unsigned int len = ffio_read_varlen(bc);

  67. 

  68.     if (len == 2)

  69.         return avio_rl16(bc);

  70.     else if (len == 4)

  71.         return avio_rl32(bc);

  72.     else

  73.         return -1;

  74. }

  75. 

  76. #ifdef TRACE

  77. static inline uint64_t get_v_trace(AVIOContext *bc, char *file,

  78.                                    char *func, int line)

  79. {

  80.     uint64_t v = ffio_read_varlen(bc);

  81. 

  82.     av_log(NULL, AV_LOG_DEBUG, "get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n",

  83.            v, v, file, func, line);

  84.     return v;

  85. }

  86. 

  87. static inline int64_t get_s_trace(AVIOContext *bc, char *file,

  88.                                   char *func, int line)

  89. {

  90.     int64_t v = get_s(bc);

  91. 

  92.     av_log(NULL, AV_LOG_DEBUG, "get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n",

  93.            v, v, file, func, line);

  94.     return v;

  95. }

  96. 

  97. static inline uint64_t get_vb_trace(AVIOContext *bc, char *file,

  98.                                     char *func, int line)

  99. {

  100.     uint64_t v = get_vb(bc);

  101. 

  102.     av_log(NULL, AV_LOG_DEBUG, "get_vb %5"PRId64" / %"PRIX64" in %s %s:%d\n",

  103.            v, v, file, func, line);

  104.     return v;

  105. }

  106. #define ffio_read_varlen(bc) get_v_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)

  107. #define get_s(bc)            get_s_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)

  108. #define get_vb(bc)           get_vb_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  109. #endif

  110. 

  111. static int get_packetheader(NUTContext *nut, AVIOContext *bc,

  112.                             int calculate_checksum, uint64_t startcode)

  113. {

  114.     int64_t size;

  115. //    start = avio_tell(bc) - 8;

  116. 

  117.     startcode = av_be2ne64(startcode);

  118.     startcode = ff_crc04C11DB7_update(0, (uint8_t*) &startcode, 8);

  119. 

  120.     ffio_init_checksum(bc, ff_crc04C11DB7_update, startcode);

  121.     size = ffio_read_varlen(bc);

  122.     if (size > 4096)

  123.         avio_rb32(bc);

  124.     if (ffio_get_checksum(bc) && size > 4096)

  125.         return -1;

  126. 

  127.     ffio_init_checksum(bc, calculate_checksum ? ff_crc04C11DB7_update : NULL, 0);

  128. 

  129.     return size;

  130. }

  131. 

  132. static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)

  133. {

  134.     uint64_t state = 0;

  135. 

  136.     if (pos >= 0)

  137.         /* Note, this may fail if the stream is not seekable, but that should

  138.          * not matter, as in this case we simply start where we currently are */

  139.         avio_seek(bc, pos, SEEK_SET);

  140.     while (!url_feof(bc)) {

  141.         state = (state << 8) | avio_r8(bc);

  142.         if ((state >> 56) != 'N')

  143.             continue;

  144.         switch (state) {

  145.         case MAIN_STARTCODE:

  146.         case STREAM_STARTCODE:

  147.         case SYNCPOINT_STARTCODE:

  148.         case INFO_STARTCODE:

  149.         case INDEX_STARTCODE:

  150.             return state;

  151.         }

  152.     }

  153. 

  154.     return 0;

  155. }

  156. 

  157. /**

  158.  * Find the given startcode.

  159.  * @param code the startcode

  160.  * @param pos the start position of the search, or -1 if the current position

  161.  * @return the position of the startcode or -1 if not found

  162.  */

  163. static int64_t find_startcode(AVIOContext *bc, uint64_t code, int64_t pos)

  164. {

  165.     for (;;) {

  166.         uint64_t startcode = find_any_startcode(bc, pos);

  167.         if (startcode == code)

  168.             return avio_tell(bc) - 8;

  169.         else if (startcode == 0)

  170.             return -1;

  171.         pos = -1;

  172.     }

  173. }

  174. 

  175. static int nut_probe(AVProbeData *p)

  176. {

  177.     int i;

  178.     uint64_t code = 0;

  179. 

  180.     for (i = 0; i < p->buf_size; i++) {

  181.         code = (code << 8) | p->buf[i];

  182.         if (code == MAIN_STARTCODE)

  183.             return AVPROBE_SCORE_MAX;

  184.     }

  185.     return 0;

  186. }

  187. 

  188. #define GET_V(dst, check)                                                 \

  189.     tmp = ffio_read_varlen(bc);                                           \

  190.     if (!(check)) {                                                       \

  191.         av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp);  \

  192.         return -1;                                                        \

  193.     }                                                                     \

  194.     dst = tmp;

  195. 

  196. static int skip_reserved(AVIOContext *bc, int64_t pos)

  197. {

  198.     pos -= avio_tell(bc);

  199.     if (pos < 0) {

  200.         avio_seek(bc, pos, SEEK_CUR);

  201.         return -1;

  202.     } else {

  203.         while (pos--)

  204.             avio_r8(bc);

  205.         return 0;

  206.     }

  207. }

  208. 

  209. static int decode_main_header(NUTContext *nut)

  210. {

  211.     AVFormatContext *s = nut->avf;

  212.     AVIOContext *bc    = s->pb;

  213.     uint64_t tmp, end;

  214.     unsigned int stream_count;

  215.     int i, j, count;

  216.     int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;

  217. 

  218.     end  = get_packetheader(nut, bc, 1, MAIN_STARTCODE);

  219.     end += avio_tell(bc);

  220. 

  221.     GET_V(tmp, tmp >= 2 && tmp <= 3)

  222.     GET_V(stream_count, tmp > 0 && tmp <= NUT_MAX_STREAMS)

  223. 

  224.     nut->max_distance = ffio_read_varlen(bc);

  225.     if (nut->max_distance > 65536) {

  226.         av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance);

  227.         nut->max_distance = 65536;

  228.     }

  229. 

  230.     GET_V(nut->time_base_count, tmp > 0 && tmp < INT_MAX / sizeof(AVRational))

  231.     nut->time_base = av_malloc(nut->time_base_count * sizeof(AVRational));

  232. 

  233.     for (i = 0; i < nut->time_base_count; i++) {

  234.         GET_V(nut->time_base[i].num, tmp > 0 && tmp < (1ULL << 31))

  235.         GET_V(nut->time_base[i].den, tmp > 0 && tmp < (1ULL << 31))

  236.         if (av_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1) {

  237.             av_log(s, AV_LOG_ERROR, "time base invalid\n");

  238.             return AVERROR_INVALIDDATA;

  239.         }

  240.     }

  241.     tmp_pts      = 0;

  242.     tmp_mul      = 1;

  243.     tmp_stream   = 0;

  244.     tmp_head_idx = 0;

  245.     for (i = 0; i < 256;) {

  246.         int tmp_flags  = ffio_read_varlen(bc);

  247.         int tmp_fields = ffio_read_varlen(bc);

  248. 

  249.         if (tmp_fields > 0)

  250.             tmp_pts = get_s(bc);

  251.         if (tmp_fields > 1)

  252.             tmp_mul = ffio_read_varlen(bc);

  253.         if (tmp_fields > 2)

  254.             tmp_stream = ffio_read_varlen(bc);

  255.         if (tmp_fields > 3)

  256.             tmp_size = ffio_read_varlen(bc);

  257.         else

  258.             tmp_size = 0;

  259.         if (tmp_fields > 4)

  260.             tmp_res = ffio_read_varlen(bc);

  261.         else

  262.             tmp_res = 0;

  263.         if (tmp_fields > 5)

  264.             count = ffio_read_varlen(bc);

  265.         else

  266.             count = tmp_mul - tmp_size;

  267.         if (tmp_fields > 6)

  268.             get_s(bc);

  269.         if (tmp_fields > 7)

  270.             tmp_head_idx = ffio_read_varlen(bc);

  271. 

  272.         while (tmp_fields-- > 8)

  273.             ffio_read_varlen(bc);

  274. 

  275.         if (count == 0 || i + count > 256) {

  276.             av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);

  277.             return AVERROR_INVALIDDATA;

  278.         }

  279.         if (tmp_stream >= stream_count) {

  280.             av_log(s, AV_LOG_ERROR, "illegal stream number\n");

  281.             return AVERROR_INVALIDDATA;

  282.         }

  283. 

  284.         for (j = 0; j < count; j++, i++) {

  285.             if (i == 'N') {

  286.                 nut->frame_code[i].flags = FLAG_INVALID;

  287.                 j--;

  288.                 continue;

  289.             }

  290.             nut->frame_code[i].flags          = tmp_flags;

  291.             nut->frame_code[i].pts_delta      = tmp_pts;

  292.             nut->frame_code[i].stream_id      = tmp_stream;

  293.             nut->frame_code[i].size_mul       = tmp_mul;

  294.             nut->frame_code[i].size_lsb       = tmp_size + j;

  295.             nut->frame_code[i].reserved_count = tmp_res;

  296.             nut->frame_code[i].header_idx     = tmp_head_idx;

  297.         }

  298.     }

  299.     av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);

  300. 

  301.     if (end > avio_tell(bc) + 4) {

  302.         int rem = 1024;

  303.         GET_V(nut->header_count, tmp < 128U)

  304.         nut->header_count++;

  305.         for (i = 1; i < nut->header_count; i++) {

  306.             uint8_t *hdr;

  307.             GET_V(nut->header_len[i], tmp > 0 && tmp < 256);

  308.             rem -= nut->header_len[i];

  309.             if (rem < 0) {

  310.                 av_log(s, AV_LOG_ERROR, "invalid elision header\n");

  311.                 return AVERROR_INVALIDDATA;

  312.             }

  313.             hdr = av_malloc(nut->header_len[i]);

  314.             if (!hdr)

  315.                 return AVERROR(ENOMEM);

  316.             avio_read(bc, hdr, nut->header_len[i]);

  317.             nut->header[i] = hdr;

  318.         }

  319.         av_assert0(nut->header_len[0] == 0);

  320.     }

  321. 

  322.     if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

  323.         av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n");

  324.         return AVERROR_INVALIDDATA;

  325.     }

  326. 

  327.     nut->stream = av_mallocz(sizeof(StreamContext) * stream_count);

  328.     for (i = 0; i < stream_count; i++)

  329.         avformat_new_stream(s, NULL);

  330. 

  331.     return 0;

  332. }

  333. 

  334. static int decode_stream_header(NUTContext *nut)

  335. {

  336.     AVFormatContext *s = nut->avf;

  337.     AVIOContext *bc    = s->pb;

  338.     StreamContext *stc;

  339.     int class, stream_id;

  340.     uint64_t tmp, end;

  341.     AVStream *st;

  342. 

  343.     end  = get_packetheader(nut, bc, 1, STREAM_STARTCODE);

  344.     end += avio_tell(bc);

  345. 

  346.     GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base);

  347.     stc = &nut->stream[stream_id];

  348.     st  = s->streams[stream_id];

  349.     if (!st)

  350.         return AVERROR(ENOMEM);

  351. 

  352.     class                = ffio_read_varlen(bc);

  353.     tmp                  = get_fourcc(bc);

  354.     st->codec->codec_tag = tmp;

  355.     switch (class) {

  356.     case 0:

  357.         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

  358.         st->codec->codec_id   = av_codec_get_id((const AVCodecTag * const []) {

  359.                                                     ff_codec_bmp_tags,

  360.                                                     ff_nut_video_tags,

  361.                                                     0

  362.                                                 },

  363.                                                 tmp);

  364.         break;

  365.     case 1:

  366.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

  367.         st->codec->codec_id   = ff_codec_get_id(ff_codec_wav_tags, tmp);

  368.         break;

  369.     case 2:

  370.         st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

  371.         st->codec->codec_id   = ff_codec_get_id(ff_nut_subtitle_tags, tmp);

  372.         break;

  373.     case 3:

  374.         st->codec->codec_type = AVMEDIA_TYPE_DATA;

  375.         break;

  376.     default:

  377.         av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);

  378.         return -1;

  379.     }

  380.     if (class < 3 && st->codec->codec_id == CODEC_ID_NONE)

  381.         av_log(s, AV_LOG_ERROR,

  382.                "Unknown codec tag '0x%04x' for stream number %d\n",

  383.                (unsigned int) tmp, stream_id);

  384. 

  385.     GET_V(stc->time_base_id, tmp < nut->time_base_count);

  386.     GET_V(stc->msb_pts_shift, tmp < 16);

  387.     stc->max_pts_distance = ffio_read_varlen(bc);

  388.     GET_V(stc->decode_delay, tmp < 1000); // sanity limit, raise this if Moore's law is true

  389.     st->codec->has_b_frames = stc->decode_delay;

  390.     ffio_read_varlen(bc); // stream flags

  391. 

  392.     GET_V(st->codec->extradata_size, tmp < (1 << 30));

  393.     if (st->codec->extradata_size) {

  394.         st->codec->extradata = av_mallocz(st->codec->extradata_size +

  395.                                           FF_INPUT_BUFFER_PADDING_SIZE);

  396.         avio_read(bc, st->codec->extradata, st->codec->extradata_size);

  397.     }

  398. 

  399.     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

  400.         GET_V(st->codec->width,  tmp > 0)

  401.         GET_V(st->codec->height, tmp > 0)

  402.         st->sample_aspect_ratio.num = ffio_read_varlen(bc);

  403.         st->sample_aspect_ratio.den = ffio_read_varlen(bc);

  404.         if ((!st->sample_aspect_ratio.num) != (!st->sample_aspect_ratio.den)) {

  405.             av_log(s, AV_LOG_ERROR, "invalid aspect ratio %d/%d\n",

  406.                    st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);

  407.             return -1;

  408.         }

  409.         ffio_read_varlen(bc); /* csp type */

  410.     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

  411.         GET_V(st->codec->sample_rate, tmp > 0)

  412.         ffio_read_varlen(bc); // samplerate_den

  413.         GET_V(st->codec->channels, tmp > 0)

  414.     }

  415.     if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

  416.         av_log(s, AV_LOG_ERROR,

  417.                "stream header %d checksum mismatch\n", stream_id);

  418.         return -1;

  419.     }

  420.     stc->time_base = &nut->time_base[stc->time_base_id];

  421.     avpriv_set_pts_info(s->streams[stream_id], 63, stc->time_base->num,

  422.                         stc->time_base->den);

  423.     return 0;

  424. }

  425. 

  426. static void set_disposition_bits(AVFormatContext *avf, char *value,

  427.                                  int stream_id)

  428. {

  429.     int flag = 0, i;

  430. 

  431.     for (i = 0; ff_nut_dispositions[i].flag; ++i)

  432.         if (!strcmp(ff_nut_dispositions[i].str, value))

  433.             flag = ff_nut_dispositions[i].flag;

  434.     if (!flag)

  435.         av_log(avf, AV_LOG_INFO, "unknown disposition type '%s'\n", value);

  436.     for (i = 0; i < avf->nb_streams; ++i)

  437.         if (stream_id == i || stream_id == -1)

  438.             avf->streams[i]->disposition |= flag;

  439. }

  440. 

  441. static int decode_info_header(NUTContext *nut)

  442. {

  443.     AVFormatContext *s = nut->avf;

  444.     AVIOContext *bc    = s->pb;

  445.     uint64_t tmp, chapter_start, chapter_len;

  446.     unsigned int stream_id_plus1, count;

  447.     int chapter_id, i;

  448.     int64_t value, end;

  449.     char name[256], str_value[1024], type_str[256];

  450.     const char *type;

  451.     AVChapter *chapter      = NULL;

  452.     AVStream *st            = NULL;

  453.     AVDictionary **metadata = NULL;

  454. 

  455.     end  = get_packetheader(nut, bc, 1, INFO_STARTCODE);

  456.     end += avio_tell(bc);

  457. 

  458.     GET_V(stream_id_plus1, tmp <= s->nb_streams)

  459.     chapter_id    = get_s(bc);

  460.     chapter_start = ffio_read_varlen(bc);

  461.     chapter_len   = ffio_read_varlen(bc);

  462.     count         = ffio_read_varlen(bc);

  463. 

  464.     if (chapter_id && !stream_id_plus1) {

  465.         int64_t start = chapter_start / nut->time_base_count;

  466.         chapter = avpriv_new_chapter(s, chapter_id,

  467.                                      nut->time_base[chapter_start %

  468.                                                     nut->time_base_count],

  469.                                      start, start + chapter_len, NULL);

  470.         metadata = &chapter->metadata;

  471.     } else if (stream_id_plus1) {

  472.         st       = s->streams[stream_id_plus1 - 1];

  473.         metadata = &st->metadata;

  474.     } else

  475.         metadata = &s->metadata;

  476. 

  477.     for (i = 0; i < count; i++) {

  478.         get_str(bc, name, sizeof(name));

  479.         value = get_s(bc);

  480.         if (value == -1) {

  481.             type = "UTF-8";

  482.             get_str(bc, str_value, sizeof(str_value));

  483.         } else if (value == -2) {

  484.             get_str(bc, type_str, sizeof(type_str));

  485.             type = type_str;

  486.             get_str(bc, str_value, sizeof(str_value));

  487.         } else if (value == -3) {

  488.             type  = "s";

  489.             value = get_s(bc);

  490.         } else if (value == -4) {

  491.             type  = "t";

  492.             value = ffio_read_varlen(bc);

  493.         } else if (value < -4) {

  494.             type = "r";

  495.             get_s(bc);

  496.         } else {

  497.             type = "v";

  498.         }

  499. 

  500.         if (stream_id_plus1 > s->nb_streams) {

  501.             av_log(s, AV_LOG_ERROR, "invalid stream id for info packet\n");

  502.             continue;

  503.         }

  504. 

  505.         if (!strcmp(type, "UTF-8")) {

  506.             if (chapter_id == 0 && !strcmp(name, "Disposition")) {

  507.                 set_disposition_bits(s, str_value, stream_id_plus1 - 1);

  508.                 continue;

  509.             }

  510.             if (metadata && av_strcasecmp(name, "Uses") &&

  511.                 av_strcasecmp(name, "Depends") && av_strcasecmp(name, "Replaces"))

  512.                 av_dict_set(metadata, name, str_value, 0);

  513.         }

  514.     }

  515. 

  516.     if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

  517.         av_log(s, AV_LOG_ERROR, "info header checksum mismatch\n");

  518.         return -1;

  519.     }

  520.     return 0;

  521. }

  522. 

  523. static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)

  524. {

  525.     AVFormatContext *s = nut->avf;

  526.     AVIOContext *bc    = s->pb;

  527.     int64_t end, tmp;

  528. 

  529.     nut->last_syncpoint_pos = avio_tell(bc) - 8;

  530. 

  531.     end  = get_packetheader(nut, bc, 1, SYNCPOINT_STARTCODE);

  532.     end += avio_tell(bc);

  533. 

  534.     tmp       = ffio_read_varlen(bc);

  535.     *back_ptr = nut->last_syncpoint_pos - 16 * ffio_read_varlen(bc);

  536.     if (*back_ptr < 0)

  537.         return -1;

  538. 

  539.     ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count],

  540.                     tmp / nut->time_base_count);

  541. 

  542.     if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

  543.         av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n");

  544.         return -1;

  545.     }

  546. 

  547.     *ts = tmp / s->nb_streams *

  548.           av_q2d(nut->time_base[tmp % s->nb_streams]) * AV_TIME_BASE;

  549.     ff_nut_add_sp(nut, nut->last_syncpoint_pos, *back_ptr, *ts);

  550. 

  551.     return 0;

  552. }

  553. 

  554. static int find_and_decode_index(NUTContext *nut)

  555. {

  556.     AVFormatContext *s = nut->avf;

  557.     AVIOContext *bc    = s->pb;

  558.     uint64_t tmp, end;

  559.     int i, j, syncpoint_count;

  560.     int64_t filesize = avio_size(bc);

  561.     int64_t *syncpoints;

  562.     int8_t *has_keyframe;

  563.     int ret = -1;

  564. 

  565.     if(filesize <= 0)

  566.         return -1;

  567. 

  568.     avio_seek(bc, filesize - 12, SEEK_SET);

  569.     avio_seek(bc, filesize - avio_rb64(bc), SEEK_SET);

  570.     if (avio_rb64(bc) != INDEX_STARTCODE) {

  571.         av_log(s, AV_LOG_ERROR, "no index at the end\n");

  572.         return -1;

  573.     }

  574. 

  575.     end  = get_packetheader(nut, bc, 1, INDEX_STARTCODE);

  576.     end += avio_tell(bc);

  577. 

  578.     ffio_read_varlen(bc); // max_pts

  579.     GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0)

  580.     syncpoints   = av_malloc(sizeof(int64_t) *  syncpoint_count);

  581.     has_keyframe = av_malloc(sizeof(int8_t)  * (syncpoint_count + 1));

  582.     for (i = 0; i < syncpoint_count; i++) {

  583.         syncpoints[i] = ffio_read_varlen(bc);

  584.         if (syncpoints[i] <= 0)

  585.             goto fail;

  586.         if (i)

  587.             syncpoints[i] += syncpoints[i - 1];

  588.     }

  589. 

  590.     for (i = 0; i < s->nb_streams; i++) {

  591.         int64_t last_pts = -1;

  592.         for (j = 0; j < syncpoint_count;) {

  593.             uint64_t x = ffio_read_varlen(bc);

  594.             int type   = x & 1;

  595.             int n      = j;

  596.             x >>= 1;

  597.             if (type) {

  598.                 int flag = x & 1;

  599.                 x >>= 1;

  600.                 if (n + x >= syncpoint_count + 1) {

  601.                     av_log(s, AV_LOG_ERROR, "index overflow A\n");

  602.                     goto fail;

  603.                 }

  604.                 while (x--)

  605.                     has_keyframe[n++] = flag;

  606.                 has_keyframe[n++] = !flag;

  607.             } else {

  608.                 while (x != 1) {

  609.                     if (n >= syncpoint_count + 1) {

  610.                         av_log(s, AV_LOG_ERROR, "index overflow B\n");

  611.                         goto fail;

  612.                     }

  613.                     has_keyframe[n++] = x & 1;

  614.                     x >>= 1;

  615.                 }

  616.             }

  617.             if (has_keyframe[0]) {

  618.                 av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");

  619.                 goto fail;

  620.             }

  621.             av_assert0(n <= syncpoint_count + 1);

  622.             for (; j < n && j < syncpoint_count; j++) {

  623.                 if (has_keyframe[j]) {

  624.                     uint64_t B, A = ffio_read_varlen(bc);

  625.                     if (!A) {

  626.                         A = ffio_read_varlen(bc);

  627.                         B = ffio_read_varlen(bc);

  628.                         // eor_pts[j][i] = last_pts + A + B

  629.                     } else

  630.                         B = 0;

  631.                     av_add_index_entry(s->streams[i], 16 * syncpoints[j - 1],

  632.                                        last_pts + A, 0, 0, AVINDEX_KEYFRAME);

  633.                     last_pts += A + B;

  634.                 }

  635.             }

  636.         }

  637.     }

  638. 

  639.     if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

  640.         av_log(s, AV_LOG_ERROR, "index checksum mismatch\n");

  641.         goto fail;

  642.     }

  643.     ret = 0;

  644. 

  645. fail:

  646.     av_free(syncpoints);

  647.     av_free(has_keyframe);

  648.     return ret;

  649. }

  650. 

  651. static int nut_read_header(AVFormatContext *s)

  652. {

  653.     NUTContext *nut = s->priv_data;

  654.     AVIOContext *bc = s->pb;

  655.     int64_t pos;

  656.     int initialized_stream_count;

  657. 

  658.     nut->avf = s;

  659. 

  660.     /* main header */

  661.     pos = 0;

  662.     do {

  663.         pos = find_startcode(bc, MAIN_STARTCODE, pos) + 1;

  664.         if (pos < 0 + 1) {

  665.             av_log(s, AV_LOG_ERROR, "No main startcode found.\n");

  666.             return AVERROR_INVALIDDATA;

  667.         }

  668.     } while (decode_main_header(nut) < 0);

  669. 

  670.     /* stream headers */

  671.     pos = 0;

  672.     for (initialized_stream_count = 0; initialized_stream_count < s->nb_streams;) {

  673.         pos = find_startcode(bc, STREAM_STARTCODE, pos) + 1;

  674.         if (pos < 0 + 1) {

  675.             av_log(s, AV_LOG_ERROR, "Not all stream headers found.\n");

  676.             return AVERROR_INVALIDDATA;

  677.         }

  678.         if (decode_stream_header(nut) >= 0)

  679.             initialized_stream_count++;

  680.     }

  681. 

  682.     /* info headers */

  683.     pos = 0;

  684.     for (;;) {

  685.         uint64_t startcode = find_any_startcode(bc, pos);

  686.         pos = avio_tell(bc);

  687. 

  688.         if (startcode == 0) {

  689.             av_log(s, AV_LOG_ERROR, "EOF before video frames\n");

  690.             return AVERROR_INVALIDDATA;

  691.         } else if (startcode == SYNCPOINT_STARTCODE) {

  692.             nut->next_startcode = startcode;

  693.             break;

  694.         } else if (startcode != INFO_STARTCODE) {

  695.             continue;

  696.         }

  697. 

  698.         decode_info_header(nut);

  699.     }

  700. 

  701.     s->data_offset = pos - 8;

  702. 

  703.     if (bc->seekable) {

  704.         int64_t orig_pos = avio_tell(bc);

  705.         find_and_decode_index(nut);

  706.         avio_seek(bc, orig_pos, SEEK_SET);

  707.     }

  708.     av_assert0(nut->next_startcode == SYNCPOINT_STARTCODE);

  709. 

  710.     ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);

  711. 

  712.     return 0;

  713. }

  714. 

  715. static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id,

  716.                                uint8_t *header_idx, int frame_code)

  717. {

  718.     AVFormatContext *s = nut->avf;

  719.     AVIOContext *bc    = s->pb;

  720.     StreamContext *stc;

  721.     int size, flags, size_mul, pts_delta, i, reserved_count;

  722.     uint64_t tmp;

  723. 

  724.     if (avio_tell(bc) > nut->last_syncpoint_pos + nut->max_distance) {

  725.         av_log(s, AV_LOG_ERROR,

  726.                "Last frame must have been damaged %"PRId64" > %"PRId64" + %d\n",

  727.                avio_tell(bc), nut->last_syncpoint_pos, nut->max_distance);

  728.         return AVERROR_INVALIDDATA;

  729.     }

  730. 

  731.     flags          = nut->frame_code[frame_code].flags;

  732.     size_mul       = nut->frame_code[frame_code].size_mul;

  733.     size           = nut->frame_code[frame_code].size_lsb;

  734.     *stream_id     = nut->frame_code[frame_code].stream_id;

  735.     pts_delta      = nut->frame_code[frame_code].pts_delta;

  736.     reserved_count = nut->frame_code[frame_code].reserved_count;

  737.     *header_idx    = nut->frame_code[frame_code].header_idx;

  738. 

  739.     if (flags & FLAG_INVALID)

  740.         return AVERROR_INVALIDDATA;

  741.     if (flags & FLAG_CODED)

  742.         flags ^= ffio_read_varlen(bc);

  743.     if (flags & FLAG_STREAM_ID) {

  744.         GET_V(*stream_id, tmp < s->nb_streams)

  745.     }

  746.     stc = &nut->stream[*stream_id];

  747.     if (flags & FLAG_CODED_PTS) {

  748.         int coded_pts = ffio_read_varlen(bc);

  749.         // FIXME check last_pts validity?

  750.         if (coded_pts < (1 << stc->msb_pts_shift)) {

  751.             *pts = ff_lsb2full(stc, coded_pts);

  752.         } else

  753.             *pts = coded_pts - (1 << stc->msb_pts_shift);

  754.     } else

  755.         *pts = stc->last_pts + pts_delta;

  756.     if (flags & FLAG_SIZE_MSB)

  757.         size += size_mul * ffio_read_varlen(bc);

  758.     if (flags & FLAG_MATCH_TIME)

  759.         get_s(bc);

  760.     if (flags & FLAG_HEADER_IDX)

  761.         *header_idx = ffio_read_varlen(bc);

  762.     if (flags & FLAG_RESERVED)

  763.         reserved_count = ffio_read_varlen(bc);

  764.     for (i = 0; i < reserved_count; i++)

  765.         ffio_read_varlen(bc);

  766. 

  767.     if (*header_idx >= (unsigned)nut->header_count) {

  768.         av_log(s, AV_LOG_ERROR, "header_idx invalid\n");

  769.         return AVERROR_INVALIDDATA;

  770.     }

  771.     if (size > 4096)

  772.         *header_idx = 0;

  773.     size -= nut->header_len[*header_idx];

  774. 

  775.     if (flags & FLAG_CHECKSUM) {

  776.         avio_rb32(bc); // FIXME check this

  777.     } else if (size > 2 * nut->max_distance || FFABS(stc->last_pts - *pts) >

  778.                stc->max_pts_distance) {

  779.         av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");

  780.         return AVERROR_INVALIDDATA;

  781.     }

  782. 

  783.     stc->last_pts   = *pts;

  784.     stc->last_flags = flags;

  785. 

  786.     return size;

  787. }

  788. 

  789. static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)

  790. {

  791.     AVFormatContext *s = nut->avf;

  792.     AVIOContext *bc    = s->pb;

  793.     int size, stream_id, discard;

  794.     int64_t pts, last_IP_pts;

  795.     StreamContext *stc;

  796.     uint8_t header_idx;

  797. 

  798.     size = decode_frame_header(nut, &pts, &stream_id, &header_idx, frame_code);

  799.     if (size < 0)

  800.         return size;

  801. 

  802.     stc = &nut->stream[stream_id];

  803. 

  804.     if (stc->last_flags & FLAG_KEY)

  805.         stc->skip_until_key_frame = 0;

  806. 

  807.     discard     = s->streams[stream_id]->discard;

  808.     last_IP_pts = s->streams[stream_id]->last_IP_pts;

  809.     if ((discard >= AVDISCARD_NONKEY && !(stc->last_flags & FLAG_KEY)) ||

  810.         (discard >= AVDISCARD_BIDIR  && last_IP_pts != AV_NOPTS_VALUE &&

  811.          last_IP_pts > pts) ||

  812.         discard >= AVDISCARD_ALL ||

  813.         stc->skip_until_key_frame) {

  814.         avio_skip(bc, size);

  815.         return 1;

  816.     }

  817. 

  818.     av_new_packet(pkt, size + nut->header_len[header_idx]);

  819.     memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);

  820.     pkt->pos = avio_tell(bc); // FIXME

  821.     avio_read(bc, pkt->data + nut->header_len[header_idx], size);

  822. 

  823.     pkt->stream_index = stream_id;

  824.     if (stc->last_flags & FLAG_KEY)

  825.         pkt->flags |= AV_PKT_FLAG_KEY;

  826.     pkt->pts = pts;

  827. 

  828.     return 0;

  829. }

  830. 

  831. static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)

  832. {

  833.     NUTContext *nut = s->priv_data;

  834.     AVIOContext *bc = s->pb;

  835.     int i, frame_code = 0, ret, skip;

  836.     int64_t ts, back_ptr;

  837. 

  838.     for (;;) {

  839.         int64_t pos  = avio_tell(bc);

  840.         uint64_t tmp = nut->next_startcode;

  841.         nut->next_startcode = 0;

  842. 

  843.         if (tmp) {

  844.             pos -= 8;

  845.         } else {

  846.             frame_code = avio_r8(bc);

  847.             if (url_feof(bc))

  848.                 return -1;

  849.             if (frame_code == 'N') {

  850.                 tmp = frame_code;

  851.                 for (i = 1; i < 8; i++)

  852.                     tmp = (tmp << 8) + avio_r8(bc);

  853.             }

  854.         }

  855.         switch (tmp) {

  856.         case MAIN_STARTCODE:

  857.         case STREAM_STARTCODE:

  858.         case INDEX_STARTCODE:

  859.             skip = get_packetheader(nut, bc, 0, tmp);

  860.             avio_skip(bc, skip);

  861.             break;

  862.         case INFO_STARTCODE:

  863.             if (decode_info_header(nut) < 0)

  864.                 goto resync;

  865.             break;

  866.         case SYNCPOINT_STARTCODE:

  867.             if (decode_syncpoint(nut, &ts, &back_ptr) < 0)

  868.                 goto resync;

  869.             frame_code = avio_r8(bc);

  870.         case 0:

  871.             ret = decode_frame(nut, pkt, frame_code);

  872.             if (ret == 0)

  873.                 return 0;

  874.             else if (ret == 1) // OK but discard packet

  875.                 break;

  876.         default:

  877. resync:

  878.             av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);

  879.             tmp = find_any_startcode(bc, nut->last_syncpoint_pos + 1);

  880.             if (tmp == 0)

  881.                 return AVERROR_INVALIDDATA;

  882.             av_log(s, AV_LOG_DEBUG, "sync\n");

  883.             nut->next_startcode = tmp;

  884.         }

  885.     }

  886. }

  887. 

  888. static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,

  889.                                   int64_t *pos_arg, int64_t pos_limit)

  890. {

  891.     NUTContext *nut = s->priv_data;

  892.     AVIOContext *bc = s->pb;

  893.     int64_t pos, pts, back_ptr;

  894.     av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n",

  895.            stream_index, *pos_arg, pos_limit);

  896. 

  897.     pos = *pos_arg;

  898.     do {

  899.         pos = find_startcode(bc, SYNCPOINT_STARTCODE, pos) + 1;

  900.         if (pos < 1) {

  901.             av_log(s, AV_LOG_ERROR, "read_timestamp failed.\n");

  902.             return AV_NOPTS_VALUE;

  903.         }

  904.     } while (decode_syncpoint(nut, &pts, &back_ptr) < 0);

  905.     *pos_arg = pos - 1;

  906.     av_assert0(nut->last_syncpoint_pos == *pos_arg);

  907. 

  908.     av_log(s, AV_LOG_DEBUG, "return %"PRId64" %"PRId64"\n", pts, back_ptr);

  909.     if (stream_index == -2)

  910.         return back_ptr;

  911.     av_assert0(stream_index == -1);

  912.     return pts;

  913. }

  914. 

  915. static int read_seek(AVFormatContext *s, int stream_index,

  916.                      int64_t pts, int flags)

  917. {

  918.     NUTContext *nut    = s->priv_data;

  919.     AVStream *st       = s->streams[stream_index];

  920.     Syncpoint dummy    = { .ts = pts * av_q2d(st->time_base) * AV_TIME_BASE };

  921.     Syncpoint nopts_sp = { .ts = AV_NOPTS_VALUE, .back_ptr = AV_NOPTS_VALUE };

  922.     Syncpoint *sp, *next_node[2] = { &nopts_sp, &nopts_sp };

  923.     int64_t pos, pos2, ts;

  924.     int i;

  925. 

  926.     if (st->index_entries) {

  927.         int index = av_index_search_timestamp(st, pts, flags);

  928.         if (index < 0)

  929.             return -1;

  930. 

  931.         pos2 = st->index_entries[index].pos;

  932.         ts   = st->index_entries[index].timestamp;

  933.     } else {

  934.         av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pts_cmp,

  935.                      (void **) next_node);

  936.         av_log(s, AV_LOG_DEBUG, "%"PRIu64"-%"PRIu64" %"PRId64"-%"PRId64"\n",

  937.                next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,

  938.                next_node[1]->ts);

  939.         pos = ff_gen_search(s, -1, dummy.ts, next_node[0]->pos,

  940.                             next_node[1]->pos, next_node[1]->pos,

  941.                             next_node[0]->ts, next_node[1]->ts,

  942.                             AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);

  943. 

  944.         if (!(flags & AVSEEK_FLAG_BACKWARD)) {

  945.             dummy.pos    = pos + 16;

  946.             next_node[1] = &nopts_sp;

  947.             av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,

  948.                          (void **) next_node);

  949.             pos2 = ff_gen_search(s, -2, dummy.pos, next_node[0]->pos,

  950.                                  next_node[1]->pos, next_node[1]->pos,

  951.                                  next_node[0]->back_ptr, next_node[1]->back_ptr,

  952.                                  flags, &ts, nut_read_timestamp);

  953.             if (pos2 >= 0)

  954.                 pos = pos2;

  955.             // FIXME dir but I think it does not matter

  956.         }

  957.         dummy.pos = pos;

  958.         sp = av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,

  959.                           NULL);

  960. 

  961.         av_assert0(sp);

  962.         pos2 = sp->back_ptr - 15;

  963.     }

  964.     av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos2);

  965.     pos = find_startcode(s->pb, SYNCPOINT_STARTCODE, pos2);

  966.     avio_seek(s->pb, pos, SEEK_SET);

  967.     av_log(NULL, AV_LOG_DEBUG, "SP: %"PRId64"\n", pos);

  968.     if (pos2 > pos || pos2 + 15 < pos)

  969.         av_log(NULL, AV_LOG_ERROR, "no syncpoint at backptr pos\n");

  970.     for (i = 0; i < s->nb_streams; i++)

  971.         nut->stream[i].skip_until_key_frame = 1;

  972. 

  973.     return 0;

  974. }

  975. 

  976. static int nut_read_close(AVFormatContext *s)

  977. {

  978.     NUTContext *nut = s->priv_data;

  979.     int i;

  980. 

  981.     av_freep(&nut->time_base);

  982.     av_freep(&nut->stream);

  983.     ff_nut_free_sp(nut);

  984.     for (i = 1; i < nut->header_count; i++)

  985.         av_freep(&nut->header[i]);

  986. 

  987.     return 0;

  988. }

  989. 

  990. AVInputFormat ff_nut_demuxer = {

  991.     .name           = "nut",

  992.     .long_name      = NULL_IF_CONFIG_SMALL("NUT format"),

  993.     .flags          = AVFMT_SEEK_TO_PTS,

  994.     .priv_data_size = sizeof(NUTContext),

  995.     .read_probe     = nut_probe,

  996.     .read_header    = nut_read_header,

  997.     .read_packet    = nut_read_packet,

  998.     .read_close     = nut_read_close,

  999.     .read_seek      = read_seek,

  1000.     .extensions     = "nut",

  1001.     .codec_tag      = (const AVCodecTag * const []) {

  1002.         ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags,

  1003.         ff_nut_subtitle_tags, 0

  1004.     },

  1005. };