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

556 lines
13KB
Raw Blame History 

  1. /*

  2.  * NUT (de)muxer based on initial draft

  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.  * Compatible with draft version 20030906

  22.  *

  23.  */

  24. 

  25. /*

  26.  * TODO:

  27.  * - checksumming

  28.  * - correct rate denom/nom and sample_mul

  29.  * - correct timestamp handling

  30.  * - correct startcodes

  31.  * - index writing

  32.  * - info and index packet reading support

  33.  * - startcode searching for broken streams

  34.  * - subpacket support

  35.  * - handling of codec specific headers

  36. */

  37. 

  38. //#define DEBUG 1

  39. 

  40. #include "avformat.h"

  41. #include "mpegaudio.h"

  42. 

  43. typedef struct {

  44.     int curr_frame_start;

  45.     int last_frame_size;

  46.     int curr_frame_size;

  47. } NUTContext;

  48. 

  49. static int bytes_left(ByteIOContext *bc)

  50. {

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

  52. }

  53. 

  54. static uint64_t get_v(ByteIOContext *bc)

  55. {

  56.     uint64_t val = 0;

  57. 

  58. //    for (; bytes_left(s)*8 > 0; )

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

  60.     {

  61. 	int tmp = get_byte(bc);

  62. 

  63. 	if (tmp&0x80)

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

  65. 	else

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

  67.     }

  68.     return -1;

  69. }

  70. 

  71. static int64_t get_s(ByteIOContext *bc)

  72. {

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

  74. 

  75.     if (v&1)

  76.         return -(v>>1);

  77.     else

  78.         return (v>>1);

  79. }

  80. 

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

  82. {

  83.     int i, len;

  84.     

  85.     len = get_v(bc);

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

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

  88.     if (i < len)

  89.     {

  90. 	len = i;

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

  92. 	    get_byte(bc);

  93.     }

  94. 

  95.     return 0;

  96. }

  97. 

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

  99. {

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

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

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

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

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

  105.     

  106.     return 0;

  107. }

  108. 

  109. static int get_padding(NUTContext *nut, ByteIOContext *bc)

  110. {

  111.     int i, tmp, len = nut->curr_frame_size - (url_ftell(bc) - nut->curr_frame_start);

  112. 

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

  114.     {

  115. 	tmp = get_byte(bc);

  116. 	if (tmp != 0)

  117. 	    fprintf(stderr, "bad padding\n");

  118.     }

  119. 

  120.     return 0;

  121. }

  122. 

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

  124. {

  125.     int i;

  126. 

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

  128. //	return -1;

  129. 

  130.     if (bytes_left(bc) < 1)

  131. 	return -1;

  132. 

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

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

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

  136. 	    break;

  137. 

  138.     for (i-=7; i>0; i-=8)

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

  140. 

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

  142. 

  143.     return 0;

  144. }

  145. 

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

  147. {

  148.     if (val<=0)

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

  150.     else

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

  152. }

  153. 

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

  155. {

  156.     int i;

  157.     

  158.     put_v(bc, len);

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

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

  161. 

  162.     return 0;

  163. }

  164. 

  165. static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int est_size)

  166. {

  167.     put_flush_packet(bc);

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

  169.     nut->curr_frame_size = est_size;

  170.     

  171.     /* packet header */

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

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

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

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

  176. 

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

  178.     

  179.     return 0;

  180. }

  181. 

  182. static int put_padding(NUTContext *nut, ByteIOContext *bc)

  183. {

  184.     int i, len = nut->curr_frame_size - (url_ftell(bc) - nut->curr_frame_start);

  185.     

  186.     put_flush_packet(bc);

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

  188. 	put_byte(bc, 0);

  189. 

  190.     dprintf("padded %d bytes\n", i);

  191. 

  192.     return 0;

  193. }

  194. 

  195. static int nut_write_header(AVFormatContext *s)

  196. {

  197.     NUTContext *nut = s->priv_data;

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

  199.     AVCodecContext *codec;

  200.     int i;

  201.     int stream_length = 0;

  202. 

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

  204.     {

  205. 	if (stream_length < (s->streams[i]->duration * (AV_TIME_BASE / 1000)))

  206. 	    stream_length = s->streams[i]->duration * (AV_TIME_BASE / 1000);

  207.     }

  208. 

  209.     put_packetheader(nut, bc, 16); /* FIXME: estimation */

  210.     

  211.     /* main header */

  212.     put_le64(bc, 1); /* FIXME: unique startcode */

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

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

  215.     put_v(bc, 0); /* file size */

  216.     put_v(bc, stream_length); /* len in msec */

  217.     put_padding(nut, bc);

  218.     put_le32(bc, 0); /* FIXME: checksum */

  219.     

  220.     /* stream headers */

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

  222.     {

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

  224. 	

  225. 	put_packetheader(nut, bc, 64); /* FIXME: estimation */

  226. 	put_le64(bc, 1); /* FIXME: unique startcode */

  227. 	put_v(bc, s->streams[i]->index);

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

  229. 	if (codec->codec_tag)

  230. 	    put_b(bc, codec->codec_tag, 4);

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

  232. 	{

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

  234. 	    put_b(bc, &tmp, 4);

  235. //	    put_v(bc, 4); /* len */

  236. //	    put_le32(bc, codec_get_bmp_tag(codec->codec_id));

  237. 	}

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

  239. 	{

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

  241. 	    put_b(bc, &tmp, 4);

  242. //	    put_v(bc, 4); /* len */

  243. //	    put_le32(bc, codec_get_wav_tag(codec->codec_id));

  244. 	}

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

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

  247. 	put_v(bc, codec->frame_rate_base);

  248. 	put_v(bc, codec->frame_rate);

  249. 	put_v(bc, 0); /* timestamp_shift */

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

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

  252. 	

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

  254. 	

  255. 	switch(codec->codec_type)

  256. 	{

  257. 	    case CODEC_TYPE_AUDIO:

  258. 		put_v(bc, codec->sample_rate / (double)(codec->frame_rate_base / codec->frame_rate));

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

  260. 		put_padding(nut, bc);

  261. 		put_le32(bc, 0); /* FIXME: checksum */

  262. 		break;

  263. 	    case CODEC_TYPE_VIDEO:

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

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

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

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

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

  269. 		put_padding(nut, bc);

  270. 		put_le32(bc, 0); /* FIXME: checksum */

  271. 		break;

  272. 	}

  273.     }

  274. 

  275. #if 0

  276.     /* info header */

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

  278.         strlen(s->comment)+strlen(s->copyright)); /* FIXME: estimation */

  279.     put_le64(bc, 1); /* FIXME: unique startcode */

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

  281.     {

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

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

  284.     }

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

  286.     {

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

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

  289.     }

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

  291.     {

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

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

  294.     }

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

  296.     {

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

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

  299.     }

  300.     /* encoder */

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

  302.     put_b(bc, LIBAVFORMAT_IDENT, strlen(LIBAVFORMAT_IDENT));

  303. 

  304.     put_padding(nut, bc);

  305.     put_le32(bc, 0); /* FIXME: checksum */

  306. #endif

  307.         

  308.     put_flush_packet(bc);

  309.     

  310.     return 0;

  311. }

  312. 

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

  314. 			    uint8_t *buf, int size, int force_pts)

  315. {

  316.     NUTContext *nut = s->priv_data;

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

  318.     int key_frame = 0;

  319.     AVCodecContext *enc;

  320. 

  321.     if (stream_index > s->nb_streams)

  322. 	return 1;

  323. 

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

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

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

  327. 

  328.     put_packetheader(nut, bc, size+(key_frame?16:8)+4); /* FIXME: estimation */

  329. 

  330.     if (key_frame)

  331. 	put_le64(bc, 1); /* FIXME: unique startcode */

  332.     put_byte(bc, (key_frame ? 1<<5 : 0) + (1 << 1)); /* flags */

  333.     put_v(bc, stream_index);

  334.     put_s(bc, 0); /* lsb_timestamp */

  335.     

  336.     put_buffer(bc, buf, size);

  337.     

  338.     put_padding(nut, bc);

  339. 

  340.     put_flush_packet(bc);

  341. 

  342.     return 0;

  343. }

  344. 

  345. static int nut_write_trailer(AVFormatContext *s)

  346. {

  347.     NUTContext *nut = s->priv_data;

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

  349. #if 0

  350.     int i;

  351. 

  352.     /* WRITE INDEX */

  353. 

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

  355.     {

  356. 	put_packetheader(nut, bc, 64); /* FIXME: estimation */

  357. 	put_le64(bc, 1); /* FIXME: unique startcode */

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

  359. 	put_v(bc, ...);

  360. 	put_padding(nut, bc);

  361. 	put_le32(bc, 0); /* FIXME: checksum */

  362.     }

  363. #endif

  364. 

  365.     put_flush_packet(bc);

  366. 

  367.     return 0;

  368. }

  369. 

  370. static int nut_probe(AVProbeData *p)

  371. {

  372.     return AVPROBE_SCORE_MAX;

  373. }

  374. 

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

  376. {

  377.     NUTContext *nut = s->priv_data;

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

  379.     int tmp;

  380.     int cur_stream, nb_streams;

  381.     

  382.     /* main header */

  383.     get_packetheader(nut, bc);

  384.     tmp = get_le64(bc);

  385.     if (tmp != 1)

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

  387.     

  388.     tmp = get_v(bc);

  389.     if (tmp != 0)

  390. 	fprintf(stderr, "bad version (%d)\n", tmp);

  391.     

  392.     nb_streams = get_v(bc);

  393.     

  394.     s->file_size = get_v(bc);

  395.     s->duration = get_v(bc) / (AV_TIME_BASE / 1000);

  396. 

  397.     get_padding(nut, bc);

  398.     get_le32(bc); /* checkusm */

  399.     

  400.     s->bit_rate = 0;

  401.     

  402.     /* stream header */

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

  404.     {

  405. 	int class;

  406. 	AVStream *st;

  407. 	

  408. 	get_packetheader(nut, bc);

  409. 	tmp = get_le64(bc);

  410. 	if (tmp != 1)

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

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

  413. 	if (!st)

  414. 	    return AVERROR_NOMEM;

  415. 	class = get_v(bc);

  416. 	switch(class)

  417. 	{

  418. 	    case 0:

  419. 		st->codec.codec_type = CODEC_TYPE_VIDEO;

  420. //		get_v(bc);

  421. //		tmp = get_le32(bc);

  422. 		get_b(bc, &tmp, 4);

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

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

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

  426. 		break;

  427. 	    case 32:

  428. 		st->codec.codec_type = CODEC_TYPE_AUDIO;

  429. //		tmp = get_v(bc);

  430. //		tmp = get_le32(bc);

  431. 		get_b(bc, &tmp, 4);

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

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

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

  435. 		break;

  436. 	    default:

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

  438. 		return -1;

  439. 	}

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

  441. 	tmp = get_v(bc); /* language code */

  442. 	while(tmp--)

  443. 	    get_byte(bc);

  444. 	st->codec.frame_rate_base = get_v(bc);

  445. 	st->codec.frame_rate = get_v(bc);

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

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

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

  449. 	

  450. 	get_v(bc); /* FIXME: codec specific data headers */

  451. 	

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

  453. 	{

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

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

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

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

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

  459. 	    get_padding(nut, bc);

  460. 	    get_le32(bc); /* checksum */

  461. 	}

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

  463. 	{

  464. 	    st->codec.sample_rate = get_v(bc) * (double)(st->codec.frame_rate_base / st->codec.frame_rate);

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

  466. 	    get_padding(nut, bc);

  467. 	    get_le32(bc); /* checksum */

  468. 	}

  469.     }    

  470.     

  471.     return 0;

  472. }

  473. 

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

  475. {

  476.     NUTContext *nut = s->priv_data;

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

  478.     int tmp, id, timestamp, size;

  479.     int key_frame = 0;

  480. 

  481.     get_packetheader(nut, bc);

  482. 

  483.     if (url_feof(bc))

  484. 	return -1;

  485.     

  486.     tmp = get_byte(bc);

  487.     if ((tmp & 0x7f) == 1) /* zero bit set? */

  488.     {

  489. 	tmp = get_le32(bc)+get_le16(bc)+get_byte(bc);

  490. 	if (!tmp)

  491. 	{

  492. 	    key_frame = 1;

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

  494. 	}

  495. 	else

  496. 	    fprintf(stderr, "error in zero bit / startcode\n");

  497.     }

  498.     if ((tmp & 0x9f) > 3) /* priority <= 3 */

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

  500.     id = get_v(bc);

  501.     timestamp = get_s(bc);

  502.     

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

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

  505.     

  506.     if (size < 0)

  507. 	return -1;

  508. 

  509.     av_new_packet(pkt, size);

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

  511.     pkt->stream_index = id;

  512.     if (key_frame)

  513. 	pkt->flags |= PKT_FLAG_KEY;

  514.     pkt->pts = timestamp;

  515. 

  516.     return 0;

  517. }

  518. 

  519. static AVInputFormat nut_iformat = {

  520.     "nut",

  521.     "nut format",

  522.     sizeof(NUTContext),

  523.     nut_probe,

  524.     nut_read_header,

  525.     nut_read_packet,

  526. //    nut_read_close,

  527. //    nut_read_seek,

  528.     .extensions = "nut",

  529. };

  530. 

  531. static AVOutputFormat nut_oformat = {

  532.     "nut",

  533.     "nut format",

  534.     "video/x-nut",

  535.     "nut",

  536.     sizeof(NUTContext),

  537. #ifdef CONFIG_VORBIS

  538.     CODEC_ID_VORBIS,

  539. #elif defined(CONFIG_MP3LAME)

  540.     CODEC_ID_MP3LAME,

  541. #else

  542.     CODEC_ID_MP2,

  543. #endif

  544.     CODEC_ID_MPEG4,

  545.     nut_write_header,

  546.     nut_write_packet,

  547.     nut_write_trailer,

  548. };

  549. 

  550. int nut_init(void)

  551. {

  552.     av_register_input_format(&nut_iformat);

  553.     av_register_output_format(&nut_oformat);

  554.     return 0;

  555. }