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

1031 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, char *file,

  81.                                    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, char *file,

  91.                                   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_vb_trace(AVIOContext *bc, char *file,

  101.                                     char *func, int line)

  102. {

  103.     uint64_t v = get_vb(bc);

  104. 

  105.     av_log(NULL, AV_LOG_DEBUG, "get_vb %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_vb(bc)           get_vb_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.             if (metadata && av_strcasecmp(name, "Uses") &&

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

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

  516.         }

  517.     }

  518. 

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

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

  521.         return -1;

  522.     }

  523.     return 0;

  524. }

  525. 

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

  527. {

  528.     AVFormatContext *s = nut->avf;

  529.     AVIOContext *bc    = s->pb;

  530.     int64_t end, tmp;

  531. 

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

  533. 

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

  535.     end += avio_tell(bc);

  536. 

  537.     tmp       = ffio_read_varlen(bc);

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

  539.     if (*back_ptr < 0)

  540.         return -1;

  541. 

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

  543.                     tmp / nut->time_base_count);

  544. 

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

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

  547.         return -1;

  548.     }

  549. 

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

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

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

  553. 

  554.     return 0;

  555. }

  556. 

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

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

  559. {

  560.     AVFormatContext *s = nut->avf;

  561.     int64_t duration = 0;

  562. 

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

  564.     for(;;){

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

  566.         if(ts < 0)

  567.             break;

  568.         duration = FFMAX(duration, ts);

  569.         pos++;

  570.     }

  571.     if(duration > 0)

  572.         s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;

  573.     return duration;

  574. }

  575. 

  576. static int find_and_decode_index(NUTContext *nut)

  577. {

  578.     AVFormatContext *s = nut->avf;

  579.     AVIOContext *bc    = s->pb;

  580.     uint64_t tmp, end;

  581.     int i, j, syncpoint_count;

  582.     int64_t filesize = avio_size(bc);

  583.     int64_t *syncpoints;

  584.     int8_t *has_keyframe;

  585.     int ret = -1;

  586. 

  587.     if(filesize <= 0)

  588.         return -1;

  589. 

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

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

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

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

  594. 

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

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

  597.         return -1;

  598.     }

  599. 

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

  601.     end += avio_tell(bc);

  602. 

  603.     ffio_read_varlen(bc); // max_pts

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

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

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

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

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

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

  610.             goto fail;

  611.         if (i)

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

  613.     }

  614. 

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

  616.         int64_t last_pts = -1;

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

  618.             uint64_t x = ffio_read_varlen(bc);

  619.             int type   = x & 1;

  620.             int n      = j;

  621.             x >>= 1;

  622.             if (type) {

  623.                 int flag = x & 1;

  624.                 x >>= 1;

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

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

  627.                     goto fail;

  628.                 }

  629.                 while (x--)

  630.                     has_keyframe[n++] = flag;

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

  632.             } else {

  633.                 while (x != 1) {

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

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

  636.                         goto fail;

  637.                     }

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

  639.                     x >>= 1;

  640.                 }

  641.             }

  642.             if (has_keyframe[0]) {

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

  644.                 goto fail;

  645.             }

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

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

  648.                 if (has_keyframe[j]) {

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

  650.                     if (!A) {

  651.                         A = ffio_read_varlen(bc);

  652.                         B = ffio_read_varlen(bc);

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

  654.                     } else

  655.                         B = 0;

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

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

  658.                     last_pts += A + B;

  659.                 }

  660.             }

  661.         }

  662.     }

  663. 

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

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

  666.         goto fail;

  667.     }

  668.     ret = 0;

  669. 

  670. fail:

  671.     av_free(syncpoints);

  672.     av_free(has_keyframe);

  673.     return ret;

  674. }

  675. 

  676. static int nut_read_header(AVFormatContext *s)

  677. {

  678.     NUTContext *nut = s->priv_data;

  679.     AVIOContext *bc = s->pb;

  680.     int64_t pos;

  681.     int initialized_stream_count;

  682. 

  683.     nut->avf = s;

  684. 

  685.     /* main header */

  686.     pos = 0;

  687.     do {

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

  689.         if (pos < 0 + 1) {

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

  691.             return AVERROR_INVALIDDATA;

  692.         }

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

  694. 

  695.     /* stream headers */

  696.     pos = 0;

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

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

  699.         if (pos < 0 + 1) {

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

  701.             return AVERROR_INVALIDDATA;

  702.         }

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

  704.             initialized_stream_count++;

  705.     }

  706. 

  707.     /* info headers */

  708.     pos = 0;

  709.     for (;;) {

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

  711.         pos = avio_tell(bc);

  712. 

  713.         if (startcode == 0) {

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

  715.             return AVERROR_INVALIDDATA;

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

  717.             nut->next_startcode = startcode;

  718.             break;

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

  720.             continue;

  721.         }

  722. 

  723.         decode_info_header(nut);

  724.     }

  725. 

  726.     s->data_offset = pos - 8;

  727. 

  728.     if (bc->seekable) {

  729.         int64_t orig_pos = avio_tell(bc);

  730.         find_and_decode_index(nut);

  731.         avio_seek(bc, orig_pos, SEEK_SET);

  732.     }

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

  734. 

  735.     ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);

  736. 

  737.     return 0;

  738. }

  739. 

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

  741.                                uint8_t *header_idx, int frame_code)

  742. {

  743.     AVFormatContext *s = nut->avf;

  744.     AVIOContext *bc    = s->pb;

  745.     StreamContext *stc;

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

  747.     uint64_t tmp;

  748. 

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

  750.         av_log(s, AV_LOG_ERROR,

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

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

  753.         return AVERROR_INVALIDDATA;

  754.     }

  755. 

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

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

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

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

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

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

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

  763. 

  764.     if (flags & FLAG_INVALID)

  765.         return AVERROR_INVALIDDATA;

  766.     if (flags & FLAG_CODED)

  767.         flags ^= ffio_read_varlen(bc);

  768.     if (flags & FLAG_STREAM_ID) {

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

  770.     }

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

  772.     if (flags & FLAG_CODED_PTS) {

  773.         int coded_pts = ffio_read_varlen(bc);

  774.         // FIXME check last_pts validity?

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

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

  777.         } else

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

  779.     } else

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

  781.     if (flags & FLAG_SIZE_MSB)

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

  783.     if (flags & FLAG_MATCH_TIME)

  784.         get_s(bc);

  785.     if (flags & FLAG_HEADER_IDX)

  786.         *header_idx = ffio_read_varlen(bc);

  787.     if (flags & FLAG_RESERVED)

  788.         reserved_count = ffio_read_varlen(bc);

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

  790.         ffio_read_varlen(bc);

  791. 

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

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

  794.         return AVERROR_INVALIDDATA;

  795.     }

  796.     if (size > 4096)

  797.         *header_idx = 0;

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

  799. 

  800.     if (flags & FLAG_CHECKSUM) {

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

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

  803.                stc->max_pts_distance) {

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

  805.         return AVERROR_INVALIDDATA;

  806.     }

  807. 

  808.     stc->last_pts   = *pts;

  809.     stc->last_flags = flags;

  810. 

  811.     return size;

  812. }

  813. 

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

  815. {

  816.     AVFormatContext *s = nut->avf;

  817.     AVIOContext *bc    = s->pb;

  818.     int size, stream_id, discard;

  819.     int64_t pts, last_IP_pts;

  820.     StreamContext *stc;

  821.     uint8_t header_idx;

  822. 

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

  824.     if (size < 0)

  825.         return size;

  826. 

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

  828. 

  829.     if (stc->last_flags & FLAG_KEY)

  830.         stc->skip_until_key_frame = 0;

  831. 

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

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

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

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

  836.          last_IP_pts > pts) ||

  837.         discard >= AVDISCARD_ALL ||

  838.         stc->skip_until_key_frame) {

  839.         avio_skip(bc, size);

  840.         return 1;

  841.     }

  842. 

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

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

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

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

  847. 

  848.     pkt->stream_index = stream_id;

  849.     if (stc->last_flags & FLAG_KEY)

  850.         pkt->flags |= AV_PKT_FLAG_KEY;

  851.     pkt->pts = pts;

  852. 

  853.     return 0;

  854. }

  855. 

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

  857. {

  858.     NUTContext *nut = s->priv_data;

  859.     AVIOContext *bc = s->pb;

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

  861.     int64_t ts, back_ptr;

  862. 

  863.     for (;;) {

  864.         int64_t pos  = avio_tell(bc);

  865.         uint64_t tmp = nut->next_startcode;

  866.         nut->next_startcode = 0;

  867. 

  868.         if (tmp) {

  869.             pos -= 8;

  870.         } else {

  871.             frame_code = avio_r8(bc);

  872.             if (url_feof(bc))

  873.                 return -1;

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

  875.                 tmp = frame_code;

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

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

  878.             }

  879.         }

  880.         switch (tmp) {

  881.         case MAIN_STARTCODE:

  882.         case STREAM_STARTCODE:

  883.         case INDEX_STARTCODE:

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

  885.             avio_skip(bc, skip);

  886.             break;

  887.         case INFO_STARTCODE:

  888.             if (decode_info_header(nut) < 0)

  889.                 goto resync;

  890.             break;

  891.         case SYNCPOINT_STARTCODE:

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

  893.                 goto resync;

  894.             frame_code = avio_r8(bc);

  895.         case 0:

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

  897.             if (ret == 0)

  898.                 return 0;

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

  900.                 break;

  901.         default:

  902. resync:

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

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

  905.             if (tmp == 0)

  906.                 return AVERROR_INVALIDDATA;

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

  908.             nut->next_startcode = tmp;

  909.         }

  910.     }

  911. }

  912. 

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

  914.                                   int64_t *pos_arg, int64_t pos_limit)

  915. {

  916.     NUTContext *nut = s->priv_data;

  917.     AVIOContext *bc = s->pb;

  918.     int64_t pos, pts, back_ptr;

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

  920.            stream_index, *pos_arg, pos_limit);

  921. 

  922.     pos = *pos_arg;

  923.     do {

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

  925.         if (pos < 1) {

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

  927.             return AV_NOPTS_VALUE;

  928.         }

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

  930.     *pos_arg = pos - 1;

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

  932. 

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

  934.     if (stream_index == -2)

  935.         return back_ptr;

  936.     av_assert0(stream_index == -1);

  937.     return pts;

  938. }

  939. 

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

  941.                      int64_t pts, int flags)

  942. {

  943.     NUTContext *nut    = s->priv_data;

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

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

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

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

  948.     int64_t pos, pos2, ts;

  949.     int i;

  950. 

  951.     if (st->index_entries) {

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

  953.         if (index < 0)

  954.             return -1;

  955. 

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

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

  958.     } else {

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

  960.                      (void **) next_node);

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

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

  963.                next_node[1]->ts);

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

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

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

  967.                             AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);

  968. 

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

  970.             dummy.pos    = pos + 16;

  971.             next_node[1] = &nopts_sp;

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

  973.                          (void **) next_node);

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

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

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

  977.                                  flags, &ts, nut_read_timestamp);

  978.             if (pos2 >= 0)

  979.                 pos = pos2;

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

  981.         }

  982.         dummy.pos = pos;

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

  984.                           NULL);

  985. 

  986.         av_assert0(sp);

  987.         pos2 = sp->back_ptr - 15;

  988.     }

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

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

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

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

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

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

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

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

  997. 

  998.     return 0;

  999. }

  1000. 

  1001. static int nut_read_close(AVFormatContext *s)

  1002. {

  1003.     NUTContext *nut = s->priv_data;

  1004.     int i;

  1005. 

  1006.     av_freep(&nut->time_base);

  1007.     av_freep(&nut->stream);

  1008.     ff_nut_free_sp(nut);

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

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

  1011. 

  1012.     return 0;

  1013. }

  1014. 

  1015. AVInputFormat ff_nut_demuxer = {

  1016.     .name           = "nut",

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

  1018.     .flags          = AVFMT_SEEK_TO_PTS,

  1019.     .priv_data_size = sizeof(NUTContext),

  1020.     .read_probe     = nut_probe,

  1021.     .read_header    = nut_read_header,

  1022.     .read_packet    = nut_read_packet,

  1023.     .read_close     = nut_read_close,

  1024.     .read_seek      = read_seek,

  1025.     .extensions     = "nut",

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

  1027.         ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags,

  1028.         ff_nut_subtitle_tags, 0

  1029.     },

  1030. };