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

595 lines
13KB
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. } NUTContext;

  54. 

  55. static int bytes_left(ByteIOContext *bc)

  56. {

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

  58. }

  59. 

  60. static uint64_t get_v(ByteIOContext *bc)

  61. {

  62.     uint64_t val = 0;

  63. 

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

  65.     {

  66. 	int tmp = get_byte(bc);

  67. 

  68. 	if (tmp&0x80)

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

  70. 	else

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

  72.     }

  73.     return -1;

  74. }

  75. 

  76. static int64_t get_s(ByteIOContext *bc)

  77. {

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

  79. 

  80.     if (v&1)

  81.         return -(v>>1);

  82.     else

  83.         return (v>>1);

  84. }

  85. 

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

  87. {

  88.     int i, len;

  89.     

  90.     len = get_v(bc);

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

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

  93.     /* skip remaining bytes */

  94.     url_fskip(bc, len-i);

  95. 

  96.     return 0;

  97. }

  98. 

  99. static int get_bi(ByteIOContext *bc)

  100. {

  101.    int i, len, val = 0;

  102.     

  103.     len = get_v(bc);

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

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

  106.     /* skip remaining bytes */

  107.     url_fskip(bc, len-i);

  108. 

  109.     return val;

  110. }

  111. 

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

  113. {

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

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

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

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

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

  119.     

  120.     return 0;

  121. }

  122. 

  123. /**

  124.  * 

  125.  */

  126. static int get_length(uint64_t val){

  127.     int i;

  128. 

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

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

  131. 	    return i;

  132. 

  133.     return 7; //not reached

  134. }

  135. 

  136. #ifdef CONFIG_ENCODERS

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

  138. {

  139.     int i;

  140. 

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

  142. //	return -1;

  143. 

  144.     if (bytes_left(bc) < 1)

  145. 	return -1;

  146. 

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

  148.     i= get_length(val);

  149. 

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

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

  152.     }

  153. 

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

  155. 

  156.     return 0;

  157. }

  158. 

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

  160. {

  161.     if (val<=0)

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

  163.     else

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

  165. }

  166. 

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

  168. {

  169.     int i;

  170.     

  171.     put_v(bc, len);

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

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

  174. 

  175.     return 0;

  176. }

  177. 

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

  179. {

  180.     put_v(bc, 4);

  181.     put_le32(bc, val);

  182.     return 0;

  183. }

  184. 

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

  186. {

  187.     put_flush_packet(bc);

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

  189.     nut->curr_frame_size = max_size;

  190.     

  191.     /* packet header */

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

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

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

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

  196. 

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

  198.     

  199.     return 0;

  200. }

  201. 

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

  203.     offset_t start= nut->curr_frame_start;

  204.     offset_t cur= url_ftell(bc);

  205.     int size= cur - start + additional_size;

  206.     

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

  208.     

  209.     url_fseek(bc, start, SEEK_SET);

  210.     put_v(bc, size);

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

  212.         put_byte(bc, 0x80);

  213.     nut->curr_frame_size= size;

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

  215. 

  216.     url_fseek(bc, cur, SEEK_SET);    

  217.     

  218.     return 0;

  219. }

  220. 

  221. static int nut_write_header(AVFormatContext *s)

  222. {

  223.     NUTContext *nut = s->priv_data;

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

  225.     AVCodecContext *codec;

  226.     int i;

  227. 

  228.     /* main header */

  229.     put_be64(bc, MAIN_STARTCODE);

  230.     put_packetheader(nut, bc, 120);

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

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

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

  234.     

  235.     update_packetheader(nut, bc, 0);

  236.     

  237.     /* stream headers */

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

  239.     {

  240. 	int nom, denom;

  241. 

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

  243. 	

  244. 	put_be64(bc, STREAM_STARTCODE);

  245. 	put_packetheader(nut, bc, 120);

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

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

  248. 	if (codec->codec_tag)

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

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

  251. 	{

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

  253. 	    put_bi(bc, tmp);

  254. 	    nom = codec->frame_rate;

  255. 	    denom = codec->frame_rate_base;

  256. 	}

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

  258. 	{

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

  260. 	    put_bi(bc, tmp);

  261. 	    nom = codec->sample_rate/8;

  262. 	    denom = 8;

  263. 	}

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

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

  266. 	put_v(bc, nom);

  267. 	put_v(bc, denom);

  268. 	put_v(bc, 0); /* msb timestamp_shift */

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

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

  271. 	

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

  273. 	

  274. 	switch(codec->codec_type)

  275. 	{

  276. 	    case CODEC_TYPE_AUDIO:

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

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

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

  280. 		break;

  281. 	    case CODEC_TYPE_VIDEO:

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

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

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

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

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

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

  288. 		break;

  289.             default:

  290.                 break;

  291. 	}

  292.         update_packetheader(nut, bc, 0);

  293.     }

  294. 

  295. #if 0

  296.     /* info header */

  297.     put_be64(bc, INFO_STARTCODE);

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

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

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

  301.     {

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

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

  304.     }

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

  306.     {

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

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

  309.     }

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

  311.     {

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

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

  314.     }

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

  316.     {

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

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

  319.     }

  320.     /* encoder */

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

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

  323.     

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

  325. 

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

  327.     update_packetheader(nut, bc, 0);

  328. #endif

  329.         

  330.     put_flush_packet(bc);

  331.     

  332.     return 0;

  333. }

  334. 

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

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

  337. {

  338.     NUTContext *nut = s->priv_data;

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

  340.     int key_frame = 0;

  341.     int flags;

  342.     AVCodecContext *enc;

  343. 

  344.     if (stream_index > s->nb_streams)

  345. 	return 1;

  346. 

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

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

  349. 

  350.     if (key_frame)

  351. 	put_be64(bc, KEYFRAME_STARTCODE);

  352.     

  353.     flags=0;

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

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

  356.     flags<<=1; flags|=0; //msb_timestamp_flag

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

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

  359. 

  360.     put_byte(bc, flags);

  361. 

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

  363.     put_v(bc, stream_index);

  364.     put_s(bc, pts); /* lsb_timestamp */

  365.     update_packetheader(nut, bc, size);

  366.     

  367.     put_buffer(bc, buf, size);

  368.     

  369.     put_flush_packet(bc);

  370. 

  371.     return 0;

  372. }

  373. 

  374. static int nut_write_trailer(AVFormatContext *s)

  375. {

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

  377. #if 0

  378.     int i;

  379. 

  380.     /* WRITE INDEX */

  381. 

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

  383.     {

  384. 	put_be64(bc, INDEX_STARTCODE);

  385. 	put_packetheader(nut, bc, 64);

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

  387. 	put_v(bc, ...);

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

  389.         update_packetheader(nut, bc, 0);

  390.     }

  391. #endif

  392. 

  393.     put_flush_packet(bc);

  394. 

  395.     return 0;

  396. }

  397. #endif //CONFIG_ENCODERS

  398. 

  399. static int nut_probe(AVProbeData *p)

  400. {

  401.     int i;

  402.     uint64_t code;

  403. 

  404.     code = 0xff;

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

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

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

  408.         if (code == MAIN_STARTCODE)

  409.             return AVPROBE_SCORE_MAX;

  410.     }

  411.     return 0;

  412. }

  413. 

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

  415. {

  416.     NUTContext *nut = s->priv_data;

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

  418.     uint64_t tmp;

  419.     int cur_stream, nb_streams;

  420.     

  421.     /* main header */

  422.     tmp = get_be64(bc);

  423.     if (tmp != MAIN_STARTCODE)

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

  425.     get_packetheader(nut, bc);

  426.     

  427.     tmp = get_v(bc);

  428.     if (tmp != 0)

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

  430.     

  431.     nb_streams = get_v(bc);

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

  433.     

  434.     s->bit_rate = 0;

  435.     

  436.     /* stream header */

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

  438.     {

  439. 	int class, nom, denom;

  440. 	AVStream *st;

  441. 	

  442. 	tmp = get_be64(bc);

  443. 	if (tmp != STREAM_STARTCODE)

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

  445. 	get_packetheader(nut, bc);

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

  447. 	if (!st)

  448. 	    return AVERROR_NOMEM;

  449. 	class = get_v(bc);

  450. 	tmp = get_bi(bc);

  451. 	switch(class)

  452. 	{

  453. 	    case 0:

  454. 		st->codec.codec_type = CODEC_TYPE_VIDEO;

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

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

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

  458. 		break;

  459. 	    case 32:

  460. 		st->codec.codec_type = CODEC_TYPE_AUDIO;

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

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

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

  464. 		break;

  465. 	    default:

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

  467. 		return -1;

  468. 	}

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

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

  471. 	nom = get_v(bc);

  472. 	denom = get_v(bc);

  473. 	get_v(bc); /* FIXME: msb timestamp base */

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

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

  476. 

  477. 	/* codec specific data headers */

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

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

  480. 	

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

  482. 	{

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

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

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

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

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

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

  489. 

  490. 	    st->codec.frame_rate = nom;

  491. 	    st->codec.frame_rate_base = denom;

  492. 	}

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

  494. 	{

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

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

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

  498. 	}

  499.     }    

  500.     

  501.     return 0;

  502. }

  503. 

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

  505. {

  506.     NUTContext *nut = s->priv_data;

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

  508.     int id, timestamp, size;

  509.     int key_frame = 0;

  510.     uint64_t tmp;

  511. 

  512. 

  513.     if (url_feof(bc))

  514. 	return -1;

  515.     

  516.     tmp = get_byte(bc);

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

  518.     {

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

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

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

  522. 	if (tmp == KEYFRAME_STARTCODE)

  523. 	{

  524. 	    key_frame = 1;

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

  526. 	}

  527. 	else

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

  529.     }

  530.     get_packetheader(nut, bc);

  531. #if 0

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

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

  534. #endif

  535.     id = get_v(bc);

  536.     timestamp = get_s(bc);

  537.     

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

  539.     dprintf("flags: 0x%Lx, timestamp: %d, packet size: %d\n", tmp, timestamp, size);

  540.     

  541.     if (size < 0)

  542. 	return -1;

  543. 

  544.     av_new_packet(pkt, size);

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

  546.     pkt->stream_index = id;

  547.     if (key_frame)

  548. 	pkt->flags |= PKT_FLAG_KEY;

  549.     pkt->pts = timestamp;

  550. 

  551.     return 0;

  552. }

  553. 

  554. static AVInputFormat nut_iformat = {

  555.     "nut",

  556.     "nut format",

  557.     sizeof(NUTContext),

  558.     nut_probe,

  559.     nut_read_header,

  560.     nut_read_packet,

  561. //    nut_read_close,

  562. //    nut_read_seek,

  563.     .extensions = "nut",

  564. };

  565. 

  566. #ifdef CONFIG_ENCODERS

  567. static AVOutputFormat nut_oformat = {

  568.     "nut",

  569.     "nut format",

  570.     "video/x-nut",

  571.     "nut",

  572.     sizeof(NUTContext),

  573. #ifdef CONFIG_VORBIS

  574.     CODEC_ID_VORBIS,

  575. #elif defined(CONFIG_MP3LAME)

  576.     CODEC_ID_MP3,

  577. #else

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

  579. #endif

  580.     CODEC_ID_MPEG4,

  581.     nut_write_header,

  582.     nut_write_packet,

  583.     nut_write_trailer,

  584. };

  585. #endif //CONFIG_ENCODERS

  586. 

  587. int nut_init(void)

  588. {

  589.     av_register_input_format(&nut_iformat);

  590. #ifdef CONFIG_ENCODERS

  591.     av_register_output_format(&nut_oformat);

  592. #endif //CONFIG_ENCODERS

  593.     return 0;

  594. }