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

999 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 Libav.

  7.  *

  8.  * Libav 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.  * Libav 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 Libav; 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/bswap.h"

  25. #include "libavutil/dict.h"

  26. #include "libavutil/mathematics.h"

  27. #include "libavutil/tree.h"

  28. #include "avio_internal.h"

  29. #include "nut.h"

  30. 

  31. #undef NDEBUG

  32. #include <assert.h>

  33. 

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

  35. 

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

  37. {

  38.     unsigned int len = ffio_read_varlen(bc);

  39. 

  40.     if (len && maxlen)

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

  42.     while (len > maxlen) {

  43.         avio_r8(bc);

  44.         len--;

  45.     }

  46. 

  47.     if (maxlen)

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

  49. 

  50.     if (maxlen == len)

  51.         return -1;

  52.     else

  53.         return 0;

  54. }

  55. 

  56. static int64_t get_s(AVIOContext *bc)

  57. {

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

  59. 

  60.     if (v & 1)

  61.         return -(v >> 1);

  62.     else

  63.         return  (v >> 1);

  64. }

  65. 

  66. static uint64_t get_fourcc(AVIOContext *bc)

  67. {

  68.     unsigned int len = ffio_read_varlen(bc);

  69. 

  70.     if (len == 2)

  71.         return avio_rl16(bc);

  72.     else if (len == 4)

  73.         return avio_rl32(bc);

  74.     else

  75.         return -1;

  76. }

  77. 

  78. #ifdef TRACE

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

  80.                                    const char *func, int line)

  81. {

  82.     uint64_t v = ffio_read_varlen(bc);

  83. 

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

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

  86.     return v;

  87. }

  88. 

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

  90.                                   const char *func, int line)

  91. {

  92.     int64_t v = get_s(bc);

  93. 

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

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

  96.     return v;

  97. }

  98. 

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

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

  101. #endif

  102. 

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

  104.                             int calculate_checksum, uint64_t startcode)

  105. {

  106.     int64_t size;

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

  108. 

  109.     startcode = av_be2ne64(startcode);

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

  111. 

  112.     ffio_init_checksum(bc, ff_crc04C11DB7_update, startcode);

  113.     size = ffio_read_varlen(bc);

  114.     if (size > 4096)

  115.         avio_rb32(bc);

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

  117.         return -1;

  118. 

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

  120. 

  121.     return size;

  122. }

  123. 

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

  125. {

  126.     uint64_t state = 0;

  127. 

  128.     if (pos >= 0)

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

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

  131.         avio_seek(bc, pos, SEEK_SET);

  132.     while (!bc->eof_reached) {

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

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

  135.             continue;

  136.         switch (state) {

  137.         case MAIN_STARTCODE:

  138.         case STREAM_STARTCODE:

  139.         case SYNCPOINT_STARTCODE:

  140.         case INFO_STARTCODE:

  141.         case INDEX_STARTCODE:

  142.             return state;

  143.         }

  144.     }

  145. 

  146.     return 0;

  147. }

  148. 

  149. /**

  150.  * Find the given startcode.

  151.  * @param code the startcode

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

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

  154.  */

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

  156. {

  157.     for (;;) {

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

  159.         if (startcode == code)

  160.             return avio_tell(bc) - 8;

  161.         else if (startcode == 0)

  162.             return -1;

  163.         pos = -1;

  164.     }

  165. }

  166. 

  167. static int nut_probe(AVProbeData *p)

  168. {

  169.     int i;

  170.     uint64_t code = 0;

  171. 

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

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

  174.         if (code == MAIN_STARTCODE)

  175.             return AVPROBE_SCORE_MAX;

  176.     }

  177.     return 0;

  178. }

  179. 

  180. #define GET_V(dst, check)                                                     \

  181.     do {                                                                      \

  182.         tmp = ffio_read_varlen(bc);                                           \

  183.         if (!(check)) {                                                       \

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

  185.             return -1;                                                        \

  186.         }                                                                     \

  187.         dst = tmp;                                                            \

  188.     } while (0)

  189. 

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

  191. {

  192.     pos -= avio_tell(bc);

  193.     if (pos < 0) {

  194.         avio_seek(bc, pos, SEEK_CUR);

  195.         return -1;

  196.     } else {

  197.         while (pos--)

  198.             avio_r8(bc);

  199.         return 0;

  200.     }

  201. }

  202. 

  203. static int decode_main_header(NUTContext *nut)

  204. {

  205.     AVFormatContext *s = nut->avf;

  206.     AVIOContext *bc    = s->pb;

  207.     uint64_t tmp, end;

  208.     unsigned int stream_count;

  209.     int i, j, count;

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

  211. 

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

  213.     end += avio_tell(bc);

  214. 

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

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

  217. 

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

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

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

  221.         nut->max_distance = 65536;

  222.     }

  223. 

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

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

  226. 

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

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

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

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

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

  232.             return AVERROR_INVALIDDATA;

  233.         }

  234.     }

  235.     tmp_pts      = 0;

  236.     tmp_mul      = 1;

  237.     tmp_stream   = 0;

  238.     tmp_head_idx = 0;

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

  240.         int tmp_flags  = ffio_read_varlen(bc);

  241.         int tmp_fields = ffio_read_varlen(bc);

  242. 

  243.         if (tmp_fields > 0)

  244.             tmp_pts = get_s(bc);

  245.         if (tmp_fields > 1)

  246.             tmp_mul = ffio_read_varlen(bc);

  247.         if (tmp_fields > 2)

  248.             tmp_stream = ffio_read_varlen(bc);

  249.         if (tmp_fields > 3)

  250.             tmp_size = ffio_read_varlen(bc);

  251.         else

  252.             tmp_size = 0;

  253.         if (tmp_fields > 4)

  254.             tmp_res = ffio_read_varlen(bc);

  255.         else

  256.             tmp_res = 0;

  257.         if (tmp_fields > 5)

  258.             count = ffio_read_varlen(bc);

  259.         else

  260.             count = tmp_mul - tmp_size;

  261.         if (tmp_fields > 6)

  262.             get_s(bc);

  263.         if (tmp_fields > 7)

  264.             tmp_head_idx = ffio_read_varlen(bc);

  265. 

  266.         while (tmp_fields-- > 8)

  267.             ffio_read_varlen(bc);

  268. 

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

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

  271.             return AVERROR_INVALIDDATA;

  272.         }

  273.         if (tmp_stream >= stream_count) {

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

  275.             return AVERROR_INVALIDDATA;

  276.         }

  277. 

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

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

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

  281.                 j--;

  282.                 continue;

  283.             }

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

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

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

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

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

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

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

  291.         }

  292.     }

  293.     assert(nut->frame_code['N'].flags == FLAG_INVALID);

  294. 

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

  296.         int rem = 1024;

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

  298.         nut->header_count++;

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

  300.             uint8_t *hdr;

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

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

  303.             if (rem < 0) {

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

  305.                 return AVERROR_INVALIDDATA;

  306.             }

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

  308.             if (!hdr)

  309.                 return AVERROR(ENOMEM);

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

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

  312.         }

  313.         assert(nut->header_len[0] == 0);

  314.     }

  315. 

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

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

  318.         return AVERROR_INVALIDDATA;

  319.     }

  320. 

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

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

  323.         avformat_new_stream(s, NULL);

  324. 

  325.     return 0;

  326. }

  327. 

  328. static int decode_stream_header(NUTContext *nut)

  329. {

  330.     AVFormatContext *s = nut->avf;

  331.     AVIOContext *bc    = s->pb;

  332.     StreamContext *stc;

  333.     int class, stream_id;

  334.     uint64_t tmp, end;

  335.     AVStream *st;

  336. 

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

  338.     end += avio_tell(bc);

  339. 

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

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

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

  343.     if (!st)

  344.         return AVERROR(ENOMEM);

  345. 

  346.     class                = ffio_read_varlen(bc);

  347.     tmp                  = get_fourcc(bc);

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

  349.     switch (class) {

  350.     case 0:

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

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

  353.                                                     ff_codec_bmp_tags,

  354.                                                     ff_nut_video_tags,

  355.                                                     0

  356.                                                 },

  357.                                                 tmp);

  358.         break;

  359.     case 1:

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

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

  362.         break;

  363.     case 2:

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

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

  366.         break;

  367.     case 3:

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

  369.         break;

  370.     default:

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

  372.         return -1;

  373.     }

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

  375.         av_log(s, AV_LOG_ERROR,

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

  377.                (unsigned int) tmp, stream_id);

  378. 

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

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

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

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

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

  384.     ffio_read_varlen(bc); // stream flags

  385. 

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

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

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

  389.                                           FF_INPUT_BUFFER_PADDING_SIZE);

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

  391.     }

  392. 

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

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

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

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

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

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

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

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

  401.             return -1;

  402.         }

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

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

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

  406.         ffio_read_varlen(bc); // samplerate_den

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

  408.     }

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

  410.         av_log(s, AV_LOG_ERROR,

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

  412.         return -1;

  413.     }

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

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

  416.                         stc->time_base->den);

  417.     return 0;

  418. }

  419. 

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

  421.                                  int stream_id)

  422. {

  423.     int flag = 0, i;

  424. 

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

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

  427.             flag = ff_nut_dispositions[i].flag;

  428.     if (!flag)

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

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

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

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

  433. }

  434. 

  435. static int decode_info_header(NUTContext *nut)

  436. {

  437.     AVFormatContext *s = nut->avf;

  438.     AVIOContext *bc    = s->pb;

  439.     uint64_t tmp, chapter_start, chapter_len;

  440.     unsigned int stream_id_plus1, count;

  441.     int chapter_id, i;

  442.     int64_t value, end;

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

  444.     const char *type;

  445.     AVChapter *chapter      = NULL;

  446.     AVStream *st            = NULL;

  447.     AVDictionary **metadata = NULL;

  448. 

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

  450.     end += avio_tell(bc);

  451. 

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

  453.     chapter_id    = get_s(bc);

  454.     chapter_start = ffio_read_varlen(bc);

  455.     chapter_len   = ffio_read_varlen(bc);

  456.     count         = ffio_read_varlen(bc);

  457. 

  458.     if (chapter_id && !stream_id_plus1) {

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

  460.         chapter = avpriv_new_chapter(s, chapter_id,

  461.                                      nut->time_base[chapter_start %

  462.                                                     nut->time_base_count],

  463.                                      start, start + chapter_len, NULL);

  464.         metadata = &chapter->metadata;

  465.     } else if (stream_id_plus1) {

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

  467.         metadata = &st->metadata;

  468.     } else

  469.         metadata = &s->metadata;

  470. 

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

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

  473.         value = get_s(bc);

  474.         if (value == -1) {

  475.             type = "UTF-8";

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

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

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

  479.             type = type_str;

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

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

  482.             type  = "s";

  483.             value = get_s(bc);

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

  485.             type  = "t";

  486.             value = ffio_read_varlen(bc);

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

  488.             type = "r";

  489.             get_s(bc);

  490.         } else {

  491.             type = "v";

  492.         }

  493. 

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

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

  496.             continue;

  497.         }

  498. 

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

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

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

  502.                 continue;

  503.             }

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

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

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

  507.         }

  508.     }

  509. 

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

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

  512.         return -1;

  513.     }

  514.     return 0;

  515. }

  516. 

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

  518. {

  519.     AVFormatContext *s = nut->avf;

  520.     AVIOContext *bc    = s->pb;

  521.     int64_t end, tmp;

  522. 

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

  524. 

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

  526.     end += avio_tell(bc);

  527. 

  528.     tmp       = ffio_read_varlen(bc);

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

  530.     if (*back_ptr < 0)

  531.         return -1;

  532. 

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

  534.                     tmp / nut->time_base_count);

  535. 

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

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

  538.         return -1;

  539.     }

  540. 

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

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

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

  544. 

  545.     return 0;

  546. }

  547. 

  548. static int find_and_decode_index(NUTContext *nut)

  549. {

  550.     AVFormatContext *s = nut->avf;

  551.     AVIOContext *bc    = s->pb;

  552.     uint64_t tmp, end;

  553.     int i, j, syncpoint_count;

  554.     int64_t filesize = avio_size(bc);

  555.     int64_t *syncpoints;

  556.     int8_t *has_keyframe;

  557.     int ret = -1;

  558. 

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

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

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

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

  563.         return -1;

  564.     }

  565. 

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

  567.     end += avio_tell(bc);

  568. 

  569.     ffio_read_varlen(bc); // max_pts

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

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

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

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

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

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

  576.             goto fail;

  577.         if (i)

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

  579.     }

  580. 

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

  582.         int64_t last_pts = -1;

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

  584.             uint64_t x = ffio_read_varlen(bc);

  585.             int type   = x & 1;

  586.             int n      = j;

  587.             x >>= 1;

  588.             if (type) {

  589.                 int flag = x & 1;

  590.                 x >>= 1;

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

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

  593.                     goto fail;

  594.                 }

  595.                 while (x--)

  596.                     has_keyframe[n++] = flag;

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

  598.             } else {

  599.                 while (x != 1) {

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

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

  602.                         goto fail;

  603.                     }

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

  605.                     x >>= 1;

  606.                 }

  607.             }

  608.             if (has_keyframe[0]) {

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

  610.                 goto fail;

  611.             }

  612.             assert(n <= syncpoint_count + 1);

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

  614.                 if (has_keyframe[j]) {

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

  616.                     if (!A) {

  617.                         A = ffio_read_varlen(bc);

  618.                         B = ffio_read_varlen(bc);

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

  620.                     } else

  621.                         B = 0;

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

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

  624.                     last_pts += A + B;

  625.                 }

  626.             }

  627.         }

  628.     }

  629. 

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

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

  632.         goto fail;

  633.     }

  634.     ret = 0;

  635. 

  636. fail:

  637.     av_free(syncpoints);

  638.     av_free(has_keyframe);

  639.     return ret;

  640. }

  641. 

  642. static int nut_read_header(AVFormatContext *s)

  643. {

  644.     NUTContext *nut = s->priv_data;

  645.     AVIOContext *bc = s->pb;

  646.     int64_t pos;

  647.     int initialized_stream_count;

  648. 

  649.     nut->avf = s;

  650. 

  651.     /* main header */

  652.     pos = 0;

  653.     do {

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

  655.         if (pos < 0 + 1) {

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

  657.             return AVERROR_INVALIDDATA;

  658.         }

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

  660. 

  661.     /* stream headers */

  662.     pos = 0;

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

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

  665.         if (pos < 0 + 1) {

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

  667.             return AVERROR_INVALIDDATA;

  668.         }

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

  670.             initialized_stream_count++;

  671.     }

  672. 

  673.     /* info headers */

  674.     pos = 0;

  675.     for (;;) {

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

  677.         pos = avio_tell(bc);

  678. 

  679.         if (startcode == 0) {

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

  681.             return AVERROR_INVALIDDATA;

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

  683.             nut->next_startcode = startcode;

  684.             break;

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

  686.             continue;

  687.         }

  688. 

  689.         decode_info_header(nut);

  690.     }

  691. 

  692.     s->data_offset = pos - 8;

  693. 

  694.     if (bc->seekable) {

  695.         int64_t orig_pos = avio_tell(bc);

  696.         find_and_decode_index(nut);

  697.         avio_seek(bc, orig_pos, SEEK_SET);

  698.     }

  699.     assert(nut->next_startcode == SYNCPOINT_STARTCODE);

  700. 

  701.     ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);

  702. 

  703.     return 0;

  704. }

  705. 

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

  707.                                uint8_t *header_idx, int frame_code)

  708. {

  709.     AVFormatContext *s = nut->avf;

  710.     AVIOContext *bc    = s->pb;

  711.     StreamContext *stc;

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

  713.     uint64_t tmp;

  714. 

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

  716.         av_log(s, AV_LOG_ERROR,

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

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

  719.         return AVERROR_INVALIDDATA;

  720.     }

  721. 

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

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

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

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

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

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

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

  729. 

  730.     if (flags & FLAG_INVALID)

  731.         return AVERROR_INVALIDDATA;

  732.     if (flags & FLAG_CODED)

  733.         flags ^= ffio_read_varlen(bc);

  734.     if (flags & FLAG_STREAM_ID) {

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

  736.     }

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

  738.     if (flags & FLAG_CODED_PTS) {

  739.         int coded_pts = ffio_read_varlen(bc);

  740.         // FIXME check last_pts validity?

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

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

  743.         } else

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

  745.     } else

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

  747.     if (flags & FLAG_SIZE_MSB)

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

  749.     if (flags & FLAG_MATCH_TIME)

  750.         get_s(bc);

  751.     if (flags & FLAG_HEADER_IDX)

  752.         *header_idx = ffio_read_varlen(bc);

  753.     if (flags & FLAG_RESERVED)

  754.         reserved_count = ffio_read_varlen(bc);

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

  756.         ffio_read_varlen(bc);

  757. 

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

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

  760.         return AVERROR_INVALIDDATA;

  761.     }

  762.     if (size > 4096)

  763.         *header_idx = 0;

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

  765. 

  766.     if (flags & FLAG_CHECKSUM) {

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

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

  769.                stc->max_pts_distance) {

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

  771.         return AVERROR_INVALIDDATA;

  772.     }

  773. 

  774.     stc->last_pts   = *pts;

  775.     stc->last_flags = flags;

  776. 

  777.     return size;

  778. }

  779. 

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

  781. {

  782.     AVFormatContext *s = nut->avf;

  783.     AVIOContext *bc    = s->pb;

  784.     int size, stream_id, discard;

  785.     int64_t pts, last_IP_pts;

  786.     StreamContext *stc;

  787.     uint8_t header_idx;

  788. 

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

  790.     if (size < 0)

  791.         return size;

  792. 

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

  794. 

  795.     if (stc->last_flags & FLAG_KEY)

  796.         stc->skip_until_key_frame = 0;

  797. 

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

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

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

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

  802.          last_IP_pts > pts) ||

  803.         discard >= AVDISCARD_ALL ||

  804.         stc->skip_until_key_frame) {

  805.         avio_skip(bc, size);

  806.         return 1;

  807.     }

  808. 

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

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

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

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

  813. 

  814.     pkt->stream_index = stream_id;

  815.     if (stc->last_flags & FLAG_KEY)

  816.         pkt->flags |= AV_PKT_FLAG_KEY;

  817.     pkt->pts = pts;

  818. 

  819.     return 0;

  820. }

  821. 

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

  823. {

  824.     NUTContext *nut = s->priv_data;

  825.     AVIOContext *bc = s->pb;

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

  827.     int64_t ts, back_ptr;

  828. 

  829.     for (;;) {

  830.         int64_t pos  = avio_tell(bc);

  831.         uint64_t tmp = nut->next_startcode;

  832.         nut->next_startcode = 0;

  833. 

  834.         if (tmp) {

  835.             pos -= 8;

  836.         } else {

  837.             frame_code = avio_r8(bc);

  838.             if (bc->eof_reached)

  839.                 return -1;

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

  841.                 tmp = frame_code;

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

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

  844.             }

  845.         }

  846.         switch (tmp) {

  847.         case MAIN_STARTCODE:

  848.         case STREAM_STARTCODE:

  849.         case INDEX_STARTCODE:

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

  851.             avio_skip(bc, skip);

  852.             break;

  853.         case INFO_STARTCODE:

  854.             if (decode_info_header(nut) < 0)

  855.                 goto resync;

  856.             break;

  857.         case SYNCPOINT_STARTCODE:

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

  859.                 goto resync;

  860.             frame_code = avio_r8(bc);

  861.         case 0:

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

  863.             if (ret == 0)

  864.                 return 0;

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

  866.                 break;

  867.         default:

  868. resync:

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

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

  871.             if (tmp == 0)

  872.                 return AVERROR_INVALIDDATA;

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

  874.             nut->next_startcode = tmp;

  875.         }

  876.     }

  877. }

  878. 

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

  880.                                   int64_t *pos_arg, int64_t pos_limit)

  881. {

  882.     NUTContext *nut = s->priv_data;

  883.     AVIOContext *bc = s->pb;

  884.     int64_t pos, pts, back_ptr;

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

  886.            stream_index, *pos_arg, pos_limit);

  887. 

  888.     pos = *pos_arg;

  889.     do {

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

  891.         if (pos < 1) {

  892.             assert(nut->next_startcode == 0);

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

  894.             return AV_NOPTS_VALUE;

  895.         }

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

  897.     *pos_arg = pos - 1;

  898.     assert(nut->last_syncpoint_pos == *pos_arg);

  899. 

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

  901.     if (stream_index == -1)

  902.         return pts;

  903.     else if (stream_index == -2)

  904.         return back_ptr;

  905. 

  906.     assert(0);

  907. }

  908. 

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

  910.                      int64_t pts, int flags)

  911. {

  912.     NUTContext *nut    = s->priv_data;

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

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

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

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

  917.     int64_t pos, pos2, ts;

  918.     int i;

  919. 

  920.     if (st->index_entries) {

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

  922.         if (index < 0)

  923.             return -1;

  924. 

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

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

  927.     } else {

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

  929.                      (void **) next_node);

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

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

  932.                next_node[1]->ts);

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

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

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

  936.                             AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);

  937. 

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

  939.             dummy.pos    = pos + 16;

  940.             next_node[1] = &nopts_sp;

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

  942.                          (void **) next_node);

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

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

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

  946.                                  flags, &ts, nut_read_timestamp);

  947.             if (pos2 >= 0)

  948.                 pos = pos2;

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

  950.         }

  951.         dummy.pos = pos;

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

  953.                           NULL);

  954. 

  955.         assert(sp);

  956.         pos2 = sp->back_ptr - 15;

  957.     }

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

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

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

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

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

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

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

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

  966. 

  967.     return 0;

  968. }

  969. 

  970. static int nut_read_close(AVFormatContext *s)

  971. {

  972.     NUTContext *nut = s->priv_data;

  973.     int i;

  974. 

  975.     av_freep(&nut->time_base);

  976.     av_freep(&nut->stream);

  977.     ff_nut_free_sp(nut);

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

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

  980. 

  981.     return 0;

  982. }

  983. 

  984. AVInputFormat ff_nut_demuxer = {

  985.     .name           = "nut",

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

  987.     .priv_data_size = sizeof(NUTContext),

  988.     .read_probe     = nut_probe,

  989.     .read_header    = nut_read_header,

  990.     .read_packet    = nut_read_packet,

  991.     .read_close     = nut_read_close,

  992.     .read_seek      = read_seek,

  993.     .extensions     = "nut",

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

  995.         ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags,

  996.         ff_nut_subtitle_tags, 0

  997.     },

  998. };