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