git.sesse.net Git - ffmpeg/blob - libavformat/nutdec.c

   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
  24 #include "nut.h"
  25
  26 #undef NDEBUG
  27 #include <assert.h>
  28
  29 static uint64_t get_v(ByteIOContext *bc/*, maxstuffing*/){
  30     uint64_t val = 0;
  31
  32     for(;;)
  33     {
  34         int tmp = get_byte(bc);
  35
  36 //         if(tmp=0x80){
  37 //             if(!maxstuffing-- || val)
  38 //                 return -1;
  39 //         }
  40
  41         if (tmp&0x80)
  42             val= (val<<7) + tmp - 0x80;
  43         else{
  44             return (val<<7) + tmp;
  45         }
  46     }
  47     return -1;
  48 }
  49
  50 static int get_str(ByteIOContext *bc, char *string, unsigned int maxlen){
  51     unsigned int len= get_v(bc);
  52
  53     if(len && maxlen)
  54         get_buffer(bc, string, FFMIN(len, maxlen));
  55     while(len > maxlen){
  56         get_byte(bc);
  57         len--;
  58     }
  59
  60     if(maxlen)
  61         string[FFMIN(len, maxlen-1)]= 0;
  62
  63     if(maxlen == len)
  64         return -1;
  65     else
  66         return 0;
  67 }
  68
  69 static int64_t get_s(ByteIOContext *bc){
  70     int64_t v = get_v(bc) + 1;
  71
  72     if (v&1) return -(v>>1);
  73     else     return  (v>>1);
  74 }
  75
  76 static uint64_t get_fourcc(ByteIOContext *bc){
  77     unsigned int len= get_v(bc);
  78
  79     if     (len==2) return get_le16(bc);
  80     else if(len==4) return get_le32(bc);
  81     else            return -1;
  82 }
  83
  84 #ifdef TRACE
  85 static inline uint64_t get_v_trace(ByteIOContext *bc, char *file, char *func, int line){
  86     uint64_t v= get_v(bc);
  87
  88     printf("get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
  89     return v;
  90 }
  91
  92 static inline int64_t get_s_trace(ByteIOContext *bc, char *file, char *func, int line){
  93     int64_t v= get_s(bc);
  94
  95     printf("get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
  96     return v;
  97 }
  98
  99 static inline uint64_t get_vb_trace(ByteIOContext *bc, char *file, char *func, int line){
 100     uint64_t v= get_vb(bc);
 101
 102     printf("get_vb %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
 103     return v;
 104 }
 105 #define get_v(bc)  get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
 106 #define get_s(bc)  get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
 107 #define get_vb(bc)  get_vb_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
 108 #endif
 109
 110 static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int calculate_checksum)
 111 {
 112     int64_t start, size;
 113 //    start= url_ftell(bc) - 8;
 114
 115     size= get_v(bc);
 116
 117     init_checksum(bc, calculate_checksum ? av_crc04C11DB7_update : NULL, 1);
 118
 119 //    nut->packet_start[2] = start;
 120 //    nut->written_packet_size= size;
 121
 122     return size;
 123 }
 124
 125 static int check_checksum(ByteIOContext *bc){
 126     unsigned long checksum= get_checksum(bc);
 127 //    return checksum != get_be32(bc);
 128
 129     av_log(NULL, AV_LOG_ERROR, "%08X %08X\n", checksum, (int)get_be32(bc));
 130
 131     return 0;
 132 }
 133
 134 static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){
 135     uint64_t state=0;
 136
 137     if(pos >= 0)
 138         url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream isnt seekable, but that shouldnt matter, as in this case we simply start where we are currently
 139
 140     while(!url_feof(bc)){
 141         state= (state<<8) | get_byte(bc);
 142         if((state>>56) != 'N')
 143             continue;
 144         switch(state){
 145         case MAIN_STARTCODE:
 146         case STREAM_STARTCODE:
 147         case SYNCPOINT_STARTCODE:
 148         case INFO_STARTCODE:
 149         case INDEX_STARTCODE:
 150             return state;
 151         }
 152     }
 153
 154     return 0;
 155 }
 156
 157 /**
 158  * find the given startcode.
 159  * @param code the startcode
 160  * @param pos the start position of the search, or -1 if the current position
 161  * @returns the position of the startcode or -1 if not found
 162  */
 163 static int64_t find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){
 164     for(;;){
 165         uint64_t startcode= find_any_startcode(bc, pos);
 166         if(startcode == code)
 167             return url_ftell(bc) - 8;
 168         else if(startcode == 0)
 169             return -1;
 170         pos=-1;
 171     }
 172 }
 173
 174 static int64_t lsb2full(StreamContext *stream, int64_t lsb){
 175     int64_t mask = (1<<stream->msb_pts_shift)-1;
 176     int64_t delta= stream->last_pts - mask/2;
 177     return  ((lsb - delta)&mask) + delta;
 178 }
 179
 180 static int nut_probe(AVProbeData *p){
 181     int i;
 182     uint64_t code= 0;
 183
 184     for (i = 0; i < p->buf_size; i++) {
 185         code = (code << 8) | p->buf[i];
 186         if (code == MAIN_STARTCODE)
 187             return AVPROBE_SCORE_MAX;
 188     }
 189     return 0;
 190 }
 191
 192 #define GET_V(dst, check) \
 193     tmp= get_v(bc);\
 194     if(!(check)){\
 195         av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp);\
 196         return -1;\
 197     }\
 198     dst= tmp;
 199
 200 static int skip_reserved(ByteIOContext *bc, int64_t pos){
 201     pos -= url_ftell(bc);
 202 av_log(NULL, AV_LOG_ERROR, "skip %d\n", (int)pos);
 203     if(pos<0){
 204         url_fseek(bc, pos, SEEK_CUR);
 205         return -1;
 206     }else{
 207         while(pos--)
 208             get_byte(bc);
 209         return 0;
 210     }
 211 }
 212
 213 static int decode_main_header(NUTContext *nut){
 214     AVFormatContext *s= nut->avf;
 215     ByteIOContext *bc = &s->pb;
 216     uint64_t tmp, end;
 217     unsigned int stream_count;
 218     int i, j, tmp_stream, tmp_mul, tmp_pts, tmp_size, count, tmp_res;
 219
 220     end= get_packetheader(nut, bc, 1);
 221     end += url_ftell(bc) - 4;
 222
 223     GET_V(tmp              , tmp >=2 && tmp <= 3)
 224     GET_V(stream_count     , tmp > 0 && tmp <=MAX_STREAMS)
 225
 226     nut->max_distance = get_v(bc);
 227     if(nut->max_distance > 65536){
 228         av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance);
 229         nut->max_distance= 65536;
 230     }
 231
 232     GET_V(nut->time_base_count, tmp>0 && tmp<INT_MAX / sizeof(AVRational))
 233     nut->time_base= av_malloc(nut->time_base_count * sizeof(AVRational));
 234
 235     for(i=0; i<nut->time_base_count; i++){
 236         GET_V(nut->time_base[i].num, tmp>0 && tmp<(1ULL<<31))
 237         GET_V(nut->time_base[i].den, tmp>0 && tmp<(1ULL<<31))
 238         if(ff_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1){
 239             av_log(s, AV_LOG_ERROR, "time base invalid\n");
 240             return -1;
 241         }
 242     }
 243     tmp_pts=0;
 244     tmp_mul=1;
 245     tmp_stream=0;
 246     for(i=0; i<256;){
 247         int tmp_flags = get_v(bc);
 248         int tmp_fields= get_v(bc);
 249         if(tmp_fields>0) tmp_pts   = get_s(bc);
 250         if(tmp_fields>1) tmp_mul   = get_v(bc);
 251         if(tmp_fields>2) tmp_stream= get_v(bc);
 252         if(tmp_fields>3) tmp_size  = get_v(bc);
 253         else             tmp_size  = 0;
 254         if(tmp_fields>4) tmp_res   = get_v(bc);
 255         else             tmp_res   = 0;
 256         if(tmp_fields>5) count     = get_v(bc);
 257         else             count     = tmp_mul - tmp_size;
 258
 259         while(tmp_fields-- > 6)
 260            get_v(bc);
 261
 262         if(count == 0 || i+count > 256){
 263             av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);
 264             return -1;
 265         }
 266         if(tmp_stream >= stream_count){
 267             av_log(s, AV_LOG_ERROR, "illegal stream number\n");
 268             return -1;
 269         }
 270
 271         for(j=0; j<count; j++,i++){
 272             if (i == 'N') {
 273                 nut->frame_code[i].flags= FLAG_INVALID;
 274                 j--;
 275                 continue;
 276             }
 277             nut->frame_code[i].flags           = tmp_flags ;
 278             nut->frame_code[i].pts_delta       = tmp_pts   ;
 279             nut->frame_code[i].stream_id       = tmp_stream;
 280             nut->frame_code[i].size_mul        = tmp_mul   ;
 281             nut->frame_code[i].size_lsb        = tmp_size+j;
 282             nut->frame_code[i].reserved_count  = tmp_res   ;
 283         }
 284     }
 285     assert(nut->frame_code['N'].flags == FLAG_INVALID);
 286
 287     if(skip_reserved(bc, end) || check_checksum(bc)){
 288         av_log(s, AV_LOG_ERROR, "Main header checksum mismatch\n");
 289         return -1;
 290     }
 291
 292     nut->stream = av_mallocz(sizeof(StreamContext)*stream_count);
 293     for(i=0; i<stream_count; i++){
 294         av_new_stream(s, i);
 295     }
 296
 297     return 0;
 298 }
 299
 300 static int decode_stream_header(NUTContext *nut){
 301     AVFormatContext *s= nut->avf;
 302     ByteIOContext *bc = &s->pb;
 303     StreamContext *stc;
 304     int class, nom, denom, stream_id;
 305     uint64_t tmp, end;
 306     AVStream *st;
 307
 308     end= get_packetheader(nut, bc, 1);
 309     end += url_ftell(bc) - 4;
 310
 311     GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base.num);
 312     stc= &nut->stream[stream_id];
 313
 314     st = s->streams[stream_id];
 315     if (!st)
 316         return AVERROR_NOMEM;
 317
 318     class = get_v(bc);
 319     tmp = get_fourcc(bc);
 320     st->codec->codec_tag= tmp;
 321     switch(class)
 322     {
 323         case 0:
 324             st->codec->codec_type = CODEC_TYPE_VIDEO;
 325             st->codec->codec_id = codec_get_bmp_id(tmp);
 326             if (st->codec->codec_id == CODEC_ID_NONE)
 327                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
 328             break;
 329         case 1:
 330             st->codec->codec_type = CODEC_TYPE_AUDIO;
 331             st->codec->codec_id = codec_get_wav_id(tmp);
 332             if (st->codec->codec_id == CODEC_ID_NONE)
 333                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
 334             break;
 335         case 2:
 336 //            st->codec->codec_type = CODEC_TYPE_TEXT;
 337 //            break;
 338         case 3:
 339             st->codec->codec_type = CODEC_TYPE_DATA;
 340             break;
 341         default:
 342             av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class);
 343             return -1;
 344     }
 345     GET_V(stc->time_base_id    , tmp < nut->time_base_count);
 346     GET_V(stc->msb_pts_shift   , tmp < 16);
 347     stc->max_pts_distance= get_v(bc);
 348     GET_V(stc->decode_delay    , tmp < 1000); //sanity limit, raise this if moors law is true
 349     st->codec->has_b_frames= stc->decode_delay;
 350     get_v(bc); //stream flags
 351
 352     GET_V(st->codec->extradata_size, tmp < (1<<30));
 353     if(st->codec->extradata_size){
 354         st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 355         get_buffer(bc, st->codec->extradata, st->codec->extradata_size);
 356     }
 357
 358     if (st->codec->codec_type == CODEC_TYPE_VIDEO){
 359         GET_V(st->codec->width , tmp > 0)
 360         GET_V(st->codec->height, tmp > 0)
 361         st->codec->sample_aspect_ratio.num= get_v(bc);
 362         st->codec->sample_aspect_ratio.den= get_v(bc);
 363         if((!st->codec->sample_aspect_ratio.num) != (!st->codec->sample_aspect_ratio.den)){
 364             av_log(s, AV_LOG_ERROR, "invalid aspect ratio\n");
 365             return -1;
 366         }
 367         get_v(bc); /* csp type */
 368     }else if (st->codec->codec_type == CODEC_TYPE_AUDIO){
 369         GET_V(st->codec->sample_rate , tmp > 0)
 370         tmp= get_v(bc); // samplerate_den
 371         if(tmp > st->codec->sample_rate){
 372             av_log(s, AV_LOG_ERROR, "bleh, libnut muxed this ;)\n");
 373             st->codec->sample_rate= tmp;
 374         }
 375         GET_V(st->codec->channels, tmp > 0)
 376     }
 377     if(skip_reserved(bc, end) || check_checksum(bc)){
 378         av_log(s, AV_LOG_ERROR, "Stream header %d checksum mismatch\n", stream_id);
 379         return -1;
 380     }
 381     stc->time_base= nut->time_base[stc->time_base_id];
 382     av_set_pts_info(s->streams[stream_id], 63, stc->time_base.num, stc->time_base.den);
 383     return 0;
 384 }
 385
 386 static int decode_info_header(NUTContext *nut){
 387     AVFormatContext *s= nut->avf;
 388     ByteIOContext *bc = &s->pb;
 389     uint64_t tmp;
 390     unsigned int stream_id_plus1, chapter_start, chapter_len, count;
 391     int chapter_id, i;
 392     int64_t value, end;
 393     char name[256], str_value[1024], type_str[256], *type= type_str;
 394
 395     end= get_packetheader(nut, bc, 1);
 396     end += url_ftell(bc) - 4;
 397
 398     GET_V(stream_id_plus1, tmp <= s->nb_streams)
 399     chapter_id   = get_s(bc);
 400     chapter_start= get_v(bc);
 401     chapter_len  = get_v(bc);
 402     count        = get_v(bc);
 403     for(i=0; i<count; i++){
 404         get_str(bc, name, sizeof(name));
 405         value= get_s(bc);
 406         if(value == -1){
 407             type= "UTF-8";
 408             get_str(bc, str_value, sizeof(str_value));
 409         }else if(value == -2){
 410             get_str(bc, type, sizeof(type));
 411             get_str(bc, str_value, sizeof(str_value));
 412         }else if(value == -3){
 413             type= "s";
 414             value= get_s(bc);
 415         }else if(value == -4){
 416             type= "t";
 417             value= get_v(bc);
 418         }else if(value < -4){
 419             type= "r";
 420             get_s(bc);
 421         }else{
 422             type= "v";
 423         }
 424
 425         if(chapter_id==0 && !strcmp(type, "UTF-8")){
 426             if     (!strcmp(name, "Author"))
 427                 pstrcpy(s->author   , sizeof(s->author)   , str_value);
 428             else if(!strcmp(name, "Title"))
 429                 pstrcpy(s->title    , sizeof(s->title)    , str_value);
 430             else if(!strcmp(name, "Copyright"))
 431                 pstrcpy(s->copyright, sizeof(s->copyright), str_value);
 432             else if(!strcmp(name, "Description"))
 433                 pstrcpy(s->comment  , sizeof(s->comment)  , str_value);
 434         }
 435     }
 436
 437     if(skip_reserved(bc, end) || check_checksum(bc)){
 438         av_log(s, AV_LOG_ERROR, "Info header checksum mismatch\n");
 439         return -1;
 440     }
 441     return 0;
 442 }
 443
 444 static int decode_syncpoint(NUTContext *nut){
 445     AVFormatContext *s= nut->avf;
 446     ByteIOContext *bc = &s->pb;
 447     int64_t end;
 448     uint64_t tmp;
 449     int i;
 450     AVRational time_base;
 451
 452     nut->last_syncpoint_pos= url_ftell(bc)-8;
 453
 454     end= get_packetheader(nut, bc, 1);
 455     end += url_ftell(bc) - 4;
 456
 457     tmp= get_v(bc);
 458     get_v(bc); //back_ptr_div16
 459
 460     time_base= nut->time_base[tmp % nut->time_base_count];
 461     for(i=0; i<s->nb_streams; i++){
 462         nut->stream[i].last_pts= av_rescale_rnd(
 463             tmp / nut->time_base_count,
 464             time_base.num * (int64_t)nut->stream[i].time_base.den,
 465             time_base.den * (int64_t)nut->stream[i].time_base.num,
 466             AV_ROUND_DOWN);
 467         //last_key_frame ?
 468     }
 469     //FIXME put this in a reset func maybe
 470
 471     if(skip_reserved(bc, end) || check_checksum(bc)){
 472         av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n");
 473         return -1;
 474     }
 475     return 0;
 476 }
 477
 478 static int find_and_decode_index(NUTContext *nut){
 479     AVFormatContext *s= nut->avf;
 480     ByteIOContext *bc = &s->pb;
 481     uint64_t tmp, end;
 482     int i, j, syncpoint_count;
 483     int64_t filesize= url_fsize(bc);
 484     int64_t *syncpoints;
 485     int8_t *has_keyframe;
 486
 487     url_fseek(bc, filesize-12, SEEK_SET);
 488     url_fseek(bc, filesize-get_be64(bc), SEEK_SET);
 489     if(get_be64(bc) != INDEX_STARTCODE){
 490         av_log(s, AV_LOG_ERROR, "no index at the end\n");
 491         return -1;
 492     }
 493
 494     end= get_packetheader(nut, bc, 1);
 495     end += url_ftell(bc) - 4;
 496
 497     get_v(bc); //max_pts
 498     GET_V(syncpoint_count, tmp < INT_MAX/8 && tmp > 0)
 499     syncpoints= av_malloc(sizeof(int64_t)*syncpoint_count);
 500     has_keyframe= av_malloc(sizeof(int8_t)*(syncpoint_count+1));
 501     for(i=0; i<syncpoint_count; i++){
 502         GET_V(syncpoints[i], tmp>0)
 503         if(i)
 504             syncpoints[i] += syncpoints[i-1];
 505     }
 506
 507     for(i=0; i<s->nb_streams; i++){
 508         int64_t last_pts= -1;
 509         for(j=0; j<syncpoint_count;){
 510             uint64_t x= get_v(bc);
 511             int type= x&1;
 512             int n= j;
 513             x>>=1;
 514             if(type){
 515                 int flag= x&1;
 516                 x>>=1;
 517                 if(n+x >= syncpoint_count + 1){
 518                     av_log(s, AV_LOG_ERROR, "index overflow A\n");
 519                     return -1;
 520                 }
 521                 while(x--)
 522                     has_keyframe[n++]= flag;
 523                 has_keyframe[n++]= !flag;
 524             }else{
 525                 while(x != 1){
 526                     if(n>=syncpoint_count + 1){
 527                         av_log(s, AV_LOG_ERROR, "index overflow B\n");
 528                         return -1;
 529                     }
 530                     has_keyframe[n++]= x&1;
 531                     x>>=1;
 532                 }
 533             }
 534             if(has_keyframe[0]){
 535                 av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");
 536                 return -1;
 537             }
 538             assert(n<=syncpoint_count+1);
 539             for(; j<n; j++){
 540                 if(has_keyframe[j]){
 541                     uint64_t B, A= get_v(bc);
 542                     if(!A){
 543                         A= get_v(bc);
 544                         B= get_v(bc);
 545                         //eor_pts[j][i] = last_pts + A + B
 546                     }else
 547                         B= 0;
 548                     av_add_index_entry(
 549                         s->streams[i],
 550                         16*syncpoints[j-1],
 551                         last_pts + A,
 552                         0,
 553                         0,
 554                         AVINDEX_KEYFRAME);
 555                     last_pts += A + B;
 556                 }
 557             }
 558         }
 559     }
 560
 561     if(skip_reserved(bc, end) || check_checksum(bc)){
 562         av_log(s, AV_LOG_ERROR, "Index checksum mismatch\n");
 563         return -1;
 564     }
 565     return 0;
 566 }
 567
 568 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
 569 {
 570     NUTContext *nut = s->priv_data;
 571     ByteIOContext *bc = &s->pb;
 572     int64_t pos;
 573     int inited_stream_count;
 574
 575     nut->avf= s;
 576
 577     /* main header */
 578     pos=0;
 579     do{
 580         pos= find_startcode(bc, MAIN_STARTCODE, pos)+1;
 581         if (pos<0+1){
 582             av_log(s, AV_LOG_ERROR, "no main startcode found\n");
 583             return -1;
 584         }
 585     }while(decode_main_header(nut) < 0);
 586
 587     /* stream headers */
 588     pos=0;
 589     for(inited_stream_count=0; inited_stream_count < s->nb_streams;){
 590         pos= find_startcode(bc, STREAM_STARTCODE, pos)+1;
 591         if (pos<0+1){
 592             av_log(s, AV_LOG_ERROR, "not all stream headers found\n");
 593             return -1;
 594         }
 595         if(decode_stream_header(nut) >= 0)
 596             inited_stream_count++;
 597     }
 598
 599     /* info headers */
 600     pos=0;
 601     for(;;){
 602         uint64_t startcode= find_any_startcode(bc, pos);
 603         pos= url_ftell(bc);
 604
 605         if(startcode==0){
 606             av_log(s, AV_LOG_ERROR, "EOF before video frames\n");
 607             return -1;
 608         }else if(startcode == SYNCPOINT_STARTCODE){
 609             nut->next_startcode= startcode;
 610             break;
 611         }else if(startcode != INFO_STARTCODE){
 612             continue;
 613         }
 614
 615         decode_info_header(nut);
 616     }
 617
 618     s->data_offset= pos-8;
 619
 620     if(0 &&!url_is_streamed(bc)){
 621         int64_t orig_pos= url_ftell(bc);
 622         find_and_decode_index(nut);
 623         url_fseek(bc, orig_pos, SEEK_SET);
 624     }
 625     assert(nut->next_startcode == SYNCPOINT_STARTCODE);
 626
 627     return 0;
 628 }
 629
 630 static int decode_frame_header(NUTContext *nut, int *flags_ret, int64_t *pts, int *stream_id, int frame_code){
 631     AVFormatContext *s= nut->avf;
 632     ByteIOContext *bc = &s->pb;
 633     StreamContext *stc;
 634     int size, flags, size_mul, pts_delta, i, reserved_count;
 635     uint64_t tmp;
 636
 637     if(url_ftell(bc) > nut->last_syncpoint_pos + nut->max_distance){
 638         av_log(s, AV_LOG_ERROR, "last frame must have been damaged %Ld > %Ld + %d\n", url_ftell(bc), nut->last_syncpoint_pos, nut->max_distance);
 639         return -1;
 640     }
 641
 642     flags          = nut->frame_code[frame_code].flags;
 643     size_mul       = nut->frame_code[frame_code].size_mul;
 644     size           = nut->frame_code[frame_code].size_lsb;
 645     *stream_id     = nut->frame_code[frame_code].stream_id;
 646     pts_delta      = nut->frame_code[frame_code].pts_delta;
 647     reserved_count = nut->frame_code[frame_code].reserved_count;
 648
 649     if(flags & FLAG_INVALID)
 650         return -1;
 651     if(flags & FLAG_CODED)
 652         flags ^= get_v(bc);
 653     if(flags & FLAG_STREAM_ID){
 654         GET_V(*stream_id, tmp < s->nb_streams)
 655     }
 656     stc= &nut->stream[*stream_id];
 657     if(flags&FLAG_CODED_PTS){
 658         int coded_pts= get_v(bc);
 659 //FIXME check last_pts validity?
 660         if(coded_pts < (1<<stc->msb_pts_shift)){
 661             *pts=lsb2full(stc, coded_pts);
 662         }else
 663             *pts=coded_pts - (1<<stc->msb_pts_shift);
 664     }else
 665         *pts= stc->last_pts + pts_delta;
 666     if(flags&FLAG_SIZE_MSB){
 667         size += size_mul*get_v(bc);
 668     }
 669     if(flags&FLAG_RESERVED)
 670         reserved_count= get_v(bc);
 671     for(i=0; i<reserved_count; i++)
 672         get_v(bc);
 673     if(flags&FLAG_CHECKSUM){
 674         get_be32(bc); //FIXME check this
 675     }
 676     *flags_ret= flags;
 677
 678     stc->last_pts= *pts;
 679     stc->last_key_frame= flags&FLAG_KEY; //FIXME change to last flags
 680
 681     if(flags&FLAG_KEY){
 682         av_add_index_entry(
 683             s->streams[*stream_id],
 684             nut->last_syncpoint_pos,
 685             *pts,
 686             0,
 687             0,
 688             AVINDEX_KEYFRAME);
 689     }
 690
 691     return size;
 692 }
 693
 694 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code){
 695     AVFormatContext *s= nut->avf;
 696     ByteIOContext *bc = &s->pb;
 697     int size, stream_id, flags, discard;
 698     int64_t pts, last_IP_pts;
 699
 700     size= decode_frame_header(nut, &flags, &pts, &stream_id, frame_code);
 701     if(size < 0)
 702         return -1;
 703
 704     discard= s->streams[ stream_id ]->discard;
 705     last_IP_pts= s->streams[ stream_id ]->last_IP_pts;
 706     if(  (discard >= AVDISCARD_NONKEY && !(flags & FLAG_KEY))
 707        ||(discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE && last_IP_pts > pts)
 708        || discard >= AVDISCARD_ALL){
 709         url_fskip(bc, size);
 710         return 1;
 711     }
 712
 713     av_get_packet(bc, pkt, size);
 714     pkt->stream_index = stream_id;
 715     if (flags & FLAG_KEY)
 716         pkt->flags |= PKT_FLAG_KEY;
 717     pkt->pts = pts;
 718
 719     return 0;
 720 }
 721
 722 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
 723 {
 724     NUTContext *nut = s->priv_data;
 725     ByteIOContext *bc = &s->pb;
 726     int i, frame_code=0, ret, skip;
 727
 728     for(;;){
 729         int64_t pos= url_ftell(bc);
 730         uint64_t tmp= nut->next_startcode;
 731         nut->next_startcode=0;
 732
 733         if (url_feof(bc))
 734             return -1;
 735
 736         if(tmp){
 737             pos-=8;
 738         }else{
 739             frame_code = get_byte(bc);
 740             if(frame_code == 'N'){
 741                 tmp= frame_code;
 742                 for(i=1; i<8; i++)
 743                     tmp = (tmp<<8) + get_byte(bc);
 744             }
 745         }
 746         switch(tmp){
 747         case MAIN_STARTCODE:
 748         case STREAM_STARTCODE:
 749         case INDEX_STARTCODE:
 750             skip= get_packetheader(nut, bc, 0);
 751             url_fseek(bc, skip, SEEK_CUR);
 752             break;
 753         case INFO_STARTCODE:
 754             if(decode_info_header(nut)<0)
 755                 goto resync;
 756             break;
 757         case SYNCPOINT_STARTCODE:
 758             if(decode_syncpoint(nut)<0)
 759                 goto resync;
 760             frame_code = get_byte(bc);
 761         case 0:
 762             ret= decode_frame(nut, pkt, frame_code);
 763             if(ret==0)
 764                 return 0;
 765             else if(ret==1) //ok but discard packet
 766                 break;
 767         default:
 768 resync:
 769 av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);
 770             tmp= find_any_startcode(bc, pos+1);
 771             if(tmp==0)
 772                 return -1;
 773 av_log(s, AV_LOG_DEBUG, "sync\n");
 774             nut->next_startcode= tmp;
 775         }
 776     }
 777 }
 778
 779 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit){
 780     NUTContext *nut = s->priv_data;
 781     ByteIOContext *bc = &s->pb;
 782     int64_t pos, pts;
 783     int frame_code, stream_id,size, flags;
 784 av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n", stream_index, *pos_arg, pos_limit);
 785
 786     pos= *pos_arg;
 787 resync:
 788     do{
 789         pos= find_startcode(bc, SYNCPOINT_STARTCODE, pos)+1;
 790         if(pos < 1){
 791             assert(nut->next_startcode == 0);
 792             av_log(s, AV_LOG_ERROR, "read_timestamp failed\n");
 793             return AV_NOPTS_VALUE;
 794         }
 795     }while(decode_syncpoint(nut) < 0);
 796     *pos_arg = pos-1;
 797     assert(nut->last_syncpoint_pos == *pos_arg);
 798
 799     do{
 800         frame_code= get_byte(bc);
 801         if(frame_code == 'N'){
 802             pos= url_ftell(bc)-1;
 803             goto resync;
 804         }
 805         //FIXME consider pos_limit and eof
 806         size= decode_frame_header(nut, &flags, &pts, &stream_id, frame_code);
 807
 808         if(size < 0)
 809             goto resync;
 810
 811         url_fseek(bc, size, SEEK_CUR);
 812     }while(stream_id != stream_index || !(flags & FLAG_KEY));
 813     assert(nut->next_startcode == 0);
 814     av_log(s, AV_LOG_DEBUG, "read_timestamp success\n");
 815
 816     return pts;
 817 }
 818
 819 static int nut_read_close(AVFormatContext *s)
 820 {
 821     NUTContext *nut = s->priv_data;
 822
 823     av_freep(&nut->time_base);
 824     av_freep(&nut->stream);
 825
 826     return 0;
 827 }
 828
 829 #ifdef CONFIG_NUT_DEMUXER
 830 AVInputFormat nut_demuxer = {
 831     "nut",
 832     "nut format",
 833     sizeof(NUTContext),
 834     nut_probe,
 835     nut_read_header,
 836     nut_read_packet,
 837     nut_read_close,
 838     NULL,
 839     nut_read_timestamp,
 840     .extensions = "nut",
 841 };
 842 #endif