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

589 lines
14KB
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.  * - index writing

  31.  * - info and index packet reading support

  32.  * - startcode searching for broken streams

  33.  * - subpacket support

  34.  * - handling of codec specific headers

  35. */

  36. 

  37. //#define DEBUG 1

  38. 

  39. #include "avformat.h"

  40. #include "mpegaudio.h"

  41. 

  42. //from /dev/random

  43. 

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

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

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

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

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

  49. 

  50. typedef struct {

  51.     int curr_frame_start;

  52.     int last_frame_size;

  53.     int curr_frame_size;

  54. } NUTContext;

  55. 

  56. static int bytes_left(ByteIOContext *bc)

  57. {

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

  59. }

  60. 

  61. static uint64_t get_v(ByteIOContext *bc)

  62. {

  63.     uint64_t val = 0;

  64. 

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

  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.     if (i < len)

  96.     {

  97. 	len = i;

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

  99. 	    get_byte(bc);

  100.     }

  101. 

  102.     return 0;

  103. }

  104. 

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

  106. {

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

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

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

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

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

  112.     

  113.     return 0;

  114. }

  115. 

  116. /**

  117.  * 

  118.  */

  119. static int get_length(uint64_t val){

  120.     int i;

  121. 

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

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

  124. 	    return i;

  125. 

  126.     return 7; //not reached

  127. }

  128. 

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

  130. {

  131.     int i;

  132. 

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

  134. //	return -1;

  135. 

  136.     if (bytes_left(bc) < 1)

  137. 	return -1;

  138. 

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

  140.     i= get_length(val);

  141. 

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

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

  144.     }

  145. 

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

  147. 

  148.     return 0;

  149. }

  150. 

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

  152. {

  153.     if (val<=0)

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

  155.     else

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

  157. }

  158. 

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

  160. {

  161.     int i;

  162.     

  163.     put_v(bc, len);

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

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

  166. 

  167.     return 0;

  168. }

  169. 

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

  171. {

  172.     put_flush_packet(bc);

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

  174.     nut->curr_frame_size = max_size;

  175.     

  176.     /* packet header */

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

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

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

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

  181. 

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

  183.     

  184.     return 0;

  185. }

  186. 

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

  188.     offset_t start= nut->curr_frame_start;

  189.     offset_t cur= url_ftell(bc);

  190.     int size= cur - start + additional_size;

  191.     

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

  193.     

  194.     url_fseek(bc, start, SEEK_SET);

  195.     put_v(bc, size);

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

  197.         put_byte(bc, 0x80);

  198.     nut->curr_frame_size= size;

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

  200. 

  201.     url_fseek(bc, cur, SEEK_SET);    

  202.     

  203.     return 0;

  204. }

  205. 

  206. static int nut_write_header(AVFormatContext *s)

  207. {

  208.     NUTContext *nut = s->priv_data;

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

  210.     AVCodecContext *codec;

  211.     int i;

  212.     int stream_length = 0;

  213. 

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

  215.     {

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

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

  218.     }

  219. 

  220.     /* main header */

  221.     put_be64(bc, MAIN_STARTCODE);

  222.     put_packetheader(nut, bc, 120);

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

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

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

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

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

  228.     

  229.     update_packetheader(nut, bc, 0);

  230.     

  231.     /* stream headers */

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

  233.     {

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

  235. 	

  236. 	put_be64(bc, STREAM_STARTCODE);

  237. 	put_packetheader(nut, bc, 120);

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

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

  240. 	if (codec->codec_tag)

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

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

  243. 	{

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

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

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

  247. //	    put_be32(bc, codec_get_bmp_tag(codec->codec_id));

  248. 	}

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

  250. 	{

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

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

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

  254. //	    put_be32(bc, codec_get_wav_tag(codec->codec_id));

  255. 	}

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

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

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

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

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

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

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

  263. 	

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

  265. 	

  266. 	switch(codec->codec_type)

  267. 	{

  268. 	    case CODEC_TYPE_AUDIO:

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

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

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

  272. 		break;

  273. 	    case CODEC_TYPE_VIDEO:

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

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

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

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

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

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

  280. 		break;

  281. 	}

  282.         update_packetheader(nut, bc, 0);

  283.     }

  284. 

  285. #if 0

  286.     /* info header */

  287.     put_be64(bc, INFO_STARTCODE);

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

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

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

  291.     {

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

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

  294.     }

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

  296.     {

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

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

  299.     }

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

  301.     {

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

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

  304.     }

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

  306.     {

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

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

  309.     }

  310.     /* encoder */

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

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

  313.     

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

  315. 

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

  317.     update_packetheader(nut, bc, 0);

  318. #endif

  319.         

  320.     put_flush_packet(bc);

  321.     

  322.     return 0;

  323. }

  324. 

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

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

  327. {

  328.     NUTContext *nut = s->priv_data;

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

  330.     int key_frame = 0;

  331.     int flags, size2;

  332.     AVCodecContext *enc;

  333. 

  334.     if (stream_index > s->nb_streams)

  335. 	return 1;

  336. 

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

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

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

  340. 

  341.     if (key_frame)

  342. 	put_be64(bc, KEYFRAME_STARTCODE);

  343.     

  344.     flags=0;

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

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

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

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

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

  350. 

  351.     put_byte(bc, flags);

  352. 

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

  354.     put_v(bc, stream_index);

  355.     put_s(bc, force_pts); /* lsb_timestamp */

  356.     update_packetheader(nut, bc, size);

  357.     

  358.     put_buffer(bc, buf, size);

  359.     

  360.     put_flush_packet(bc);

  361. 

  362.     return 0;

  363. }

  364. 

  365. static int nut_write_trailer(AVFormatContext *s)

  366. {

  367.     NUTContext *nut = s->priv_data;

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

  369. #if 0

  370.     int i;

  371. 

  372.     /* WRITE INDEX */

  373. 

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

  375.     {

  376. 	put_be64(bc, INDEX_STARTCODE);

  377. 	put_packetheader(nut, bc, 64);

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

  379. 	put_v(bc, ...);

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

  381.         update_packetheader(nut, bc, 0);

  382.     }

  383. #endif

  384. 

  385.     put_flush_packet(bc);

  386. 

  387.     return 0;

  388. }

  389. 

  390. static int nut_probe(AVProbeData *p)

  391. {

  392.     int i;

  393.     uint64_t code;

  394. 

  395.     code = 0xff;

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

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

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

  399.         code &= 0xFFFFFFFFFFFFFFFFULL;

  400.         if (code == MAIN_STARTCODE)

  401.             return AVPROBE_SCORE_MAX;

  402.     }

  403.     return 0;

  404. }

  405. 

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

  407. {

  408.     NUTContext *nut = s->priv_data;

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

  410.     uint64_t tmp;

  411.     int cur_stream, nb_streams;

  412.     

  413.     /* main header */

  414.     tmp = get_be64(bc);

  415.     if (tmp != MAIN_STARTCODE)

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

  417.     get_packetheader(nut, bc);

  418.     

  419.     tmp = get_v(bc);

  420.     if (tmp != 0)

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

  422.     

  423.     nb_streams = get_v(bc);

  424.     

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

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

  427. 

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

  429.     

  430.     s->bit_rate = 0;

  431.     

  432.     /* stream header */

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

  434.     {

  435. 	int class;

  436. 	AVStream *st;

  437. 	

  438. 	tmp = get_be64(bc);

  439. 	if (tmp != STREAM_STARTCODE)

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

  441. 	get_packetheader(nut, bc);

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

  443. 	if (!st)

  444. 	    return AVERROR_NOMEM;

  445. 	class = get_v(bc);

  446. 	switch(class)

  447. 	{

  448. 	    case 0:

  449. 		st->codec.codec_type = CODEC_TYPE_VIDEO;

  450. //		get_v(bc);

  451. //		tmp = get_be32(bc);

  452. 		get_b(bc, (char*)&tmp, 4);

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

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

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

  456. 		break;

  457. 	    case 32:

  458. 		st->codec.codec_type = CODEC_TYPE_AUDIO;

  459. //		tmp = get_v(bc);

  460. //		tmp = get_be32(bc);

  461. 		get_b(bc, (char*)&tmp, 4);

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

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

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

  465. 		break;

  466. 	    default:

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

  468. 		return -1;

  469. 	}

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

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

  472. 	while(tmp--)

  473. 	    get_byte(bc);

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

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

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

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

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

  479. 	

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

  481. 	

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

  483. 	{

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

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

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

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

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

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

  490. 	}

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

  492. 	{

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

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

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

  496. 	}

  497.     }    

  498.     

  499.     return 0;

  500. }

  501. 

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

  503. {

  504.     NUTContext *nut = s->priv_data;

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

  506.     int id, timestamp, size;

  507.     int key_frame = 0;

  508.     uint64_t tmp;

  509. 

  510. 

  511.     if (url_feof(bc))

  512. 	return -1;

  513.     

  514.     tmp = get_byte(bc);

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

  516.     {

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

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

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

  520. 	if (tmp == KEYFRAME_STARTCODE)

  521. 	{

  522. 	    key_frame = 1;

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

  524. 	}

  525. 	else

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

  527.     }

  528.     get_packetheader(nut, bc);

  529. #if 0

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

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

  532. #endif

  533.     id = get_v(bc);

  534.     timestamp = get_s(bc);

  535.     

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

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

  538.     

  539.     if (size < 0)

  540. 	return -1;

  541. 

  542.     av_new_packet(pkt, size);

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

  544.     pkt->stream_index = id;

  545.     if (key_frame)

  546. 	pkt->flags |= PKT_FLAG_KEY;

  547.     pkt->pts = timestamp;

  548. 

  549.     return 0;

  550. }

  551. 

  552. static AVInputFormat nut_iformat = {

  553.     "nut",

  554.     "nut format",

  555.     sizeof(NUTContext),

  556.     nut_probe,

  557.     nut_read_header,

  558.     nut_read_packet,

  559. //    nut_read_close,

  560. //    nut_read_seek,

  561.     .extensions = "nut",

  562. };

  563. 

  564. static AVOutputFormat nut_oformat = {

  565.     "nut",

  566.     "nut format",

  567.     "video/x-nut",

  568.     "nut",

  569.     sizeof(NUTContext),

  570. #ifdef CONFIG_VORBIS

  571.     CODEC_ID_VORBIS,

  572. #elif defined(CONFIG_MP3LAME)

  573.     CODEC_ID_MP3LAME,

  574. #else

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

  576. #endif

  577.     CODEC_ID_MPEG4,

  578.     nut_write_header,

  579.     nut_write_packet,

  580.     nut_write_trailer,

  581. };

  582. 

  583. int nut_init(void)

  584. {

  585.     av_register_input_format(&nut_iformat);

  586.     av_register_output_format(&nut_oformat);

  587.     return 0;

  588. }