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

637 lines
15KB
Raw Blame History 

  1. /*

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

  3.  * Copyright (c) 2003 Alex Beregszaszi

  4.  *

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

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

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

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

  9.  *

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

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

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

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

  18.  *

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

  20.  *

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

  22.  *

  23.  */

  24. 

  25. /*

  26.  * TODO:

  27.  * - checksumming

  28.  * - optimal timestamp handling

  29.  * - index writing

  30.  * - info and index packet reading support

  31.  * - startcode searching for broken streams

  32.  * - subpacket support

  33. */

  34. 

  35. //#define DEBUG 1

  36. 

  37. #include "avformat.h"

  38. #include "mpegaudio.h"

  39. #include "avi.h"

  40. 

  41. //from /dev/random

  42. 

  43. #define     MAIN_STARTCODE (0xF9526A6200000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'M')

  44. #define   STREAM_STARTCODE (0xD667773F00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'S')

  45. #define KEYFRAME_STARTCODE (0xCB86308700000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'K')

  46. #define    INDEX_STARTCODE (0xEBFCDE0E00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'X')

  47. #define     INFO_STARTCODE (0xA37B643500000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'I')

  48. 

  49. typedef struct {

  50.     int curr_frame_start;

  51.     int last_frame_size;

  52.     int curr_frame_size;

  53.     int *msb_timestamp_shift;

  54.     int64_t *last_msb_timestamp;

  55. } NUTContext;

  56. 

  57. static int bytes_left(ByteIOContext *bc)

  58. {

  59.     return bc->buf_end - bc->buf_ptr;

  60. }

  61. 

  62. static uint64_t get_v(ByteIOContext *bc)

  63. {

  64.     uint64_t val = 0;

  65. 

  66.     for(; bytes_left(bc) > 0; )

  67.     {

  68. 	int tmp = get_byte(bc);

  69. 

  70. 	if (tmp&0x80)

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

  72. 	else

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

  74.     }

  75.     return -1;

  76. }

  77. 

  78. static int64_t get_s(ByteIOContext *bc)

  79. {

  80.     int64_t v = get_v(bc) + 1;

  81. 

  82.     if (v&1)

  83.         return -(v>>1);

  84.     else

  85.         return (v>>1);

  86. }

  87. 

  88. static int get_b(ByteIOContext *bc, char *data, int maxlen)

  89. {

  90.     int i, len;

  91.     

  92.     len = get_v(bc);

  93.     for (i = 0; i < len && i < maxlen; i++)

  94. 	data[i] = get_byte(bc);

  95.     /* skip remaining bytes */

  96.     url_fskip(bc, len-i);

  97. 

  98.     return 0;

  99. }

  100. 

  101. static int get_bi(ByteIOContext *bc)

  102. {

  103.    int i, len, val = 0;

  104.     

  105.     len = get_v(bc);

  106.     for (i = 0; i < len && i <= 4; i++)

  107.         val |= get_byte(bc) << (i * 8);

  108.     /* skip remaining bytes */

  109.     url_fskip(bc, len-i);

  110. 

  111.     return val;

  112. }

  113. 

  114. static int get_packetheader(NUTContext *nut, ByteIOContext *bc)

  115. {

  116.     nut->curr_frame_start = url_ftell(bc);

  117.     nut->curr_frame_size = get_v(bc);

  118.     nut->last_frame_size = get_v(bc);

  119.     dprintf("Packet: fwd: %d bwd: %d\n",

  120. 	nut->curr_frame_size, nut->last_frame_size);

  121.     

  122.     return 0;

  123. }

  124. 

  125. /**

  126.  * 

  127.  */

  128. static int get_length(uint64_t val){

  129.     int i;

  130. 

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

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

  133. 	    return i;

  134. 

  135.     return 7; //not reached

  136. }

  137. 

  138. #ifdef CONFIG_ENCODERS

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

  140. {

  141.     int i;

  142. 

  143. //    if (bytes_left(s)*8 < 9)

  144. //	return -1;

  145. 

  146.     if (bytes_left(bc) < 1)

  147. 	return -1;

  148. 

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

  150.     i= get_length(val);

  151. 

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

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

  154.     }

  155. 

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

  157. 

  158.     return 0;

  159. }

  160. 

  161. static int put_s(ByteIOContext *bc, uint64_t val)

  162. {

  163.     if (val<=0)

  164. 	return put_v(bc, -2*val);

  165.     else

  166. 	return put_v(bc, 2*val-1);

  167. }

  168. 

  169. static int put_b(ByteIOContext *bc, char *data, int len)

  170. {

  171.     int i;

  172.     

  173.     put_v(bc, len);

  174.     for (i = 0; i < len; i++)

  175. 	put_byte(bc, data[i]);

  176. 

  177.     return 0;

  178. }

  179. 

  180. static int put_bi(ByteIOContext *bc, int val)

  181. {

  182.     put_v(bc, 4);

  183.     put_le32(bc, val);

  184.     return 0;

  185. }

  186. 

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

  188. {

  189.     put_flush_packet(bc);

  190.     nut->curr_frame_start = url_ftell(bc);

  191.     nut->curr_frame_size = max_size;

  192.     

  193.     /* packet header */

  194.     put_v(bc, nut->curr_frame_size); /* forward ptr */

  195.     put_v(bc, nut->last_frame_size); /* backward ptr */

  196.     dprintf("Packet: fwd: %d, bwd: %d\n",

  197. 	nut->curr_frame_size, nut->last_frame_size);

  198. 

  199.     nut->last_frame_size = nut->curr_frame_size;

  200.     

  201.     return 0;

  202. }

  203. 

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

  205.     offset_t start= nut->curr_frame_start;

  206.     offset_t cur= url_ftell(bc);

  207.     int size= cur - start + additional_size;

  208.     

  209.     assert( size <= nut->curr_frame_size );

  210.     

  211.     url_fseek(bc, start, SEEK_SET);

  212.     put_v(bc, size);

  213.     if(get_length(size) < get_length(nut->curr_frame_size))

  214.         put_byte(bc, 0x80);

  215.     nut->curr_frame_size= size;

  216.     dprintf("Packet update: size: %d\n", size);

  217. 

  218.     url_fseek(bc, cur, SEEK_SET);    

  219.     

  220.     return 0;

  221. }

  222. 

  223. static int nut_write_header(AVFormatContext *s)

  224. {

  225.     NUTContext *nut = s->priv_data;

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

  227.     AVCodecContext *codec;

  228.     int i;

  229. 

  230.     /* main header */

  231.     put_be64(bc, MAIN_STARTCODE);

  232.     put_packetheader(nut, bc, 120);

  233.     put_v(bc, 0); /* version */

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

  235.     put_be32(bc, 0); /* FIXME: checksum */

  236.     

  237.     update_packetheader(nut, bc, 0);

  238.     

  239.     nut->msb_timestamp_shift =	

  240. 	av_mallocz(sizeof(nut->msb_timestamp_shift)*s->nb_streams);

  241.     nut->last_msb_timestamp =

  242. 	av_mallocz(sizeof(nut->last_msb_timestamp)*s->nb_streams);

  243.     

  244.     /* stream headers */

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

  246.     {

  247. 	int nom, denom;

  248. 

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

  250. 	

  251. 	put_be64(bc, STREAM_STARTCODE);

  252. 	put_packetheader(nut, bc, 120);

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

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

  255. 	if (codec->codec_tag)

  256. 	    put_bi(bc, codec->codec_tag);

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

  258. 	{

  259. 	    int tmp = codec_get_bmp_tag(codec->codec_id);

  260. 	    put_bi(bc, tmp);

  261. 	}

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

  263. 	{

  264. 	    int tmp = codec_get_wav_tag(codec->codec_id);

  265. 	    put_bi(bc, tmp);

  266. 	}

  267. 

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

  269. 	{

  270. 	    nom = codec->frame_rate;

  271. 	    denom = codec->frame_rate_base;

  272. 	}

  273. 	else

  274. 	{

  275. 	    nom = codec->sample_rate/8;

  276. 	    denom = 8;

  277. 	}

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

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

  280. 	put_v(bc, nom);

  281. 	put_v(bc, denom);

  282. 	nut->msb_timestamp_shift[i] = 0;

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

  284. 	put_v(bc, 0); /* shuffle type */

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

  286. 	

  287. 	put_v(bc, 0); /* no codec specific headers */

  288. 	

  289. 	switch(codec->codec_type)

  290. 	{

  291. 	    case CODEC_TYPE_AUDIO:

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

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

  294. 		put_be32(bc, 0); /* FIXME: checksum */

  295. 		break;

  296. 	    case CODEC_TYPE_VIDEO:

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

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

  299. 		put_v(bc, 0); /* aspected w */

  300. 		put_v(bc, 0); /* aspected h */

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

  302. 		put_be32(bc, 0); /* FIXME: checksum */

  303. 		break;

  304.             default:

  305.                 break;

  306. 	}

  307.         update_packetheader(nut, bc, 0);

  308.     }

  309. 

  310. #if 0

  311.     /* info header */

  312.     put_be64(bc, INFO_STARTCODE);

  313.     put_packetheader(nut, bc, 16+strlen(s->author)+strlen(s->title)+

  314.         strlen(s->comment)+strlen(s->copyright)); 

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

  316.     {

  317.         put_v(bc, 5); /* type */

  318.         put_b(bc, s->author, strlen(s->author));

  319.     }

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

  321.     {

  322.         put_v(bc, 6); /* type */

  323.         put_b(bc, s->title, strlen(s->title));

  324.     }

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

  326.     {

  327.         put_v(bc, 7); /* type */

  328.         put_b(bc, s->comment, strlen(s->comment));

  329.     }

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

  331.     {

  332.         put_v(bc, 8); /* type */

  333.         put_b(bc, s->copyright, strlen(s->copyright));

  334.     }

  335.     /* encoder */

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

  337.     put_b(bc, LIBAVFORMAT_IDENT "\0", strlen(LIBAVFORMAT_IDENT));

  338.     

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

  340. 

  341.     put_be32(bc, 0); /* FIXME: checksum */

  342.     update_packetheader(nut, bc, 0);

  343. #endif

  344.         

  345.     put_flush_packet(bc);

  346.     

  347.     return 0;

  348. }

  349. 

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

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

  352. {

  353.     NUTContext *nut = s->priv_data;

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

  355.     int key_frame = 0, flags, msb_pts = 0;

  356.     AVCodecContext *enc;

  357.     int64_t lsb_pts;

  358. 

  359.     if (stream_index > s->nb_streams)

  360. 	return 1;

  361. 

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

  363.     // FIXME, lavc reports always keyframes for audio, which will make

  364.     // _huge_ overhead

  365.     if (enc->codec_type == CODEC_TYPE_VIDEO)

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

  367. 

  368.     if (key_frame /*||

  369. 	((pts - (nut->last_msb_timestamp[stream_index] <<

  370. 	nut->msb_timestamp_shift[stream_index])) > 1024)*/)

  371.     {

  372. 	msb_pts = 1;

  373. 	nut->last_msb_timestamp[stream_index] = pts >> nut->msb_timestamp_shift[stream_index];

  374.     }

  375. 

  376.     lsb_pts = pts - (nut->last_msb_timestamp[stream_index] << nut->msb_timestamp_shift[stream_index]);

  377.     

  378.     flags=0;

  379.     flags<<=2; flags|=1; //priority

  380.     flags<<=1; flags|=0; //checksum

  381.     flags<<=1; flags|=msb_pts; //msb_timestamp_flag

  382.     flags<<=2; flags|=1; //subpacket_type

  383.     flags<<=1; flags|=0; //reserved

  384. 

  385.     if (key_frame)

  386. 	put_be64(bc, KEYFRAME_STARTCODE);

  387.     put_byte(bc, flags);

  388. 

  389.     put_packetheader(nut, bc, size+20);

  390.     put_v(bc, stream_index);

  391.     if (msb_pts)

  392. 	put_v(bc, nut->last_msb_timestamp[stream_index]);

  393.     put_v(bc, lsb_pts); /* lsb_timestamp */

  394.     update_packetheader(nut, bc, size);

  395.     

  396.     put_buffer(bc, buf, size);

  397.     

  398.     put_flush_packet(bc);

  399. 

  400.     return 0;

  401. }

  402. 

  403. static int nut_write_trailer(AVFormatContext *s)

  404. {

  405.     NUTContext *nut = s->priv_data;

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

  407. #if 0

  408.     int i;

  409. 

  410.     /* WRITE INDEX */

  411. 

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

  413.     {

  414. 	put_be64(bc, INDEX_STARTCODE);

  415. 	put_packetheader(nut, bc, 64);

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

  417. 	put_v(bc, ...);

  418. 	put_be32(bc, 0); /* FIXME: checksum */

  419.         update_packetheader(nut, bc, 0);

  420.     }

  421. #endif

  422. 

  423.     put_flush_packet(bc);

  424.     

  425.     if (nut->last_msb_timestamp)

  426. 	av_free(nut->last_msb_timestamp);

  427.     if (nut->msb_timestamp_shift)

  428. 	av_free(nut->msb_timestamp_shift);

  429. 

  430.     return 0;

  431. }

  432. #endif //CONFIG_ENCODERS

  433. 

  434. static int nut_probe(AVProbeData *p)

  435. {

  436.     int i;

  437.     uint64_t code;

  438. 

  439.     code = 0xff;

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

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

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

  443.         if (code == MAIN_STARTCODE)

  444.             return AVPROBE_SCORE_MAX;

  445.     }

  446.     return 0;

  447. }

  448. 

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

  450. {

  451.     NUTContext *nut = s->priv_data;

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

  453.     uint64_t tmp;

  454.     int cur_stream, nb_streams;

  455.     

  456.     /* main header */

  457.     tmp = get_be64(bc);

  458.     if (tmp != MAIN_STARTCODE)

  459. 	fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);

  460.     get_packetheader(nut, bc);

  461.     

  462.     tmp = get_v(bc);

  463.     if (tmp != 0)

  464. 	fprintf(stderr, "bad version (%Ld)\n", tmp);

  465.     

  466.     nb_streams = get_v(bc);

  467.     get_be32(bc); /* checkusm */

  468.     

  469.     s->bit_rate = 0;

  470. 

  471.     nut->msb_timestamp_shift =	

  472. 	av_malloc(sizeof(nut->msb_timestamp_shift)*s->nb_streams);

  473.     nut->last_msb_timestamp =

  474. 	av_malloc(sizeof(nut->last_msb_timestamp)*s->nb_streams);

  475.     

  476.     /* stream header */

  477.     for (cur_stream = 0; cur_stream < nb_streams; cur_stream++)

  478.     {

  479. 	int class, nom, denom;

  480. 	AVStream *st;

  481. 	

  482. 	tmp = get_be64(bc);

  483. 	if (tmp != STREAM_STARTCODE)

  484. 	    fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);

  485. 	get_packetheader(nut, bc);

  486. 	st = av_new_stream(s, get_v(bc));

  487. 	if (!st)

  488. 	    return AVERROR_NOMEM;

  489. 	class = get_v(bc);

  490. 	tmp = get_bi(bc);

  491. 	switch(class)

  492. 	{

  493. 	    case 0:

  494. 		st->codec.codec_type = CODEC_TYPE_VIDEO;

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

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

  497. 		    fprintf(stderr, "Unknown codec?!\n");

  498. 		break;

  499. 	    case 32:

  500. 		st->codec.codec_type = CODEC_TYPE_AUDIO;

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

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

  503. 		    fprintf(stderr, "Unknown codec?!\n");

  504. 		break;

  505. 	    default:

  506. 		fprintf(stderr, "Unknown stream class (%d)\n", class);

  507. 		return -1;

  508. 	}

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

  510. 	get_b(bc, NULL, 0); /* language code */

  511. 	nom = get_v(bc);

  512. 	denom = get_v(bc);

  513. 	nut->msb_timestamp_shift[cur_stream] = get_v(bc);

  514. 	get_v(bc); /* shuffle type */

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

  516. 

  517. 	/* codec specific data headers */

  518. 	while(get_v(bc) != 0)

  519. 	    url_fskip(bc, get_v(bc));

  520. 	

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

  522. 	{

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

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

  525. 	    get_v(bc); /* aspected w */

  526. 	    get_v(bc); /* aspected h */

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

  528. 	    get_be32(bc); /* checksum */

  529. 

  530. 	    st->codec.frame_rate = nom;

  531. 	    st->codec.frame_rate_base = denom;

  532. 	}

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

  534. 	{

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

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

  537. 	    get_be32(bc); /* checksum */

  538. 	}

  539.     }    

  540.     

  541.     return 0;

  542. }

  543. 

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

  545. {

  546.     NUTContext *nut = s->priv_data;

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

  548.     int id, size;

  549.     int key_frame = 0;

  550.     uint64_t tmp;

  551.     int64_t pts = 0;

  552. 

  553.     if (url_feof(bc))

  554. 	return -1;

  555.     

  556.     tmp = get_byte(bc);

  557.     if (tmp & 0x80) /* zero bit set? */

  558.     {

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

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

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

  562. 	if (tmp == KEYFRAME_STARTCODE)

  563. 	{

  564. 	    key_frame = 1;

  565. 	    tmp = get_byte(bc); /* flags */

  566. 	}

  567. 	else

  568. 	    fprintf(stderr, "error in zero bit / startcode %LX\n", tmp);

  569.     }

  570.     get_packetheader(nut, bc);

  571. #if 0

  572.     if (((tmp & 0x60)>>5) > 3) /* priority <= 3 */

  573. 	fprintf(stderr, "sanity check failed!\n");

  574. #endif

  575.     id = get_v(bc);

  576.     if ((tmp & 0x8) >> 3)

  577. 	pts = get_v(bc) << nut->msb_timestamp_shift[id];

  578.     pts += get_v(bc);

  579.     

  580.     size = (nut->curr_frame_size - (url_ftell(bc)-nut->curr_frame_start));

  581.     dprintf("flags: 0x%llx, timestamp: %llx, packet size: %d\n", tmp, pts, size);

  582.     

  583.     if (size < 0)

  584. 	return -1;

  585. 

  586.     av_new_packet(pkt, size);

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

  588.     pkt->stream_index = id;

  589.     if (key_frame)

  590. 	pkt->flags |= PKT_FLAG_KEY;

  591.     pkt->pts = pts;

  592. 

  593.     return 0;

  594. }

  595. 

  596. static AVInputFormat nut_iformat = {

  597.     "nut",

  598.     "nut format",

  599.     sizeof(NUTContext),

  600.     nut_probe,

  601.     nut_read_header,

  602.     nut_read_packet,

  603. //    nut_read_close,

  604. //    nut_read_seek,

  605.     .extensions = "nut",

  606. };

  607. 

  608. #ifdef CONFIG_ENCODERS

  609. static AVOutputFormat nut_oformat = {

  610.     "nut",

  611.     "nut format",

  612.     "video/x-nut",

  613.     "nut",

  614.     sizeof(NUTContext),

  615. #ifdef CONFIG_VORBIS

  616.     CODEC_ID_VORBIS,

  617. #elif defined(CONFIG_MP3LAME)

  618.     CODEC_ID_MP3,

  619. #else

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

  621. #endif

  622.     CODEC_ID_MPEG4,

  623.     nut_write_header,

  624.     nut_write_packet,

  625.     nut_write_trailer,

  626. };

  627. #endif //CONFIG_ENCODERS

  628. 

  629. int nut_init(void)

  630. {

  631.     av_register_input_format(&nut_iformat);

  632. #ifdef CONFIG_ENCODERS

  633.     av_register_output_format(&nut_oformat);

  634. #endif //CONFIG_ENCODERS

  635.     return 0;

  636. }