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.
3234 Commits
32 Branches
388MB
Tree: 21f52609dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '21f52609dd'
${ noResults }
FFmpeg/libavformat/nut.c

1272 lines
36KB
Raw Blame History 

  1. /*

  2.  * "NUT" Container Format muxer and demuxer (DRAFT-200403??)

  3.  * Copyright (c) 2003 Alex Beregszaszi

  4.  * Copyright (c) 2004 Michael Niedermayer

  5.  *

  6.  * This library is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2 of the License, or (at your option) any later version.

  10.  *

  11.  * This library is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU General Public

  17.  * License along with this library; if not, write to the Free Software

  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  19.  *

  20.  * NUT DRAFT can be found in MPlayer CVS at DOCS/tech/mpcf.txt

  21.  *

  22.  * AND http://people.fsn.hu/~alex/nut/ (TeX, pdf, ps, dvi, ..)

  23.  *

  24.  */

  25. 

  26. /*

  27.  * TODO:

  28.  * - seeking

  29.  * - index writing

  30.  * - index packet reading support

  31. */

  32. 

  33. //#define DEBUG 1

  34. 

  35. #include <limits.h>

  36. #include "avformat.h"

  37. #include "mpegaudio.h"

  38. #include "avi.h"

  39. 

  40. #undef NDEBUG

  41. #include <assert.h>

  42. 

  43. //from /dev/random

  44. 

  45. #define     MAIN_STARTCODE (0x7A561F5F04ADULL + (((uint64_t)('N'<<8) + 'M')<<48)) 

  46. #define   STREAM_STARTCODE (0x11405BF2F9DBULL + (((uint64_t)('N'<<8) + 'S')<<48)) 

  47. #define KEYFRAME_STARTCODE (0xE4ADEECA4569ULL + (((uint64_t)('N'<<8) + 'K')<<48)) 

  48. #define    INDEX_STARTCODE (0xDD672F23E64EULL + (((uint64_t)('N'<<8) + 'X')<<48)) 

  49. #define     INFO_STARTCODE (0xAB68B596BA78ULL + (((uint64_t)('N'<<8) + 'I')<<48)) 

  50. 

  51. #define MAX_TYPE1_DISTANCE (1024*16-1)

  52. #define MAX_TYPE2_DISTANCE (1024*64-1)

  53. 

  54. #define MAX_SIZE_LRU 2

  55. #define MAX_PTS_LRU 3

  56. 

  57. #define FLAG_FRAME_TYPE      1

  58. #define FLAG_DATA_SIZE       2

  59. #define FLAG_PTS            16

  60. #define FLAG_FULL_PTS        4

  61. #define FLAG_KEY_FRAME      32

  62. #define FLAG_PRED_KEY_FRAME 64

  63. 

  64. typedef struct {

  65.     uint8_t flags;

  66.     uint8_t stream_id_plus1;

  67.     uint8_t size_mul;

  68.     uint8_t size_lsb;

  69. } FrameCode;

  70. 

  71. typedef struct {

  72.     int last_key_frame;

  73.     int msb_timestamp_shift;

  74.     int rate_num;

  75.     int rate_den;

  76.     int64_t last_pts;

  77.     int64_t last_full_pts;

  78.     int lru_pts_delta[MAX_PTS_LRU];

  79.     int lru_size[MAX_SIZE_LRU];

  80.     int initial_pts_predictor[MAX_PTS_LRU];

  81.     int initial_size_predictor[MAX_SIZE_LRU];

  82. } StreamContext;

  83. 

  84. typedef struct {

  85.     AVFormatContext *avf;

  86.     int64_t packet_start;

  87.     int64_t last_packet_start;

  88.     int written_packet_size;

  89.     int64_t packet_size_pos;

  90.     int64_t last_frame_start[3];

  91.     FrameCode frame_code[256];

  92.     int stream_count;

  93.     uint64_t next_startcode;     ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable

  94.     StreamContext *stream;

  95. } NUTContext;

  96. 

  97. static char *info_table[][2]={

  98. 	{NULL			,  NULL }, // end

  99. 	{NULL			,  NULL },

  100. 	{NULL			, "UTF8"},

  101. 	{NULL			, "v"},

  102. 	{NULL			, "s"},

  103. 	{"StreamId"		, "v"},

  104. 	{"SegmentId"		, "v"},

  105. 	{"StartTimestamp"	, "v"},

  106. 	{"EndTimestamp"		, "v"},

  107. 	{"Author"		, "UTF8"},

  108. 	{"Title"		, "UTF8"},

  109. 	{"Description"		, "UTF8"},

  110. 	{"Copyright"		, "UTF8"},

  111. 	{"Encoder"		, "UTF8"},

  112. 	{"Keyword"		, "UTF8"},

  113. 	{"Cover"		, "JPEG"},

  114. 	{"Cover"		, "PNG"},

  115. };

  116. 

  117. static void update_lru(int *lru, int current, int count){

  118.     int i;

  119. 

  120.     for(i=0; i<count-1; i++){

  121.         if(lru[i] == current)

  122.             break;

  123.     }

  124. 

  125.     for(; i; i--){

  126.         lru[i]= lru[i-1];

  127.     }

  128. 

  129.     lru[0]= current;

  130. }

  131. 

  132. static void update(NUTContext *nut, int stream_index, int64_t frame_start, int frame_type, int frame_code, int key_frame, int size, int64_t pts){

  133.     StreamContext *stream= &nut->stream[stream_index];

  134.     const int flags=nut->frame_code[frame_code].flags; 

  135.     

  136.     stream->last_key_frame= key_frame;

  137.     nut->last_frame_start[ frame_type ]= frame_start;

  138.     if(frame_type == 0)

  139.         update_lru(stream->lru_pts_delta, pts - stream->last_pts, 3);

  140.     update_lru(stream->lru_size, size, 2);

  141.     stream->last_pts= pts;

  142.     if((flags & FLAG_PTS) && (flags & FLAG_FULL_PTS))

  143.         stream->last_full_pts= pts;

  144. }

  145. 

  146. static void reset(AVFormatContext *s/*, int frame_type*/){

  147.     NUTContext *nut = s->priv_data;

  148.     int i;

  149.     

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

  151.         StreamContext *stream= &nut->stream[i];

  152.     

  153.         stream->last_key_frame= 1;

  154.         memcpy(stream->lru_pts_delta, stream->initial_pts_predictor, sizeof(int)*MAX_PTS_LRU);

  155.         memcpy(stream->lru_size, stream->initial_size_predictor, sizeof(int)*MAX_SIZE_LRU);

  156.     }

  157. }

  158. 

  159. static void build_frame_code(AVFormatContext *s){

  160.     NUTContext *nut = s->priv_data;

  161.     int key_frame, frame_type, full_pts, index, pred, stream_id;

  162.     int start=0;

  163.     int end= 255;

  164.     int keyframe_0_esc= s->nb_streams > 2;

  165. 

  166.     if(keyframe_0_esc){

  167.         /* keyframe = 0 escapes, 3 codes */

  168.         for(frame_type=0; frame_type<2; frame_type++){

  169.             for(full_pts=frame_type; full_pts<2; full_pts++){

  170.                 FrameCode *ft= &nut->frame_code[start];

  171.                 ft->flags= FLAG_FRAME_TYPE*frame_type + FLAG_FULL_PTS*full_pts;

  172.                 ft->flags|= FLAG_DATA_SIZE | FLAG_PTS; 

  173.                 ft->stream_id_plus1= 0;

  174.                 ft->size_mul=1;

  175.                 start++;

  176.             }

  177.         }

  178.     }

  179. 

  180.     for(stream_id= 0; stream_id<s->nb_streams; stream_id++){

  181.         int start2= start + (end-start)*stream_id / s->nb_streams;

  182.         int end2  = start + (end-start)*(stream_id+1) / s->nb_streams;

  183.         AVCodecContext *codec = &s->streams[stream_id]->codec;

  184.         int is_audio= codec->codec_type == CODEC_TYPE_AUDIO;

  185.         int intra_only= /*codec->intra_only || */is_audio;

  186.         int pred_count;

  187. 

  188.         for(key_frame=0; key_frame<2; key_frame++){

  189.             if(intra_only && keyframe_0_esc && key_frame==0)

  190.                 continue;

  191.             

  192.             for(frame_type=0; frame_type<2; frame_type++){

  193.                 for(full_pts=frame_type; full_pts<2; full_pts++){

  194.                     FrameCode *ft= &nut->frame_code[start2];

  195.                     ft->flags= FLAG_FRAME_TYPE*frame_type + FLAG_FULL_PTS*full_pts + FLAG_KEY_FRAME*key_frame;

  196.                     ft->flags|= FLAG_DATA_SIZE | FLAG_PTS;

  197.                     ft->stream_id_plus1= stream_id + 1;

  198.                     ft->size_mul=1;

  199.                     start2++;

  200.                 }

  201.             }

  202.         }

  203. 

  204.         key_frame= intra_only;

  205. #if 1

  206.         if(is_audio){

  207.             int frame_bytes= codec->frame_size*(int64_t)codec->bit_rate / (8*codec->sample_rate);

  208.             for(pred=0; pred<MAX_SIZE_LRU; pred++){

  209.                 for(frame_type=0; frame_type<1; frame_type++){

  210.                     FrameCode *ft= &nut->frame_code[start2];

  211.                     ft->flags= FLAG_KEY_FRAME*key_frame + (FLAG_FULL_PTS+FLAG_PTS+FLAG_FRAME_TYPE)*frame_type;

  212.                     ft->stream_id_plus1= stream_id + 1;

  213.                     ft->size_mul=1;

  214.                     ft->size_lsb=1 + pred;

  215.                     start2++;

  216.                 }

  217.                 nut->stream[stream_id].initial_size_predictor[pred]= frame_bytes + pred;

  218.             }

  219.         }else{

  220.             FrameCode *ft= &nut->frame_code[start2];

  221.             ft->flags= FLAG_KEY_FRAME | FLAG_DATA_SIZE;

  222.             ft->stream_id_plus1= stream_id + 1;

  223.             ft->size_mul=1;

  224.             start2++;

  225.         }

  226. #endif

  227.         pred_count= 2 + codec->has_b_frames + (codec->codec_id == CODEC_ID_VORBIS);

  228.         for(pred=0; pred<pred_count; pred++){

  229.             int start3= start2 + (end2-start2)*pred / pred_count;

  230.             int end3  = start2 + (end2-start2)*(pred+1) / pred_count;

  231. 

  232.             for(index=start3; index<end3; index++){

  233.                 FrameCode *ft= &nut->frame_code[index];

  234.                 ft->flags= FLAG_KEY_FRAME*key_frame + pred*4;

  235.                 ft->flags|= FLAG_DATA_SIZE;

  236.                 ft->stream_id_plus1= stream_id + 1;

  237. //FIXME use single byte size and pred from last

  238.                 ft->size_mul= end3-start3;

  239.                 ft->size_lsb= index - start3;

  240.             }

  241.             nut->stream[stream_id].initial_pts_predictor[pred]= pred+1;

  242.         }

  243.     }

  244.     memmove(&nut->frame_code['N'+1], &nut->frame_code['N'], sizeof(FrameCode)*(255-'N'));

  245.     nut->frame_code['N'].flags= 1;

  246. }

  247. 

  248. static uint64_t get_v(ByteIOContext *bc)

  249. {

  250.     uint64_t val = 0;

  251. 

  252.     for(;;)

  253.     {

  254. 	int tmp = get_byte(bc);

  255. 

  256. 	if (tmp&0x80)

  257. 	    val= (val<<7) + tmp - 0x80;

  258. 	else

  259. 	    return (val<<7) + tmp;

  260.     }

  261.     return -1;

  262. }

  263. 

  264. static int get_str(ByteIOContext *bc, char *string, int maxlen){

  265.     int len= get_v(bc);

  266.     

  267.     if(len && maxlen)

  268.         get_buffer(bc, string, FFMIN(len, maxlen));

  269.     while(len > maxlen){

  270.         get_byte(bc);

  271.         len--;

  272.     }

  273. 

  274.     if(maxlen)

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

  276.     

  277.     if(maxlen == len)

  278.         return -1;

  279.     else

  280.         return 0;

  281. }

  282. 

  283. static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int prefix_length, int calculate_checksum)

  284. {

  285.     int64_t start, size, last_size;

  286.     start= url_ftell(bc) - prefix_length;

  287. 

  288.     if(start != nut->packet_start + nut->written_packet_size){

  289.         av_log(nut->avf, AV_LOG_ERROR, "get_packetheader called at weird position\n");

  290.         if(prefix_length<8)

  291.             return -1;

  292.     }

  293.     

  294.     init_checksum(bc, calculate_checksum ? update_adler32 : NULL, 0);

  295. 

  296.     size= get_v(bc);

  297.     last_size= get_v(bc);

  298.     if(nut->written_packet_size != last_size){

  299.         av_log(nut->avf, AV_LOG_ERROR, "packet size missmatch %d != %lld at %lld\n", nut->written_packet_size, last_size, start);

  300.         if(prefix_length<8)

  301.             return -1;

  302.     }

  303. 

  304.     nut->last_packet_start = nut->packet_start;

  305.     nut->packet_start = start;

  306.     nut->written_packet_size= size;

  307. 

  308.     return size;

  309. }

  310. 

  311. static int check_checksum(ByteIOContext *bc){

  312.     unsigned long checksum= get_checksum(bc);

  313.     return checksum != get_be32(bc);

  314. }

  315. 

  316. /**

  317.  * 

  318.  */

  319. static int get_length(uint64_t val){

  320.     int i;

  321. 

  322.     for (i=7; ; i+=7)

  323. 	if ((val>>i) == 0)

  324. 	    return i;

  325. 

  326.     return 7; //not reached

  327. }

  328. 

  329. static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){

  330.     uint64_t state=0;

  331.     

  332.     if(pos >= 0)

  333.         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

  334. 

  335.     while(!url_feof(bc)){

  336.         state= (state<<8) | get_byte(bc);

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

  338.             continue;

  339.         switch(state){

  340.         case MAIN_STARTCODE:

  341.         case STREAM_STARTCODE:

  342.         case KEYFRAME_STARTCODE:

  343.         case INFO_STARTCODE:

  344.         case INDEX_STARTCODE:

  345.             return state;

  346.         }

  347.     }

  348.     av_log(NULL, AV_LOG_DEBUG, "searched until %lld\n", url_ftell(bc));

  349.     return 0;

  350. }

  351. 

  352. static int find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){

  353.     for(;;){

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

  355.         if(startcode == code)

  356.             return 0;

  357.         else if(startcode == 0)

  358.             return -1;

  359.         pos=-1;

  360.     }

  361. }

  362. 

  363. #ifdef CONFIG_ENCODERS

  364. static int put_v(ByteIOContext *bc, uint64_t val)

  365. {

  366.     int i;

  367. 

  368.     val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently

  369.     i= get_length(val);

  370. 

  371.     for (i-=7; i>0; i-=7){

  372. 	put_byte(bc, 0x80 | (val>>i));

  373.     }

  374. 

  375.     put_byte(bc, val&0x7f);

  376. 

  377.     return 0;

  378. }

  379. 

  380. static int put_str(ByteIOContext *bc, const char *string){

  381.     int len= strlen(string);

  382.     

  383.     put_v(bc, len);

  384.     put_buffer(bc, string, len);

  385.     

  386.     return 0;

  387. }

  388. 

  389. static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int max_size, int calculate_checksum)

  390. {

  391.     put_flush_packet(bc);

  392.     nut->last_packet_start= nut->packet_start;

  393.     nut->packet_start+= nut->written_packet_size;

  394.     nut->packet_size_pos = url_ftell(bc);

  395.     nut->written_packet_size = max_size;

  396.     

  397.     if(calculate_checksum)

  398.         init_checksum(bc, update_adler32, 0);

  399. 

  400.     /* packet header */

  401.     put_v(bc, nut->written_packet_size); /* forward ptr */

  402.     put_v(bc, nut->packet_start - nut->last_packet_start); /* backward ptr */

  403. 

  404.     return 0;

  405. }

  406. 

  407. static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size, int calculate_checksum){

  408.     int64_t start= nut->packet_start;

  409.     int64_t cur= url_ftell(bc);

  410.     int size= cur - start + additional_size;

  411.     

  412.     if(calculate_checksum)

  413.         size += 4;

  414.     

  415.     if(size != nut->written_packet_size){

  416.         int i;

  417. 

  418.         assert( size <= nut->written_packet_size );

  419.     

  420.         url_fseek(bc, nut->packet_size_pos, SEEK_SET);

  421.         for(i=get_length(size); i < get_length(nut->written_packet_size); i+=7)

  422.             put_byte(bc, 0x80);

  423.         put_v(bc, size);

  424. 

  425.         url_fseek(bc, cur, SEEK_SET);

  426.         nut->written_packet_size= size; //FIXME may fail if multiple updates with differing sizes, as get_length may differ

  427.         

  428.         if(calculate_checksum)

  429.             put_be32(bc, get_checksum(bc));

  430.     }

  431.     

  432.     return 0;

  433. }

  434. 

  435. static int nut_write_header(AVFormatContext *s)

  436. {

  437.     NUTContext *nut = s->priv_data;

  438.     ByteIOContext *bc = &s->pb;

  439.     AVCodecContext *codec;

  440.     int i, j;

  441. 

  442.     nut->avf= s;

  443.     

  444.     nut->stream =	

  445. 	av_mallocz(sizeof(StreamContext)*s->nb_streams);

  446.     

  447.     av_set_pts_info(s, 60, 1, AV_TIME_BASE);

  448.     

  449.     /* main header */

  450.     put_be64(bc, MAIN_STARTCODE);

  451.     put_packetheader(nut, bc, 120+5*256, 1);

  452.     put_v(bc, 1); /* version */

  453.     put_v(bc, s->nb_streams);

  454.     put_v(bc, 3);

  455.     

  456.     build_frame_code(s);

  457.     assert(nut->frame_code['N'].flags == 1);

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

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

  460.         int tmp_stream= nut->frame_code[i].stream_id_plus1;

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

  462.         int tmp_size  = nut->frame_code[i].size_lsb;

  463.         put_v(bc, tmp_flags);

  464.         put_v(bc, tmp_stream);

  465.         put_v(bc, tmp_mul);

  466.         put_v(bc, tmp_size);

  467. 

  468.         for(j=0; i<256; j++,i++){

  469.             if(nut->frame_code[i].flags           != tmp_flags ) break;

  470.             if(nut->frame_code[i].stream_id_plus1 != tmp_stream) break;

  471.             if(nut->frame_code[i].size_mul        != tmp_mul   ) break;

  472.             if(nut->frame_code[i].size_lsb        != tmp_size  ) break;

  473.             if(++tmp_size >= tmp_mul){

  474.                 tmp_size=0;

  475.                 tmp_stream++;

  476.             }

  477.         }

  478.         put_v(bc, j);

  479.     }

  480. 

  481.     update_packetheader(nut, bc, 0, 1);

  482.     

  483.     /* stream headers */

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

  485.     {

  486. 	int nom, denom, gcd;

  487. 

  488. 	codec = &s->streams[i]->codec;

  489. 	

  490. 	put_be64(bc, STREAM_STARTCODE);

  491. 	put_packetheader(nut, bc, 120 + codec->extradata_size, 1);

  492. 	put_v(bc, i /*s->streams[i]->index*/);

  493. 	put_v(bc, (codec->codec_type == CODEC_TYPE_AUDIO) ? 32 : 0);

  494. 	if (codec->codec_tag)

  495. 	    put_v(bc, codec->codec_tag);

  496. 	else if (codec->codec_type == CODEC_TYPE_VIDEO)

  497. 	{

  498. 	    put_v(bc, codec_get_bmp_tag(codec->codec_id));

  499. 	}

  500. 	else if (codec->codec_type == CODEC_TYPE_AUDIO)

  501. 	{

  502. 	    put_v(bc, codec_get_wav_tag(codec->codec_id));

  503. 	}

  504.         else

  505.             put_v(bc, 0);

  506. 

  507. 	if (codec->codec_type == CODEC_TYPE_VIDEO)

  508. 	{

  509. 	    nom = codec->frame_rate;

  510. 	    denom = codec->frame_rate_base;

  511. 	}

  512. 	else

  513. 	{

  514. 	    nom = codec->sample_rate;

  515.             if(codec->frame_size>0)

  516.                 denom= codec->frame_size;

  517.             else

  518.                 denom= 1; //unlucky

  519. 	}

  520.         gcd= ff_gcd(nom, denom);

  521.         nom   /= gcd;

  522.         denom /= gcd;

  523.         nut->stream[i].rate_num= nom;

  524.         nut->stream[i].rate_den= denom;

  525. 

  526. 	put_v(bc, codec->bit_rate);

  527. 	put_v(bc, 0); /* no language code */

  528. 	put_v(bc, nom);

  529. 	put_v(bc, denom);

  530.         if(nom / denom < 1000)

  531. 	    nut->stream[i].msb_timestamp_shift = 7;

  532.         else

  533. 	    nut->stream[i].msb_timestamp_shift = 14;

  534. 	put_v(bc, nut->stream[i].msb_timestamp_shift);

  535. 	for(j=0; j<3; j++)

  536. 		put_v(bc, nut->stream[i].initial_pts_predictor[j]);

  537. 	for(j=0; j<2; j++)

  538. 		put_v(bc, nut->stream[i].initial_size_predictor[j]);

  539. 	put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */

  540. 	

  541.         if(codec->extradata_size){

  542.             put_v(bc, 1);

  543.             put_v(bc, codec->extradata_size);

  544.             put_buffer(bc, codec->extradata, codec->extradata_size);            

  545.         }

  546. 	put_v(bc, 0); /* end of codec specific headers */

  547. 	

  548. 	switch(codec->codec_type)

  549. 	{

  550. 	    case CODEC_TYPE_AUDIO:

  551. 		put_v(bc, (codec->sample_rate * denom) / nom);

  552. 		put_v(bc, codec->channels);

  553. 		break;

  554. 	    case CODEC_TYPE_VIDEO:

  555. 		put_v(bc, codec->width);

  556. 		put_v(bc, codec->height);

  557. 		put_v(bc, codec->sample_aspect_ratio.num);

  558. 		put_v(bc, codec->sample_aspect_ratio.den);

  559. 		put_v(bc, 0); /* csp type -- unknown */

  560. 		break;

  561.             default:

  562.                 break;

  563. 	}

  564.         update_packetheader(nut, bc, 0, 1);

  565.     }

  566. 

  567.     /* info header */

  568.     put_be64(bc, INFO_STARTCODE);

  569.     put_packetheader(nut, bc, 30+strlen(s->author)+strlen(s->title)+

  570.         strlen(s->comment)+strlen(s->copyright)+strlen(LIBAVFORMAT_IDENT), 1); 

  571.     if (s->author[0])

  572.     {

  573.         put_v(bc, 9); /* type */

  574.         put_str(bc, s->author);

  575.     }

  576.     if (s->title[0])

  577.     {

  578.         put_v(bc, 10); /* type */

  579.         put_str(bc, s->title);

  580.     }

  581.     if (s->comment[0])

  582.     {

  583.         put_v(bc, 11); /* type */

  584.         put_str(bc, s->comment);

  585.     }

  586.     if (s->copyright[0])

  587.     {

  588.         put_v(bc, 12); /* type */

  589.         put_str(bc, s->copyright);

  590.     }

  591.     /* encoder */

  592.     put_v(bc, 13); /* type */

  593.     put_str(bc, LIBAVFORMAT_IDENT);

  594.     

  595.     put_v(bc, 0); /* eof info */

  596.     update_packetheader(nut, bc, 0, 1);

  597.         

  598.     put_flush_packet(bc);

  599.     

  600.     return 0;

  601. }

  602. 

  603. static int nut_write_packet(AVFormatContext *s, int stream_index, 

  604. 			    const uint8_t *buf, int size, int64_t pts)

  605. {

  606.     NUTContext *nut = s->priv_data;

  607.     StreamContext *stream= &nut->stream[stream_index];

  608.     ByteIOContext *bc = &s->pb;

  609.     int key_frame = 0, full_pts=0;

  610.     AVCodecContext *enc;

  611.     int64_t lsb_pts, delta_pts;

  612.     int frame_type, best_length, frame_code, flags, i, size_mul, size_lsb;

  613.     const int64_t frame_start= url_ftell(bc);

  614. 

  615.     if (stream_index > s->nb_streams)

  616. 	return 1;

  617.         

  618.     pts= (av_rescale(pts, stream->rate_num, stream->rate_den) + AV_TIME_BASE/2) / AV_TIME_BASE;

  619. 

  620.     enc = &s->streams[stream_index]->codec;

  621.     key_frame = enc->coded_frame->key_frame;

  622.     delta_pts= pts - stream->last_pts;

  623.     

  624.     frame_type=0;

  625.     if(frame_start + size + 20 - FFMAX(nut->last_frame_start[1], nut->last_frame_start[2]) > MAX_TYPE1_DISTANCE)

  626.         frame_type=1;

  627.     if(key_frame){

  628.         if(frame_type==1 && frame_start + size - nut->last_frame_start[2] > MAX_TYPE2_DISTANCE)

  629.             frame_type=2;

  630.         if(!stream->last_key_frame)

  631.             frame_type=2;

  632.     }

  633. 

  634.     if(frame_type>0){

  635.         update_packetheader(nut, bc, 0, 0);

  636.         reset(s);

  637.         full_pts=1;

  638.     }

  639.     //FIXME ensure that the timestamp can be represented by either delta or lsb or full_pts=1

  640. 

  641.     lsb_pts = pts & ((1 << stream->msb_timestamp_shift)-1);

  642. 

  643.     best_length=INT_MAX;

  644.     frame_code= -1;

  645.     for(i=0; i<256; i++){

  646.         int stream_id_plus1= nut->frame_code[i].stream_id_plus1;

  647.         int fc_key_frame= stream->last_key_frame;

  648.         int length=0;

  649.         size_mul= nut->frame_code[i].size_mul;

  650.         size_lsb= nut->frame_code[i].size_lsb;

  651.         flags= nut->frame_code[i].flags;

  652. 

  653.         if(stream_id_plus1 == 0) length+= get_length(stream_index);

  654.         else if(stream_id_plus1 - 1 != stream_index)

  655.             continue;

  656.         if(flags & FLAG_PRED_KEY_FRAME){

  657.             if(flags & FLAG_KEY_FRAME)

  658.                 fc_key_frame= !fc_key_frame;

  659.         }else{

  660.             fc_key_frame= !!(flags & FLAG_KEY_FRAME);

  661.         }

  662.         assert(key_frame==0 || key_frame==1);

  663.         if(fc_key_frame != key_frame)

  664.             continue;

  665. 

  666.         if((!!(flags & FLAG_FRAME_TYPE)) != (frame_type > 0))

  667.             continue;

  668.         

  669.         if(size_mul <= size_lsb){

  670.             int p= stream->lru_size[size_lsb - size_mul];

  671.             if(p != size)

  672.                 continue;

  673.         }else{

  674.             if(size % size_mul != size_lsb)

  675.                 continue;

  676.             if(flags & FLAG_DATA_SIZE)

  677.                 length += get_length(size / size_mul);

  678.             else if(size/size_mul)

  679.                 continue;

  680.         }

  681. 

  682.         if(full_pts != ((flags & FLAG_PTS) && (flags & FLAG_FULL_PTS)))

  683.             continue;

  684.             

  685.         if(flags&FLAG_PTS){

  686.             if(flags&FLAG_FULL_PTS){

  687.                 length += get_length(pts);

  688.             }else{

  689.                 length += get_length(lsb_pts);

  690.             }

  691.         }else{

  692.             int delta= stream->lru_pts_delta[(flags & 12)>>2];

  693.             if(delta != pts - stream->last_pts)

  694.                 continue;

  695.             assert(frame_type == 0);

  696.         }

  697. 

  698.         if(length < best_length){

  699.             best_length= length;

  700.             frame_code=i;

  701.         }

  702. //    av_log(s, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d %d %d\n", key_frame, frame_type, full_pts, size, stream_index, flags, size_mul, size_lsb, stream_id_plus1, length);

  703.     }

  704. 

  705.     assert(frame_code != -1);

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

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

  708.     size_lsb= nut->frame_code[frame_code].size_lsb;

  709. #if 0

  710.     best_length /= 7;

  711.     best_length ++; //frame_code

  712.     if(frame_type>0){

  713.         best_length += 4; //packet header

  714.         if(frame_type>1)

  715.             best_length += 8; // startcode

  716.     }

  717.     av_log(s, AV_LOG_DEBUG, "kf:%d ft:%d pt:%d fc:%2X len:%2d size:%d stream:%d flag:%d mul:%d lsb:%d s+1:%d pts_delta:%d\n", key_frame, frame_type, full_pts ? 2 : ((flags & FLAG_PTS) ? 1 : 0), frame_code, best_length, size, stream_index, flags, size_mul, size_lsb, nut->frame_code[frame_code].stream_id_plus1,(int)(pts - stream->last_pts));

  718. #endif

  719. 

  720.     if (frame_type==2)

  721. 	put_be64(bc, KEYFRAME_STARTCODE);

  722.     put_byte(bc, frame_code);

  723. 

  724.     if(frame_type>0)

  725.         put_packetheader(nut, bc, FFMAX(size+20, MAX_TYPE1_DISTANCE), 0);

  726.     if(nut->frame_code[frame_code].stream_id_plus1 == 0)

  727.         put_v(bc, stream_index);

  728.     if (flags & FLAG_PTS){

  729.         if (flags & FLAG_FULL_PTS)

  730.             put_v(bc, pts);

  731.         else

  732.             put_v(bc, lsb_pts);

  733.     }

  734.     if(flags & FLAG_DATA_SIZE)

  735.         put_v(bc, size / size_mul);

  736.     if(size > MAX_TYPE1_DISTANCE){

  737.         assert(frame_type > 0);

  738.         update_packetheader(nut, bc, size, 0);

  739.     }

  740.     

  741.     put_buffer(bc, buf, size);

  742. 

  743.     update(nut, stream_index, frame_start, frame_type, frame_code, key_frame, size, pts);

  744.     

  745.     return 0;

  746. }

  747. 

  748. static int nut_write_trailer(AVFormatContext *s)

  749. {

  750.     NUTContext *nut = s->priv_data;

  751.     ByteIOContext *bc = &s->pb;

  752. 

  753.     update_packetheader(nut, bc, 0, 0);

  754. 

  755. #if 0

  756.     int i;

  757. 

  758.     /* WRITE INDEX */

  759. 

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

  761.     {

  762. 	put_be64(bc, INDEX_STARTCODE);

  763. 	put_packetheader(nut, bc, 64, 1);

  764. 	put_v(bc, s->streams[i]->id);

  765. 	put_v(bc, ...);

  766.         update_packetheader(nut, bc, 0, 1);

  767.     }

  768. #endif

  769. 

  770.     put_flush_packet(bc);

  771.     

  772.     av_freep(&nut->stream);

  773. 

  774.     return 0;

  775. }

  776. #endif //CONFIG_ENCODERS

  777. 

  778. static int nut_probe(AVProbeData *p)

  779. {

  780.     int i;

  781.     uint64_t code;

  782. 

  783.     code = 0xff;

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

  785.         int c = p->buf[i];

  786.         code = (code << 8) | c;

  787.         if (code == MAIN_STARTCODE)

  788.             return AVPROBE_SCORE_MAX;

  789.     }

  790.     return 0;

  791. }

  792. 

  793. static int decode_main_header(NUTContext *nut){

  794.     AVFormatContext *s= nut->avf;

  795.     ByteIOContext *bc = &s->pb;

  796.     uint64_t tmp;

  797.     int i, j;

  798.     

  799.     get_packetheader(nut, bc, 8, 1);

  800. 

  801.     tmp = get_v(bc);

  802.     if (tmp != 1){

  803. 	av_log(s, AV_LOG_ERROR, "bad version (%Ld)\n", tmp);

  804.         return -1;

  805.     }

  806.     

  807.     nut->stream_count = get_v(bc);

  808.     get_v(bc); //checksum threshold

  809. 

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

  811.         int tmp_flags = get_v(bc);

  812.         int tmp_stream= get_v(bc);

  813.         int tmp_mul   = get_v(bc);

  814.         int tmp_size  = get_v(bc);

  815.         int count     = get_v(bc);

  816. 

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

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

  819.             return -1;

  820.         }

  821. 

  822.         if((tmp_flags & FLAG_FRAME_TYPE) && tmp_flags != 1){

  823.             if(tmp_flags & FLAG_PRED_KEY_FRAME){

  824.                 av_log(s, AV_LOG_ERROR, "keyframe prediction in non 0 frame type\n");

  825.                 return -1;

  826.             }

  827.             if(!(tmp_flags & FLAG_PTS) || !(tmp_flags & FLAG_FULL_PTS) ){

  828.                 av_log(s, AV_LOG_ERROR, "no full pts in non 0 frame type\n");

  829.                 return -1;

  830.             }

  831.         }

  832. 

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

  834.             if(tmp_stream > nut->stream_count + 1){

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

  836.                 return -1;

  837.             }

  838. 

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

  840.             nut->frame_code[i].stream_id_plus1 = tmp_stream;

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

  842.             nut->frame_code[i].size_lsb        = tmp_size  ;

  843.             if(++tmp_size >= tmp_mul){

  844.                 tmp_size=0;

  845.                 tmp_stream++;

  846.             }

  847.         }

  848.     }

  849.     if(nut->frame_code['N'].flags != 1){

  850.         av_log(s, AV_LOG_ERROR, "illegal frame_code table\n");

  851.         return -1;

  852.     }

  853. 

  854.     if(check_checksum(bc)){

  855.         av_log(s, AV_LOG_ERROR, "Main header checksum missmatch\n");

  856.         return -1;

  857.     }

  858. 

  859.     return 0;

  860. }

  861. 

  862. static int decode_stream_header(NUTContext *nut){

  863.     AVFormatContext *s= nut->avf;

  864.     ByteIOContext *bc = &s->pb;

  865.     int class, nom, denom, stream_id, i;

  866.     uint64_t tmp;

  867.     AVStream *st;

  868.     

  869.     get_packetheader(nut, bc, 8, 1);

  870.     stream_id= get_v(bc);

  871.     if(stream_id >= nut->stream_count || s->streams[stream_id])

  872.         return -1;

  873.     

  874.     st = av_new_stream(s, stream_id);

  875.     if (!st)

  876.         return AVERROR_NOMEM;

  877.     class = get_v(bc);

  878.     tmp = get_v(bc);

  879.     switch(class)

  880.     {

  881.         case 0:

  882.             st->codec.codec_type = CODEC_TYPE_VIDEO;

  883.             st->codec.codec_id = codec_get_bmp_id(tmp);

  884.             if (st->codec.codec_id == CODEC_ID_NONE)

  885.                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");

  886.             break;

  887.         case 32:

  888.             st->codec.codec_type = CODEC_TYPE_AUDIO;

  889.             st->codec.codec_id = codec_get_wav_id(tmp);

  890.             if (st->codec.codec_id == CODEC_ID_NONE)

  891.                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");

  892.             break;

  893.         default:

  894.             av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class);

  895.             return -1;

  896.     }

  897.     s->bit_rate += get_v(bc);

  898.     get_v(bc); /* language code */

  899.     nom = get_v(bc);

  900.     denom = get_v(bc);

  901.     nut->stream[stream_id].msb_timestamp_shift = get_v(bc);

  902.     for(i=0; i<3; i++)

  903.             nut->stream[stream_id].initial_pts_predictor[i]= get_v(bc);

  904.     for(i=0; i<2; i++)

  905.             nut->stream[stream_id].initial_size_predictor[i]= get_v(bc);

  906.     get_byte(bc); /* flags */

  907. 

  908.     /* codec specific data headers */

  909.     while(get_v(bc) != 0){

  910.         st->codec.extradata_size= get_v(bc);

  911.         st->codec.extradata= av_mallocz(st->codec.extradata_size);

  912.         get_buffer(bc, st->codec.extradata, st->codec.extradata_size);            

  913. //	    url_fskip(bc, get_v(bc));

  914.     }

  915.     

  916.     if (class == 0) /* VIDEO */

  917.     {

  918.         st->codec.width = get_v(bc);

  919.         st->codec.height = get_v(bc);

  920.         st->codec.sample_aspect_ratio.num= get_v(bc);

  921.         st->codec.sample_aspect_ratio.den= get_v(bc);

  922.         get_v(bc); /* csp type */

  923. 

  924.         st->codec.frame_rate = nom;

  925.         st->codec.frame_rate_base = denom;

  926.     }

  927.     if (class == 32) /* AUDIO */

  928.     {

  929.         st->codec.sample_rate = (get_v(bc) * nom) / denom;

  930.         st->codec.channels = get_v(bc);

  931.     }

  932.     if(check_checksum(bc)){

  933.         av_log(s, AV_LOG_ERROR, "Stream header %d checksum missmatch\n", stream_id);

  934.         return -1;

  935.     }

  936.     nut->stream[stream_id].rate_num= nom;

  937.     nut->stream[stream_id].rate_den= denom;

  938.     return 0;

  939. }

  940. 

  941. static int decode_info_header(NUTContext *nut){

  942.     AVFormatContext *s= nut->avf;

  943.     ByteIOContext *bc = &s->pb;

  944.     

  945.     get_packetheader(nut, bc, 8, 1);

  946. 

  947.     for(;;){

  948.         int id= get_v(bc);

  949.         char *name, *type, custom_name[256], custom_type[256];

  950. 

  951.         if(!id)

  952.             break;

  953.         else if(id >= sizeof(info_table)/sizeof(info_table[0])){

  954.             av_log(s, AV_LOG_ERROR, "info id is too large %d %d\n", id, sizeof(info_table)/sizeof(info_table[0]));

  955.             return -1;

  956.         }

  957. 

  958.         type= info_table[id][1];

  959.         name= info_table[id][0];

  960. //av_log(s, AV_LOG_DEBUG, "%d %s %s\n", id, type, name);

  961. 

  962.         if(!type){

  963.             get_str(bc, custom_type, sizeof(custom_type));

  964.             type= custom_type;

  965.         }

  966.         if(!name){

  967.             get_str(bc, custom_name, sizeof(custom_name));

  968.             name= custom_name;

  969.         }

  970.         

  971.         if(!strcmp(type, "v")){

  972.             int value= get_v(bc);

  973.         }else{

  974.             if(!strcmp(name, "Author"))

  975.                 get_str(bc, s->author, sizeof(s->author));

  976.             else if(!strcmp(name, "Title"))

  977.                 get_str(bc, s->title, sizeof(s->title));

  978.             else if(!strcmp(name, "Copyright"))

  979.                 get_str(bc, s->copyright, sizeof(s->copyright));

  980.             else if(!strcmp(name, "Description"))

  981.                 get_str(bc, s->comment, sizeof(s->comment));

  982.             else

  983.                 get_str(bc, NULL, 0);

  984.         }

  985.     }

  986.     if(check_checksum(bc)){

  987.         av_log(s, AV_LOG_ERROR, "Info header checksum missmatch\n");

  988.         return -1;

  989.     }

  990.     return 0;

  991. }

  992. 

  993. static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)

  994. {

  995.     NUTContext *nut = s->priv_data;

  996.     ByteIOContext *bc = &s->pb;

  997.     int64_t pos;

  998.     int inited_stream_count;

  999. 

  1000.     nut->avf= s;

  1001.     

  1002.     av_set_pts_info(s, 60, 1, AV_TIME_BASE);

  1003. 

  1004.     /* main header */

  1005.     pos=0;

  1006.     for(;;){

  1007.         if (find_startcode(bc, MAIN_STARTCODE, pos)<0){

  1008.             av_log(s, AV_LOG_ERROR, "no main startcode found\n");

  1009.             return -1;

  1010.         }

  1011.         pos= url_ftell(bc);

  1012.         if(decode_main_header(nut) >= 0)

  1013.             break;

  1014.     }

  1015.     

  1016.     

  1017.     s->bit_rate = 0;

  1018. 

  1019.     nut->stream = av_malloc(sizeof(StreamContext)*nut->stream_count);

  1020. 

  1021.     /* stream headers */

  1022.     pos=0;

  1023.     for(inited_stream_count=0; inited_stream_count < nut->stream_count;){

  1024.         if (find_startcode(bc, STREAM_STARTCODE, pos)<0){

  1025.             av_log(s, AV_LOG_ERROR, "not all stream headers found\n");

  1026.             return -1;

  1027.         }

  1028.         pos= url_ftell(bc);

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

  1030.             inited_stream_count++;

  1031.     }

  1032. 

  1033.     /* info headers */

  1034.     pos=0;

  1035.     for(;;){

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

  1037.         pos= url_ftell(bc);

  1038. 

  1039.         if(startcode==0){

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

  1041.             return -1;

  1042.         }else if(startcode == KEYFRAME_STARTCODE){

  1043.             nut->next_startcode= startcode;

  1044.             break;

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

  1046.             continue;

  1047.         }

  1048. 

  1049.         decode_info_header(nut);

  1050.     }

  1051. 

  1052.     return 0;

  1053. }

  1054. 

  1055. static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code, int frame_type){

  1056.     AVFormatContext *s= nut->avf;

  1057.     StreamContext *stream;

  1058.     ByteIOContext *bc = &s->pb;

  1059.     int size, flags, size_mul, size_lsb, stream_id;

  1060.     int key_frame = 0;

  1061.     int64_t pts = 0;

  1062.     const int prefix_len= frame_type == 2 ? 8+1 : 1;

  1063.     const int64_t frame_start= url_ftell(bc) + prefix_len;

  1064. 

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

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

  1067.     size_lsb= nut->frame_code[frame_code].size_lsb;

  1068.     stream_id= nut->frame_code[frame_code].stream_id_plus1 - 1;

  1069. 

  1070.     if(flags & FLAG_FRAME_TYPE){

  1071.         reset(s);

  1072.         if(get_packetheader(nut, bc, prefix_len, 0) < 0)

  1073.             return -1;

  1074.         if(frame_type!=2)

  1075.             frame_type= 1;

  1076.     }

  1077. 

  1078.     if(stream_id==-1)

  1079.         stream_id= get_v(bc);

  1080.     if(stream_id >= s->nb_streams){

  1081.         av_log(s, AV_LOG_ERROR, "illegal stream_id\n");

  1082.         return -1;

  1083.     }

  1084.     stream= &nut->stream[stream_id];

  1085. 

  1086. //    av_log(s, AV_LOG_DEBUG, "ft:%d ppts:%d %d %d\n", frame_type, stream->lru_pts_delta[0], stream->lru_pts_delta[1], stream->lru_pts_delta[2]);

  1087.     

  1088.     if(flags & FLAG_PRED_KEY_FRAME){

  1089.         if(flags & FLAG_KEY_FRAME)

  1090.             key_frame= !stream->last_key_frame;

  1091.         else

  1092.             key_frame= stream->last_key_frame;

  1093.     }else{

  1094.         key_frame= !!(flags & FLAG_KEY_FRAME);

  1095.     }

  1096. 

  1097.     if(flags & FLAG_PTS){

  1098.         if(flags & FLAG_FULL_PTS){

  1099.             pts= get_v(bc);

  1100.         }else{

  1101.             int64_t mask = (1<<stream->msb_timestamp_shift)-1;

  1102.             int64_t delta= stream->last_pts - mask/2;

  1103.             pts= ((get_v(bc) - delta)&mask) + delta;

  1104.         }

  1105.     }else{

  1106.         pts= stream->last_pts + stream->lru_pts_delta[(flags&12)>>2];

  1107.     }

  1108.   

  1109.     if(size_mul <= size_lsb){

  1110.         size= stream->lru_size[size_lsb - size_mul];

  1111.     }else{

  1112.         if(flags & FLAG_DATA_SIZE)

  1113.             size= size_mul*get_v(bc) + size_lsb;

  1114.         else

  1115.             size= size_lsb;

  1116.     }

  1117.       

  1118. //av_log(s, AV_LOG_DEBUG, "fs:%lld fc:%d ft:%d kf:%d pts:%lld size:%d\n", frame_start, frame_code, frame_type, key_frame, pts, size);

  1119. 

  1120.     if(url_ftell(bc) - nut->packet_start + size > nut->written_packet_size){

  1121.         av_log(s, AV_LOG_ERROR, "frame size too large\n");

  1122.         return -1;

  1123.     }

  1124.     

  1125.     av_new_packet(pkt, size);

  1126.     get_buffer(bc, pkt->data, size);

  1127.     pkt->stream_index = stream_id;

  1128.     if (key_frame)

  1129. 	pkt->flags |= PKT_FLAG_KEY;

  1130.     pkt->pts = pts * AV_TIME_BASE * stream->rate_den / stream->rate_num;

  1131. 

  1132.     update(nut, stream_id, frame_start, frame_type, frame_code, key_frame, size, pts);

  1133.     

  1134.     return 0;

  1135. }

  1136. 

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

  1138. {

  1139.     NUTContext *nut = s->priv_data;

  1140.     ByteIOContext *bc = &s->pb;

  1141.     int size, frame_code=0;

  1142.     int frame_type= 0;

  1143.     int64_t pos;

  1144. 

  1145.     for(;;){

  1146.         uint64_t tmp= nut->next_startcode;

  1147.         nut->next_startcode=0;

  1148. 

  1149.         if (url_feof(bc))

  1150.             return -1;

  1151. 

  1152.         if(!tmp){

  1153.             frame_code = get_byte(bc);

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

  1155.                 tmp= frame_code;

  1156.                 tmp<<=8 ; tmp |= get_byte(bc);

  1157.                 tmp<<=16; tmp |= get_be16(bc);

  1158.                 tmp<<=32; tmp |= get_be32(bc);

  1159.             }

  1160.         }

  1161.         switch(tmp){

  1162.         case KEYFRAME_STARTCODE:

  1163.             frame_type = 2;

  1164.             break;

  1165.         case MAIN_STARTCODE:

  1166.         case STREAM_STARTCODE:

  1167.         case INDEX_STARTCODE:

  1168.             get_packetheader(nut, bc, 8, 0);

  1169.             url_fseek(bc, nut->written_packet_size + nut->packet_start, SEEK_SET);

  1170.             break;

  1171.         case INFO_STARTCODE:

  1172.             if(decode_info_header(nut)<0)

  1173.                 goto resync;

  1174.             break;

  1175.         case 0:

  1176.             if(decode_frame(nut, pkt, frame_code, frame_type)>=0)

  1177.                 return 0;

  1178.         default:

  1179. resync:

  1180.             frame_type = 0;

  1181. av_log(s, AV_LOG_DEBUG, "syncing from %lld\n", nut->packet_start+1);

  1182.             tmp= find_any_startcode(bc, nut->packet_start+1);

  1183.             if(tmp==0)

  1184.                 return -1;

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

  1186.             if(url_is_streamed(bc)){

  1187.                 nut->next_startcode= tmp;

  1188.                 break;

  1189.             }

  1190. 

  1191.             pos= url_ftell(bc) - 8;

  1192. av_log(s, AV_LOG_DEBUG, "at %lld code=%llX\n", pos, tmp);

  1193.             if(tmp==KEYFRAME_STARTCODE){

  1194.                 get_byte(bc);

  1195.             }

  1196.             get_v(bc);

  1197.             size= get_v(bc);

  1198.             

  1199.             while(size > 2 && size < 100000 && nut->packet_start < pos - size){

  1200.                 url_fseek(bc, pos - size, SEEK_SET);

  1201.                 frame_code= get_byte(bc);

  1202.                 if(!(nut->frame_code[ frame_code ].flags & FLAG_FRAME_TYPE))

  1203.                     break;

  1204.                 if(get_v(bc) != size)

  1205.                     break;

  1206.                 pos -= size;

  1207.                 size= get_v(bc);

  1208. av_log(s, AV_LOG_DEBUG, "steping back to %lld next %d\n", pos, size);

  1209.             }

  1210.             url_fseek(bc, pos, SEEK_SET);

  1211.             

  1212.             nut->written_packet_size= size;

  1213.             nut->packet_start= pos - size;

  1214.         }

  1215.     }

  1216. }

  1217. 

  1218. static int nut_read_close(AVFormatContext *s)

  1219. {

  1220.     NUTContext *nut = s->priv_data;

  1221.     int i;

  1222. 

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

  1224.         av_freep(&s->streams[i]->codec.extradata);

  1225.     }

  1226.     av_freep(&nut->stream);

  1227. 

  1228.     return 0;

  1229. }

  1230. 

  1231. static AVInputFormat nut_iformat = {

  1232.     "nut",

  1233.     "nut format",

  1234.     sizeof(NUTContext),

  1235.     nut_probe,

  1236.     nut_read_header,

  1237.     nut_read_packet,

  1238.     nut_read_close,

  1239. //    nut_read_seek,

  1240.     .extensions = "nut",

  1241. };

  1242. 

  1243. #ifdef CONFIG_ENCODERS

  1244. static AVOutputFormat nut_oformat = {

  1245.     "nut",

  1246.     "nut format",

  1247.     "video/x-nut",

  1248.     "nut",

  1249.     sizeof(NUTContext),

  1250. #ifdef CONFIG_VORBIS

  1251.     CODEC_ID_VORBIS,

  1252. #elif defined(CONFIG_MP3LAME)

  1253.     CODEC_ID_MP3,

  1254. #else

  1255.     CODEC_ID_MP2, /* AC3 needs liba52 decoder */

  1256. #endif

  1257.     CODEC_ID_MPEG4,

  1258.     nut_write_header,

  1259.     nut_write_packet,

  1260.     nut_write_trailer,

  1261. };

  1262. #endif //CONFIG_ENCODERS

  1263. 

  1264. int nut_init(void)

  1265. {

  1266.     av_register_input_format(&nut_iformat);

  1267. #ifdef CONFIG_ENCODERS

  1268.     av_register_output_format(&nut_oformat);

  1269. #endif //CONFIG_ENCODERS

  1270.     return 0;

  1271. }