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.
44961 Commits
32 Branches
552MB
Tree: f7f5370b4b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f7f5370b4b'
${ noResults }
FFmpeg/libavformat/nutdec.c

1040 lines
33KB
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 int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,

  35.                                   int64_t *pos_arg, int64_t pos_limit);

  36. 

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

  38. {

  39.     unsigned int len = ffio_read_varlen(bc);

  40. 

  41.     if (len && maxlen)

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

  43.     while (len > maxlen) {

  44.         avio_r8(bc);

  45.         len--;

  46.     }

  47. 

  48.     if (maxlen)

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

  50. 

  51.     if (maxlen == len)

  52.         return -1;

  53.     else

  54.         return 0;

  55. }

  56. 

  57. static int64_t get_s(AVIOContext *bc)

  58. {

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

  60. 

  61.     if (v & 1)

  62.         return -(v >> 1);

  63.     else

  64.         return  (v >> 1);

  65. }

  66. 

  67. static uint64_t get_fourcc(AVIOContext *bc)

  68. {

  69.     unsigned int len = ffio_read_varlen(bc);

  70. 

  71.     if (len == 2)

  72.         return avio_rl16(bc);

  73.     else if (len == 4)

  74.         return avio_rl32(bc);

  75.     else

  76.         return -1;

  77. }

  78. 

  79. #ifdef TRACE

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

  81.                                    const char *func, int line)

  82. {

  83.     uint64_t v = ffio_read_varlen(bc);

  84. 

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

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

  87.     return v;

  88. }

  89. 

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

  91.                                   const char *func, int line)

  92. {

  93.     int64_t v = get_s(bc);

  94. 

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

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

  97.     return v;

  98. }

  99. 

  100. static inline uint64_t get_4cc_trace(AVIOContext *bc, char *file,

  101.                                     char *func, int line)

  102. {

  103.     uint64_t v = get_fourcc(bc);

  104. 

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

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

  107.     return v;

  108. }

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

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

  111. #define get_fourcc(bc)       get_4cc_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  112. #endif

  113. 

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

  115.                             int calculate_checksum, uint64_t startcode)

  116. {

  117.     int64_t size;

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

  119. 

  120.     startcode = av_be2ne64(startcode);

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

  122. 

  123.     ffio_init_checksum(bc, ff_crc04C11DB7_update, startcode);

  124.     size = ffio_read_varlen(bc);

  125.     if (size > 4096)

  126.         avio_rb32(bc);

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

  128.         return -1;

  129. 

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

  131. 

  132.     return size;

  133. }

  134. 

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

  136. {

  137.     uint64_t state = 0;

  138. 

  139.     if (pos >= 0)

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

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

  142.         avio_seek(bc, pos, SEEK_SET);

  143.     while (!url_feof(bc)) {

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

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

  146.             continue;

  147.         switch (state) {

  148.         case MAIN_STARTCODE:

  149.         case STREAM_STARTCODE:

  150.         case SYNCPOINT_STARTCODE:

  151.         case INFO_STARTCODE:

  152.         case INDEX_STARTCODE:

  153.             return state;

  154.         }

  155.     }

  156. 

  157.     return 0;

  158. }

  159. 

  160. /**

  161.  * Find the given startcode.

  162.  * @param code the startcode

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

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

  165.  */

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

  167. {

  168.     for (;;) {

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

  170.         if (startcode == code)

  171.             return avio_tell(bc) - 8;

  172.         else if (startcode == 0)

  173.             return -1;

  174.         pos = -1;

  175.     }

  176. }

  177. 

  178. static int nut_probe(AVProbeData *p)

  179. {

  180.     int i;

  181.     uint64_t code = 0;

  182. 

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

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

  185.         if (code == MAIN_STARTCODE)

  186.             return AVPROBE_SCORE_MAX;

  187.     }

  188.     return 0;

  189. }

  190. 

  191. #define GET_V(dst, check)                                                 \

  192.     tmp = ffio_read_varlen(bc);                                           \

  193.     if (!(check)) {                                                       \

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

  195.         return -1;                                                        \

  196.     }                                                                     \

  197.     dst = tmp;

  198. 

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

  200. {

  201.     pos -= avio_tell(bc);

  202.     if (pos < 0) {

  203.         avio_seek(bc, pos, SEEK_CUR);

  204.         return -1;

  205.     } else {

  206.         while (pos--)

  207.             avio_r8(bc);

  208.         return 0;

  209.     }

  210. }

  211. 

  212. static int decode_main_header(NUTContext *nut)

  213. {

  214.     AVFormatContext *s = nut->avf;

  215.     AVIOContext *bc    = s->pb;

  216.     uint64_t tmp, end;

  217.     unsigned int stream_count;

  218.     int i, j, count;

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

  220. 

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

  222.     end += avio_tell(bc);

  223. 

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

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

  226. 

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

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

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

  230.         nut->max_distance = 65536;

  231.     }

  232. 

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

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

  235. 

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

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

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

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

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

  241.             return AVERROR_INVALIDDATA;

  242.         }

  243.     }

  244.     tmp_pts      = 0;

  245.     tmp_mul      = 1;

  246.     tmp_stream   = 0;

  247.     tmp_head_idx = 0;

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

  249.         int tmp_flags  = ffio_read_varlen(bc);

  250.         int tmp_fields = ffio_read_varlen(bc);

  251. 

  252.         if (tmp_fields > 0)

  253.             tmp_pts = get_s(bc);

  254.         if (tmp_fields > 1)

  255.             tmp_mul = ffio_read_varlen(bc);

  256.         if (tmp_fields > 2)

  257.             tmp_stream = ffio_read_varlen(bc);

  258.         if (tmp_fields > 3)

  259.             tmp_size = ffio_read_varlen(bc);

  260.         else

  261.             tmp_size = 0;

  262.         if (tmp_fields > 4)

  263.             tmp_res = ffio_read_varlen(bc);

  264.         else

  265.             tmp_res = 0;

  266.         if (tmp_fields > 5)

  267.             count = ffio_read_varlen(bc);

  268.         else

  269.             count = tmp_mul - tmp_size;

  270.         if (tmp_fields > 6)

  271.             get_s(bc);

  272.         if (tmp_fields > 7)

  273.             tmp_head_idx = ffio_read_varlen(bc);

  274. 

  275.         while (tmp_fields-- > 8)

  276.             ffio_read_varlen(bc);

  277. 

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

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

  280.             return AVERROR_INVALIDDATA;

  281.         }

  282.         if (tmp_stream >= stream_count) {

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

  284.             return AVERROR_INVALIDDATA;

  285.         }

  286. 

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

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

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

  290.                 j--;

  291.                 continue;

  292.             }

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

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

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

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

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

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

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

  300.         }

  301.     }

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

  303. 

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

  305.         int rem = 1024;

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

  307.         nut->header_count++;

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

  309.             uint8_t *hdr;

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

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

  312.             if (rem < 0) {

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

  314.                 return AVERROR_INVALIDDATA;

  315.             }

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

  317.             if (!hdr)

  318.                 return AVERROR(ENOMEM);

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

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

  321.         }

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

  323.     }

  324. 

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

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

  327.         return AVERROR_INVALIDDATA;

  328.     }

  329. 

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

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

  332.         avformat_new_stream(s, NULL);

  333. 

  334.     return 0;

  335. }

  336. 

  337. static int decode_stream_header(NUTContext *nut)

  338. {

  339.     AVFormatContext *s = nut->avf;

  340.     AVIOContext *bc    = s->pb;

  341.     StreamContext *stc;

  342.     int class, stream_id;

  343.     uint64_t tmp, end;

  344.     AVStream *st;

  345. 

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

  347.     end += avio_tell(bc);

  348. 

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

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

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

  352.     if (!st)

  353.         return AVERROR(ENOMEM);

  354. 

  355.     class                = ffio_read_varlen(bc);

  356.     tmp                  = get_fourcc(bc);

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

  358.     switch (class) {

  359.     case 0:

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

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

  362.                                                     ff_codec_bmp_tags,

  363.                                                     ff_nut_video_tags,

  364.                                                     0

  365.                                                 },

  366.                                                 tmp);

  367.         break;

  368.     case 1:

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

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

  371.         break;

  372.     case 2:

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

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

  375.         break;

  376.     case 3:

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

  378.         break;

  379.     default:

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

  381.         return -1;

  382.     }

  383.     if (class < 3 && st->codec->codec_id == AV_CODEC_ID_NONE)

  384.         av_log(s, AV_LOG_ERROR,

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

  386.                (unsigned int) tmp, stream_id);

  387. 

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

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

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

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

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

  393.     ffio_read_varlen(bc); // stream flags

  394. 

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

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

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

  398.                                           FF_INPUT_BUFFER_PADDING_SIZE);

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

  400.     }

  401. 

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

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

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

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

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

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

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

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

  410.             return -1;

  411.         }

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

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

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

  415.         ffio_read_varlen(bc); // samplerate_den

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

  417.     }

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

  419.         av_log(s, AV_LOG_ERROR,

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

  421.         return -1;

  422.     }

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

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

  425.                         stc->time_base->den);

  426.     return 0;

  427. }

  428. 

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

  430.                                  int stream_id)

  431. {

  432.     int flag = 0, i;

  433. 

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

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

  436.             flag = ff_nut_dispositions[i].flag;

  437.     if (!flag)

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

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

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

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

  442. }

  443. 

  444. static int decode_info_header(NUTContext *nut)

  445. {

  446.     AVFormatContext *s = nut->avf;

  447.     AVIOContext *bc    = s->pb;

  448.     uint64_t tmp, chapter_start, chapter_len;

  449.     unsigned int stream_id_plus1, count;

  450.     int chapter_id, i;

  451.     int64_t value, end;

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

  453.     const char *type;

  454.     AVChapter *chapter      = NULL;

  455.     AVStream *st            = NULL;

  456.     AVDictionary **metadata = NULL;

  457. 

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

  459.     end += avio_tell(bc);

  460. 

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

  462.     chapter_id    = get_s(bc);

  463.     chapter_start = ffio_read_varlen(bc);

  464.     chapter_len   = ffio_read_varlen(bc);

  465.     count         = ffio_read_varlen(bc);

  466. 

  467.     if (chapter_id && !stream_id_plus1) {

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

  469.         chapter = avpriv_new_chapter(s, chapter_id,

  470.                                      nut->time_base[chapter_start %

  471.                                                     nut->time_base_count],

  472.                                      start, start + chapter_len, NULL);

  473.         metadata = &chapter->metadata;

  474.     } else if (stream_id_plus1) {

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

  476.         metadata = &st->metadata;

  477.     } else

  478.         metadata = &s->metadata;

  479. 

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

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

  482.         value = get_s(bc);

  483.         if (value == -1) {

  484.             type = "UTF-8";

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

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

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

  488.             type = type_str;

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

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

  491.             type  = "s";

  492.             value = get_s(bc);

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

  494.             type  = "t";

  495.             value = ffio_read_varlen(bc);

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

  497.             type = "r";

  498.             get_s(bc);

  499.         } else {

  500.             type = "v";

  501.         }

  502. 

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

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

  505.             continue;

  506.         }

  507. 

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

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

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

  511.                 continue;

  512.             }

  513. 

  514.             if (stream_id_plus1 && !strcmp(name, "r_frame_rate")) {

  515.                 sscanf(str_value, "%d/%d", &st->r_frame_rate.num, &st->r_frame_rate.den);

  516.                 continue;

  517.             }

  518. 

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

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

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

  522.         }

  523.     }

  524. 

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

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

  527.         return -1;

  528.     }

  529.     return 0;

  530. }

  531. 

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

  533. {

  534.     AVFormatContext *s = nut->avf;

  535.     AVIOContext *bc    = s->pb;

  536.     int64_t end;

  537.     uint64_t tmp;

  538. 

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

  540. 

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

  542.     end += avio_tell(bc);

  543. 

  544.     tmp       = ffio_read_varlen(bc);

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

  546.     if (*back_ptr < 0)

  547.         return -1;

  548. 

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

  550.                     tmp / nut->time_base_count);

  551. 

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

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

  554.         return -1;

  555.     }

  556. 

  557.     *ts = tmp / nut->time_base_count *

  558.           av_q2d(nut->time_base[tmp % nut->time_base_count]) * AV_TIME_BASE;

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

  560. 

  561.     return 0;

  562. }

  563. 

  564. //FIXME calculate exactly, this is just a good approximation.

  565. static int64_t find_duration(NUTContext *nut, int64_t filesize)

  566. {

  567.     AVFormatContext *s = nut->avf;

  568.     int64_t duration = 0;

  569. 

  570.     int64_t pos = FFMAX(0, filesize - 2*nut->max_distance);

  571.     for(;;){

  572.         int64_t ts = nut_read_timestamp(s, -1, &pos, INT64_MAX);

  573.         if(ts < 0)

  574.             break;

  575.         duration = FFMAX(duration, ts);

  576.         pos++;

  577.     }

  578.     if(duration > 0)

  579.         s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;

  580.     return duration;

  581. }

  582. 

  583. static int find_and_decode_index(NUTContext *nut)

  584. {

  585.     AVFormatContext *s = nut->avf;

  586.     AVIOContext *bc    = s->pb;

  587.     uint64_t tmp, end;

  588.     int i, j, syncpoint_count;

  589.     int64_t filesize = avio_size(bc);

  590.     int64_t *syncpoints;

  591.     int8_t *has_keyframe;

  592.     int ret = -1;

  593. 

  594.     if(filesize <= 0)

  595.         return -1;

  596. 

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

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

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

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

  601. 

  602.         if(s->duration<=0)

  603.             s->duration = find_duration(nut, filesize);

  604.         return -1;

  605.     }

  606. 

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

  608.     end += avio_tell(bc);

  609. 

  610.     ffio_read_varlen(bc); // max_pts

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

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

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

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

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

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

  617.             goto fail;

  618.         if (i)

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

  620.     }

  621. 

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

  623.         int64_t last_pts = -1;

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

  625.             uint64_t x = ffio_read_varlen(bc);

  626.             int type   = x & 1;

  627.             int n      = j;

  628.             x >>= 1;

  629.             if (type) {

  630.                 int flag = x & 1;

  631.                 x >>= 1;

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

  633.                     av_log(s, AV_LOG_ERROR, "index overflow A %d + %"PRIu64" >= %d\n", n, x, syncpoint_count + 1);

  634.                     goto fail;

  635.                 }

  636.                 while (x--)

  637.                     has_keyframe[n++] = flag;

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

  639.             } else {

  640.                 while (x != 1) {

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

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

  643.                         goto fail;

  644.                     }

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

  646.                     x >>= 1;

  647.                 }

  648.             }

  649.             if (has_keyframe[0]) {

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

  651.                 goto fail;

  652.             }

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

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

  655.                 if (has_keyframe[j]) {

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

  657.                     if (!A) {

  658.                         A = ffio_read_varlen(bc);

  659.                         B = ffio_read_varlen(bc);

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

  661.                     } else

  662.                         B = 0;

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

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

  665.                     last_pts += A + B;

  666.                 }

  667.             }

  668.         }

  669.     }

  670. 

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

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

  673.         goto fail;

  674.     }

  675.     ret = 0;

  676. 

  677. fail:

  678.     av_free(syncpoints);

  679.     av_free(has_keyframe);

  680.     return ret;

  681. }

  682. 

  683. static int nut_read_header(AVFormatContext *s)

  684. {

  685.     NUTContext *nut = s->priv_data;

  686.     AVIOContext *bc = s->pb;

  687.     int64_t pos;

  688.     int initialized_stream_count;

  689. 

  690.     nut->avf = s;

  691. 

  692.     /* main header */

  693.     pos = 0;

  694.     do {

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

  696.         if (pos < 0 + 1) {

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

  698.             return AVERROR_INVALIDDATA;

  699.         }

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

  701. 

  702.     /* stream headers */

  703.     pos = 0;

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

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

  706.         if (pos < 0 + 1) {

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

  708.             return AVERROR_INVALIDDATA;

  709.         }

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

  711.             initialized_stream_count++;

  712.     }

  713. 

  714.     /* info headers */

  715.     pos = 0;

  716.     for (;;) {

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

  718.         pos = avio_tell(bc);

  719. 

  720.         if (startcode == 0) {

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

  722.             return AVERROR_INVALIDDATA;

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

  724.             nut->next_startcode = startcode;

  725.             break;

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

  727.             continue;

  728.         }

  729. 

  730.         decode_info_header(nut);

  731.     }

  732. 

  733.     s->data_offset = pos - 8;

  734. 

  735.     if (bc->seekable) {

  736.         int64_t orig_pos = avio_tell(bc);

  737.         find_and_decode_index(nut);

  738.         avio_seek(bc, orig_pos, SEEK_SET);

  739.     }

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

  741. 

  742.     ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);

  743. 

  744.     return 0;

  745. }

  746. 

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

  748.                                uint8_t *header_idx, int frame_code)

  749. {

  750.     AVFormatContext *s = nut->avf;

  751.     AVIOContext *bc    = s->pb;

  752.     StreamContext *stc;

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

  754.     uint64_t tmp;

  755. 

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

  757.         av_log(s, AV_LOG_ERROR,

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

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

  760.         return AVERROR_INVALIDDATA;

  761.     }

  762. 

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

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

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

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

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

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

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

  770. 

  771.     if (flags & FLAG_INVALID)

  772.         return AVERROR_INVALIDDATA;

  773.     if (flags & FLAG_CODED)

  774.         flags ^= ffio_read_varlen(bc);

  775.     if (flags & FLAG_STREAM_ID) {

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

  777.     }

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

  779.     if (flags & FLAG_CODED_PTS) {

  780.         int coded_pts = ffio_read_varlen(bc);

  781.         // FIXME check last_pts validity?

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

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

  784.         } else

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

  786.     } else

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

  788.     if (flags & FLAG_SIZE_MSB)

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

  790.     if (flags & FLAG_MATCH_TIME)

  791.         get_s(bc);

  792.     if (flags & FLAG_HEADER_IDX)

  793.         *header_idx = ffio_read_varlen(bc);

  794.     if (flags & FLAG_RESERVED)

  795.         reserved_count = ffio_read_varlen(bc);

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

  797.         ffio_read_varlen(bc);

  798. 

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

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

  801.         return AVERROR_INVALIDDATA;

  802.     }

  803.     if (size > 4096)

  804.         *header_idx = 0;

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

  806. 

  807.     if (flags & FLAG_CHECKSUM) {

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

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

  810.                stc->max_pts_distance) {

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

  812.         return AVERROR_INVALIDDATA;

  813.     }

  814. 

  815.     stc->last_pts   = *pts;

  816.     stc->last_flags = flags;

  817. 

  818.     return size;

  819. }

  820. 

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

  822. {

  823.     AVFormatContext *s = nut->avf;

  824.     AVIOContext *bc    = s->pb;

  825.     int size, stream_id, discard;

  826.     int64_t pts, last_IP_pts;

  827.     StreamContext *stc;

  828.     uint8_t header_idx;

  829. 

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

  831.     if (size < 0)

  832.         return size;

  833. 

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

  835. 

  836.     if (stc->last_flags & FLAG_KEY)

  837.         stc->skip_until_key_frame = 0;

  838. 

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

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

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

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

  843.          last_IP_pts > pts) ||

  844.         discard >= AVDISCARD_ALL ||

  845.         stc->skip_until_key_frame) {

  846.         avio_skip(bc, size);

  847.         return 1;

  848.     }

  849. 

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

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

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

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

  854. 

  855.     pkt->stream_index = stream_id;

  856.     if (stc->last_flags & FLAG_KEY)

  857.         pkt->flags |= AV_PKT_FLAG_KEY;

  858.     pkt->pts = pts;

  859. 

  860.     return 0;

  861. }

  862. 

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

  864. {

  865.     NUTContext *nut = s->priv_data;

  866.     AVIOContext *bc = s->pb;

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

  868.     int64_t ts, back_ptr;

  869. 

  870.     for (;;) {

  871.         int64_t pos  = avio_tell(bc);

  872.         uint64_t tmp = nut->next_startcode;

  873.         nut->next_startcode = 0;

  874. 

  875.         if (tmp) {

  876.             pos -= 8;

  877.         } else {

  878.             frame_code = avio_r8(bc);

  879.             if (url_feof(bc))

  880.                 return -1;

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

  882.                 tmp = frame_code;

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

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

  885.             }

  886.         }

  887.         switch (tmp) {

  888.         case MAIN_STARTCODE:

  889.         case STREAM_STARTCODE:

  890.         case INDEX_STARTCODE:

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

  892.             avio_skip(bc, skip);

  893.             break;

  894.         case INFO_STARTCODE:

  895.             if (decode_info_header(nut) < 0)

  896.                 goto resync;

  897.             break;

  898.         case SYNCPOINT_STARTCODE:

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

  900.                 goto resync;

  901.             frame_code = avio_r8(bc);

  902.         case 0:

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

  904.             if (ret == 0)

  905.                 return 0;

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

  907.                 break;

  908.         default:

  909. resync:

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

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

  912.             if (tmp == 0)

  913.                 return AVERROR_INVALIDDATA;

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

  915.             nut->next_startcode = tmp;

  916.         }

  917.     }

  918. }

  919. 

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

  921.                                   int64_t *pos_arg, int64_t pos_limit)

  922. {

  923.     NUTContext *nut = s->priv_data;

  924.     AVIOContext *bc = s->pb;

  925.     int64_t pos, pts, back_ptr;

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

  927.            stream_index, *pos_arg, pos_limit);

  928. 

  929.     pos = *pos_arg;

  930.     do {

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

  932.         if (pos < 1) {

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

  934.             return AV_NOPTS_VALUE;

  935.         }

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

  937.     *pos_arg = pos - 1;

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

  939. 

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

  941.     if (stream_index == -2)

  942.         return back_ptr;

  943.     av_assert0(stream_index == -1);

  944.     return pts;

  945. }

  946. 

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

  948.                      int64_t pts, int flags)

  949. {

  950.     NUTContext *nut    = s->priv_data;

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

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

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

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

  955.     int64_t pos, pos2, ts;

  956.     int i;

  957. 

  958.     if (st->index_entries) {

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

  960.         if (index < 0)

  961.             index = av_index_search_timestamp(st, pts, flags ^ AVSEEK_FLAG_BACKWARD);

  962.         if (index < 0)

  963.             return -1;

  964. 

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

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

  967.     } else {

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

  969.                      (void **) next_node);

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

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

  972.                next_node[1]->ts);

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

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

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

  976.                             AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);

  977. 

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

  979.             dummy.pos    = pos + 16;

  980.             next_node[1] = &nopts_sp;

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

  982.                          (void **) next_node);

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

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

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

  986.                                  flags, &ts, nut_read_timestamp);

  987.             if (pos2 >= 0)

  988.                 pos = pos2;

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

  990.         }

  991.         dummy.pos = pos;

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

  993.                           NULL);

  994. 

  995.         av_assert0(sp);

  996.         pos2 = sp->back_ptr - 15;

  997.     }

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

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

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

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

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

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

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

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

  1006. 

  1007.     return 0;

  1008. }

  1009. 

  1010. static int nut_read_close(AVFormatContext *s)

  1011. {

  1012.     NUTContext *nut = s->priv_data;

  1013.     int i;

  1014. 

  1015.     av_freep(&nut->time_base);

  1016.     av_freep(&nut->stream);

  1017.     ff_nut_free_sp(nut);

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

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

  1020. 

  1021.     return 0;

  1022. }

  1023. 

  1024. AVInputFormat ff_nut_demuxer = {

  1025.     .name           = "nut",

  1026.     .long_name      = NULL_IF_CONFIG_SMALL("NUT"),

  1027.     .flags          = AVFMT_SEEK_TO_PTS,

  1028.     .priv_data_size = sizeof(NUTContext),

  1029.     .read_probe     = nut_probe,

  1030.     .read_header    = nut_read_header,

  1031.     .read_packet    = nut_read_packet,

  1032.     .read_close     = nut_read_close,

  1033.     .read_seek      = read_seek,

  1034.     .extensions     = "nut",

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

  1036.         ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags,

  1037.         ff_nut_subtitle_tags, 0

  1038.     },

  1039. };