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.
2683 Commits
32 Branches
283MB
Tree: 94789b9e59
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '94789b9e59'
${ noResults }
FFmpeg/libavformat/asf.c

1295 lines
38KB
Raw Blame History 

  1. /*

  2.  * ASF compatible encoder and decoder.

  3.  * Copyright (c) 2000, 2001 Fabrice Bellard.

  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 Lesser 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. #include "avformat.h"

  20. #include "avi.h"

  21. #include "mpegaudio.h"

  22. 

  23. #define PACKET_SIZE 3200

  24. #define PACKET_HEADER_SIZE 12

  25. #define FRAME_HEADER_SIZE 17

  26. 

  27. typedef struct {

  28.     int num;

  29.     int seq;

  30.     /* use for reading */

  31.     AVPacket pkt;

  32.     int frag_offset;

  33.     int timestamp;

  34.     int64_t duration;

  35. 

  36.     int ds_span;		/* descrambling  */

  37.     int ds_packet_size;

  38.     int ds_chunk_size;

  39.     int ds_data_size;

  40.     int ds_silence_data;

  41. 

  42. } ASFStream;

  43. 

  44. typedef struct {

  45.     uint32_t v1;

  46.     uint16_t v2;

  47.     uint16_t v3;

  48.     uint8_t v4[8];

  49. } GUID;

  50. 

  51. typedef struct {

  52.     GUID guid;			// generated by client computer

  53.     uint64_t file_size;		// in bytes

  54.                                 // invalid if broadcasting

  55.     uint64_t create_time;	// time of creation, in 100-nanosecond units since 1.1.1601

  56.                                 // invalid if broadcasting

  57.     uint64_t packets_count;	// how many packets are there in the file

  58.                                 // invalid if broadcasting

  59.     uint64_t play_time;		// play time, in 100-nanosecond units

  60.                                 // invalid if broadcasting

  61.     uint64_t send_time;		// time to send file, in 100-nanosecond units

  62.                                 // invalid if broadcasting (could be ignored)

  63.     uint32_t preroll;		// timestamp of the first packet, in milliseconds

  64.     				// if nonzero - substract from time

  65.     uint32_t ignore;            // preroll is 64bit - but let's just ignore it

  66.     uint32_t flags;		// 0x01 - broadcast

  67.     				// 0x02 - seekable

  68.                                 // rest is reserved should be 0

  69.     uint32_t min_pktsize;	// size of a data packet

  70.                                 // invalid if broadcasting

  71.     uint32_t max_pktsize;	// shall be the same as for min_pktsize

  72.                                 // invalid if broadcasting

  73.     uint32_t max_bitrate;	// bandwith of stream in bps

  74.     				// should be the sum of bitrates of the

  75.                                 // individual media streams

  76. } ASFMainHeader;

  77. 

  78. 

  79. typedef struct {

  80.     int seqno;

  81.     int packet_size;

  82.     int is_streamed;

  83.     int asfid2avid[128];        /* conversion table from asf ID 2 AVStream ID */

  84.     ASFStream streams[128];	/* it's max number and it's not that big */

  85.     /* non streamed additonnal info */

  86.     int64_t nb_packets;

  87.     int64_t duration; /* in 100ns units */

  88.     /* packet filling */

  89.     int packet_size_left;

  90.     int packet_timestamp_start;

  91.     int packet_timestamp_end;

  92.     int packet_nb_frames;

  93.     uint8_t packet_buf[PACKET_SIZE];

  94.     ByteIOContext pb;

  95.     /* only for reading */

  96.     uint64_t data_offset; /* begining of the first data packet */

  97. 

  98.     ASFMainHeader hdr;

  99. 

  100.     int packet_flags;

  101.     int packet_property;

  102.     int packet_timestamp;

  103.     int packet_segsizetype;

  104.     int packet_segments;

  105.     int packet_seq;

  106.     int packet_replic_size;

  107.     int packet_key_frame;

  108.     int packet_padsize;

  109.     int packet_frag_offset;

  110.     int packet_frag_size;

  111.     int packet_frag_timestamp;

  112.     int packet_multi_size;

  113.     int packet_obj_size;

  114.     int packet_time_delta;

  115.     int packet_time_start;

  116. 

  117.     int stream_index;

  118.     ASFStream* asf_st; /* currently decoded stream */

  119. } ASFContext;

  120. 

  121. static const GUID asf_header = {

  122.     0x75B22630, 0x668E, 0x11CF, { 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C },

  123. };

  124. 

  125. static const GUID file_header = {

  126.     0x8CABDCA1, 0xA947, 0x11CF, { 0x8E, 0xE4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 },

  127. };

  128. 

  129. static const GUID stream_header = {

  130.     0xB7DC0791, 0xA9B7, 0x11CF, { 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 },

  131. };

  132. 

  133. static const GUID audio_stream = {

  134.     0xF8699E40, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },

  135. };

  136. 

  137. static const GUID audio_conceal_none = {

  138.     // 0x49f1a440, 0x4ece, 0x11d0, { 0xa3, 0xac, 0x00, 0xa0, 0xc9, 0x03, 0x48, 0xf6 },

  139.     // New value lifted from avifile

  140.     0x20fb5700, 0x5b55, 0x11cf, { 0xa8, 0xfd, 0x00, 0x80, 0x5f, 0x5c, 0x44, 0x2b },

  141. };

  142. 

  143. static const GUID video_stream = {

  144.     0xBC19EFC0, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },

  145. };

  146. 

  147. static const GUID video_conceal_none = {

  148.     0x20FB5700, 0x5B55, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },

  149. };

  150. 

  151. 

  152. static const GUID comment_header = {

  153.     0x75b22633, 0x668e, 0x11cf, { 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c },

  154. };

  155. 

  156. static const GUID codec_comment_header = {

  157.     0x86D15240, 0x311D, 0x11D0, { 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 },

  158. };

  159. static const GUID codec_comment1_header = {

  160.     0x86d15241, 0x311d, 0x11d0, { 0xa3, 0xa4, 0x00, 0xa0, 0xc9, 0x03, 0x48, 0xf6 },

  161. };

  162. 

  163. static const GUID data_header = {

  164.     0x75b22636, 0x668e, 0x11cf, { 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c },

  165. };

  166. 

  167. static const GUID index_guid = {

  168.     0x33000890, 0xe5b1, 0x11cf, { 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb },

  169. };

  170. 

  171. static const GUID head1_guid = {

  172.     0x5fbf03b5, 0xa92e, 0x11cf, { 0x8e, 0xe3, 0x00, 0xc0, 0x0c, 0x20, 0x53, 0x65 },

  173. };

  174. 

  175. static const GUID head2_guid = {

  176.     0xabd3d211, 0xa9ba, 0x11cf, { 0x8e, 0xe6, 0x00, 0xc0, 0x0c, 0x20, 0x53, 0x65 },

  177. };

  178. 

  179. /* I am not a number !!! This GUID is the one found on the PC used to

  180.    generate the stream */

  181. static const GUID my_guid = {

  182.     0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 },

  183. };

  184. 

  185. #ifdef CONFIG_ENCODERS

  186. static void put_guid(ByteIOContext *s, const GUID *g)

  187. {

  188.     int i;

  189. 

  190.     put_le32(s, g->v1);

  191.     put_le16(s, g->v2);

  192.     put_le16(s, g->v3);

  193.     for(i=0;i<8;i++)

  194.         put_byte(s, g->v4[i]);

  195. }

  196. 

  197. static void put_str16(ByteIOContext *s, const char *tag)

  198. {

  199.     int c;

  200. 

  201.     put_le16(s,strlen(tag) + 1);

  202.     for(;;) {

  203.         c = (uint8_t)*tag++;

  204.         put_le16(s, c);

  205.         if (c == '\0')

  206.             break;

  207.     }

  208. }

  209. 

  210. static void put_str16_nolen(ByteIOContext *s, const char *tag)

  211. {

  212.     int c;

  213. 

  214.     for(;;) {

  215.         c = (uint8_t)*tag++;

  216.         put_le16(s, c);

  217.         if (c == '\0')

  218.             break;

  219.     }

  220. }

  221. 

  222. static int64_t put_header(ByteIOContext *pb, const GUID *g)

  223. {

  224.     int64_t pos;

  225. 

  226.     pos = url_ftell(pb);

  227.     put_guid(pb, g);

  228.     put_le64(pb, 24);

  229.     return pos;

  230. }

  231. 

  232. /* update header size */

  233. static void end_header(ByteIOContext *pb, int64_t pos)

  234. {

  235.     int64_t pos1;

  236. 

  237.     pos1 = url_ftell(pb);

  238.     url_fseek(pb, pos + 16, SEEK_SET);

  239.     put_le64(pb, pos1 - pos);

  240.     url_fseek(pb, pos1, SEEK_SET);

  241. }

  242. 

  243. /* write an asf chunk (only used in streaming case) */

  244. static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags)

  245. {

  246.     ASFContext *asf = s->priv_data;

  247.     ByteIOContext *pb = &s->pb;

  248.     int length;

  249. 

  250.     length = payload_length + 8;

  251.     put_le16(pb, type);

  252.     put_le16(pb, length);

  253.     put_le32(pb, asf->seqno);

  254.     put_le16(pb, flags); /* unknown bytes */

  255.     put_le16(pb, length);

  256.     asf->seqno++;

  257. }

  258. 

  259. /* convert from unix to windows time */

  260. static int64_t unix_to_file_time(int ti)

  261. {

  262.     int64_t t;

  263. 

  264.     t = ti * int64_t_C(10000000);

  265.     t += int64_t_C(116444736000000000);

  266.     return t;

  267. }

  268. 

  269. /* write the header (used two times if non streamed) */

  270. static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)

  271. {

  272.     ASFContext *asf = s->priv_data;

  273.     ByteIOContext *pb = &s->pb;

  274.     int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;

  275.     int has_title;

  276.     AVCodecContext *enc;

  277.     int64_t header_offset, cur_pos, hpos;

  278.     int bit_rate;

  279. 

  280.     has_title = (s->title[0] || s->author[0] || s->copyright[0] || s->comment[0]);

  281. 

  282.     bit_rate = 0;

  283.     for(n=0;n<s->nb_streams;n++) {

  284.         enc = &s->streams[n]->codec;

  285. 

  286.         bit_rate += enc->bit_rate;

  287.     }

  288. 

  289.     if (asf->is_streamed) {

  290.         put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */

  291.     }

  292. 

  293.     put_guid(pb, &asf_header);

  294.     put_le64(pb, -1); /* header length, will be patched after */

  295.     put_le32(pb, 3 + has_title + s->nb_streams); /* number of chunks in header */

  296.     put_byte(pb, 1); /* ??? */

  297.     put_byte(pb, 2); /* ??? */

  298. 

  299.     /* file header */

  300.     header_offset = url_ftell(pb);

  301.     hpos = put_header(pb, &file_header);

  302.     put_guid(pb, &my_guid);

  303.     put_le64(pb, file_size);

  304.     file_time = 0;

  305.     put_le64(pb, unix_to_file_time(file_time));

  306.     put_le64(pb, asf->nb_packets); /* number of packets */

  307.     put_le64(pb, asf->duration); /* end time stamp (in 100ns units) */

  308.     put_le64(pb, asf->duration); /* duration (in 100ns units) */

  309.     put_le32(pb, 0); /* start time stamp */

  310.     put_le32(pb, 0); /* ??? */

  311.     put_le32(pb, asf->is_streamed ? 1 : 0); /* ??? */

  312.     put_le32(pb, asf->packet_size); /* packet size */

  313.     put_le32(pb, asf->packet_size); /* packet size */

  314.     put_le32(pb, bit_rate); /* Nominal data rate in bps */

  315.     end_header(pb, hpos);

  316. 

  317.     /* unknown headers */

  318.     hpos = put_header(pb, &head1_guid);

  319.     put_guid(pb, &head2_guid);

  320.     put_le32(pb, 6);

  321.     put_le16(pb, 0);

  322.     end_header(pb, hpos);

  323. 

  324.     /* title and other infos */

  325.     if (has_title) {

  326.         hpos = put_header(pb, &comment_header);

  327.         put_le16(pb, 2 * (strlen(s->title) + 1));

  328.         put_le16(pb, 2 * (strlen(s->author) + 1));

  329.         put_le16(pb, 2 * (strlen(s->copyright) + 1));

  330.         put_le16(pb, 2 * (strlen(s->comment) + 1));

  331.         put_le16(pb, 0);

  332.         put_str16_nolen(pb, s->title);

  333.         put_str16_nolen(pb, s->author);

  334.         put_str16_nolen(pb, s->copyright);

  335.         put_str16_nolen(pb, s->comment);

  336.         end_header(pb, hpos);

  337.     }

  338. 

  339.     /* stream headers */

  340.     for(n=0;n<s->nb_streams;n++) {

  341.         int64_t es_pos;

  342.         //        ASFStream *stream = &asf->streams[n];

  343. 

  344.         enc = &s->streams[n]->codec;

  345.         asf->streams[n].num = n + 1;

  346.         asf->streams[n].seq = 0;

  347. 

  348.         switch(enc->codec_type) {

  349.         case CODEC_TYPE_AUDIO:

  350.             wav_extra_size = 0;

  351.             extra_size = 18 + wav_extra_size;

  352.             extra_size2 = 0;

  353.             break;

  354.         default:

  355.         case CODEC_TYPE_VIDEO:

  356.             wav_extra_size = 0;

  357.             extra_size = 0x33;

  358.             extra_size2 = 0;

  359.             break;

  360.         }

  361. 

  362.         hpos = put_header(pb, &stream_header);

  363.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  364.             put_guid(pb, &audio_stream);

  365.             put_guid(pb, &audio_conceal_none);

  366.         } else {

  367.             put_guid(pb, &video_stream);

  368.             put_guid(pb, &video_conceal_none);

  369.         }

  370.         put_le64(pb, 0); /* ??? */

  371.         es_pos = url_ftell(pb);

  372.         put_le32(pb, extra_size); /* wav header len */

  373.         put_le32(pb, extra_size2); /* additional data len */

  374.         put_le16(pb, n + 1); /* stream number */

  375.         put_le32(pb, 0); /* ??? */

  376. 

  377.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  378.             /* WAVEFORMATEX header */

  379.             int wavsize = put_wav_header(pb, enc);

  380. 

  381.             if (wavsize < 0)

  382.                 return -1;

  383.             if (wavsize != extra_size) {

  384.                 cur_pos = url_ftell(pb);

  385.                 url_fseek(pb, es_pos, SEEK_SET);

  386.                 put_le32(pb, wavsize); /* wav header len */

  387.                 url_fseek(pb, cur_pos, SEEK_SET);

  388.             }

  389.         } else {

  390.             put_le32(pb, enc->width);

  391.             put_le32(pb, enc->height);

  392.             put_byte(pb, 2); /* ??? */

  393.             put_le16(pb, 40); /* size */

  394. 

  395.             /* BITMAPINFOHEADER header */

  396.             put_bmp_header(pb, enc, codec_bmp_tags, 1);

  397.         }

  398.         end_header(pb, hpos);

  399.     }

  400. 

  401.     /* media comments */

  402. 

  403.     hpos = put_header(pb, &codec_comment_header);

  404.     put_guid(pb, &codec_comment1_header);

  405.     put_le32(pb, s->nb_streams);

  406.     for(n=0;n<s->nb_streams;n++) {

  407.         AVCodec *p;

  408. 

  409.         enc = &s->streams[n]->codec;

  410.         p = avcodec_find_encoder(enc->codec_id);

  411. 

  412.         put_le16(pb, asf->streams[n].num);

  413.         put_str16(pb, p ? p->name : enc->codec_name);

  414.         put_le16(pb, 0); /* no parameters */

  415.         

  416.         

  417.         /* id */

  418.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  419.             put_le16(pb, 2);

  420.             if(!enc->codec_tag)

  421.                 enc->codec_tag = codec_get_tag(codec_wav_tags, enc->codec_id);

  422.             if(!enc->codec_tag)

  423.                 return -1;

  424.             put_le16(pb, enc->codec_tag);

  425.         } else {

  426.             put_le16(pb, 4);

  427.             if(!enc->codec_tag)

  428.                 enc->codec_tag = codec_get_tag(codec_bmp_tags, enc->codec_id);

  429.             if(!enc->codec_tag)

  430.                 return -1;

  431.             put_le32(pb, enc->codec_tag);

  432.         }

  433.     }

  434.     end_header(pb, hpos);

  435. 

  436.     /* patch the header size fields */

  437. 

  438.     cur_pos = url_ftell(pb);

  439.     header_size = cur_pos - header_offset;

  440.     if (asf->is_streamed) {

  441.         header_size += 8 + 30 + 50;

  442. 

  443.         url_fseek(pb, header_offset - 10 - 30, SEEK_SET);

  444.         put_le16(pb, header_size);

  445.         url_fseek(pb, header_offset - 2 - 30, SEEK_SET);

  446.         put_le16(pb, header_size);

  447. 

  448.         header_size -= 8 + 30 + 50;

  449.     }

  450.     header_size += 24 + 6;

  451.     url_fseek(pb, header_offset - 14, SEEK_SET);

  452.     put_le64(pb, header_size);

  453.     url_fseek(pb, cur_pos, SEEK_SET);

  454. 

  455.     /* movie chunk, followed by packets of packet_size */

  456.     asf->data_offset = cur_pos;

  457.     put_guid(pb, &data_header);

  458.     put_le64(pb, data_chunk_size);

  459.     put_guid(pb, &my_guid);

  460.     put_le64(pb, asf->nb_packets); /* nb packets */

  461.     put_byte(pb, 1); /* ??? */

  462.     put_byte(pb, 1); /* ??? */

  463.     return 0;

  464. }

  465. 

  466. static int asf_write_header(AVFormatContext *s)

  467. {

  468.     ASFContext *asf = s->priv_data;

  469. 

  470.     av_set_pts_info(s, 32, 1, 1000); /* 32 bit pts in ms */

  471. 

  472.     asf->packet_size = PACKET_SIZE;

  473.     asf->nb_packets = 0;

  474. 

  475.     if (asf_write_header1(s, 0, 50) < 0) {

  476.         //av_free(asf);

  477.         return -1;

  478.     }

  479. 

  480.     put_flush_packet(&s->pb);

  481. 

  482.     asf->packet_nb_frames = 0;

  483.     asf->packet_timestamp_start = -1;

  484.     asf->packet_timestamp_end = -1;

  485.     asf->packet_size_left = asf->packet_size - PACKET_HEADER_SIZE;

  486.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size, 1,

  487.                   NULL, NULL, NULL, NULL);

  488. 

  489.     return 0;

  490. }

  491. 

  492. static int asf_write_stream_header(AVFormatContext *s)

  493. {

  494.     ASFContext *asf = s->priv_data;

  495. 

  496.     asf->is_streamed = 1;

  497. 

  498.     return asf_write_header(s);

  499. }

  500. 

  501. /* write a fixed size packet */

  502. static int put_packet(AVFormatContext *s,

  503.                        unsigned int timestamp, unsigned int duration,

  504.                        int nb_frames, int padsize)

  505. {

  506.     ASFContext *asf = s->priv_data;

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

  508.     int flags;

  509. 

  510.     if (asf->is_streamed) {

  511.         put_chunk(s, 0x4424, asf->packet_size, 0);

  512.     }

  513. 

  514.     put_byte(pb, 0x82);

  515.     put_le16(pb, 0);

  516. 

  517.     flags = 0x01; /* nb segments present */

  518.     if (padsize > 0) {

  519.         if (padsize < 256)

  520.             flags |= 0x08;

  521.         else

  522.             flags |= 0x10;

  523.     }

  524.     put_byte(pb, flags); /* flags */

  525.     put_byte(pb, 0x5d);

  526.     if (flags & 0x10)

  527.         put_le16(pb, padsize - 2);

  528.     if (flags & 0x08)

  529.         put_byte(pb, padsize - 1);

  530.     put_le32(pb, timestamp);

  531.     put_le16(pb, duration);

  532.     put_byte(pb, nb_frames | 0x80);

  533. 

  534.     return PACKET_HEADER_SIZE + ((flags & 0x18) >> 3);

  535. }

  536. 

  537. static void flush_packet(AVFormatContext *s)

  538. {

  539.     ASFContext *asf = s->priv_data;

  540.     int hdr_size, ptr;

  541. 

  542.     hdr_size = put_packet(s, asf->packet_timestamp_start,

  543.                asf->packet_timestamp_end - asf->packet_timestamp_start,

  544.                asf->packet_nb_frames, asf->packet_size_left);

  545. 

  546.     /* Clear out the padding bytes */

  547.     ptr = asf->packet_size - hdr_size - asf->packet_size_left;

  548.     memset(asf->packet_buf + ptr, 0, asf->packet_size_left);

  549. 

  550.     put_buffer(&s->pb, asf->packet_buf, asf->packet_size - hdr_size);

  551. 

  552.     put_flush_packet(&s->pb);

  553.     asf->nb_packets++;

  554.     asf->packet_nb_frames = 0;

  555.     asf->packet_timestamp_start = -1;

  556.     asf->packet_timestamp_end = -1;

  557.     asf->packet_size_left = asf->packet_size - PACKET_HEADER_SIZE;

  558.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size, 1,

  559.                   NULL, NULL, NULL, NULL);

  560. }

  561. 

  562. static void put_frame_header(AVFormatContext *s, ASFStream *stream, int timestamp,

  563.                              int payload_size, int frag_offset, int frag_len)

  564. {

  565.     ASFContext *asf = s->priv_data;

  566.     ByteIOContext *pb = &asf->pb;

  567.     int val;

  568. 

  569.     val = stream->num;

  570.     if (s->streams[val - 1]->codec.coded_frame->key_frame /* && frag_offset == 0 */)

  571.         val |= 0x80;

  572.     put_byte(pb, val);

  573.     put_byte(pb, stream->seq);

  574.     put_le32(pb, frag_offset); /* fragment offset */

  575.     put_byte(pb, 0x08); /* flags */

  576.     put_le32(pb, payload_size);

  577.     put_le32(pb, timestamp);

  578.     put_le16(pb, frag_len);

  579. }

  580. 

  581. 

  582. /* Output a frame. We suppose that payload_size <= PACKET_SIZE.

  583. 

  584.    It is there that you understand that the ASF format is really

  585.    crap. They have misread the MPEG Systems spec !

  586.  */

  587. static void put_frame(AVFormatContext *s, ASFStream *stream, int timestamp,

  588.                       const uint8_t *buf, int payload_size)

  589. {

  590.     ASFContext *asf = s->priv_data;

  591.     int frag_pos, frag_len, frag_len1;

  592. 

  593.     frag_pos = 0;

  594.     while (frag_pos < payload_size) {

  595.         frag_len = payload_size - frag_pos;

  596.         frag_len1 = asf->packet_size_left - FRAME_HEADER_SIZE;

  597.         if (frag_len1 > 0) {

  598.             if (frag_len > frag_len1)

  599.                 frag_len = frag_len1;

  600.             put_frame_header(s, stream, timestamp+1, payload_size, frag_pos, frag_len);

  601.             put_buffer(&asf->pb, buf, frag_len);

  602.             asf->packet_size_left -= (frag_len + FRAME_HEADER_SIZE);

  603.             asf->packet_timestamp_end = timestamp;

  604.             if (asf->packet_timestamp_start == -1)

  605.                 asf->packet_timestamp_start = timestamp;

  606.             asf->packet_nb_frames++;

  607.         } else {

  608.             frag_len = 0;

  609.         }

  610.         frag_pos += frag_len;

  611.         buf += frag_len;

  612.         /* output the frame if filled */

  613.         if (asf->packet_size_left <= FRAME_HEADER_SIZE)

  614.             flush_packet(s);

  615.     }

  616.     stream->seq++;

  617. }

  618. 

  619. 

  620. static int asf_write_packet(AVFormatContext *s, int stream_index,

  621.                             const uint8_t *buf, int size, int64_t timestamp)

  622. {

  623.     ASFContext *asf = s->priv_data;

  624.     ASFStream *stream;

  625.     int64_t duration;

  626.     AVCodecContext *codec;

  627. 

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

  629.     stream = &asf->streams[stream_index];

  630. 

  631.     if (codec->codec_type == CODEC_TYPE_AUDIO) {

  632.         duration = (codec->frame_number * codec->frame_size * int64_t_C(10000000)) /

  633.             codec->sample_rate;

  634.     } else {

  635.         duration = av_rescale(codec->frame_number * codec->frame_rate_base, 10000000, codec->frame_rate);

  636.     }

  637.     if (duration > asf->duration)

  638.         asf->duration = duration;

  639. 

  640.     put_frame(s, stream, timestamp, buf, size);

  641.     return 0;

  642. }

  643. 

  644. static int asf_write_trailer(AVFormatContext *s)

  645. {

  646.     ASFContext *asf = s->priv_data;

  647.     int64_t file_size;

  648. 

  649.     /* flush the current packet */

  650.     if (asf->pb.buf_ptr > asf->pb.buffer)

  651.         flush_packet(s);

  652. 

  653.     if (asf->is_streamed) {

  654.         put_chunk(s, 0x4524, 0, 0); /* end of stream */

  655.     } else {

  656.         /* rewrite an updated header */

  657.         file_size = url_ftell(&s->pb);

  658.         url_fseek(&s->pb, 0, SEEK_SET);

  659.         asf_write_header1(s, file_size, file_size - asf->data_offset);

  660.     }

  661. 

  662.     put_flush_packet(&s->pb);

  663.     return 0;

  664. }

  665. #endif //CONFIG_ENCODERS

  666. 

  667. /**********************************/

  668. /* decoding */

  669. 

  670. //#define DEBUG

  671. 

  672. #ifdef DEBUG

  673. #define PRINT_IF_GUID(g,cmp) \

  674. if (!memcmp(g, &cmp, sizeof(GUID))) \

  675.     printf("(GUID: %s) ", #cmp)

  676. 

  677. static void print_guid(const GUID *g)

  678. {

  679.     int i;

  680.     PRINT_IF_GUID(g, asf_header);

  681.     else PRINT_IF_GUID(g, file_header);

  682.     else PRINT_IF_GUID(g, stream_header);

  683.     else PRINT_IF_GUID(g, audio_stream);

  684.     else PRINT_IF_GUID(g, audio_conceal_none);

  685.     else PRINT_IF_GUID(g, video_stream);

  686.     else PRINT_IF_GUID(g, video_conceal_none);

  687.     else PRINT_IF_GUID(g, comment_header);

  688.     else PRINT_IF_GUID(g, codec_comment_header);

  689.     else PRINT_IF_GUID(g, codec_comment1_header);

  690.     else PRINT_IF_GUID(g, data_header);

  691.     else PRINT_IF_GUID(g, index_guid);

  692.     else PRINT_IF_GUID(g, head1_guid);

  693.     else PRINT_IF_GUID(g, head2_guid);

  694.     else PRINT_IF_GUID(g, my_guid);

  695.     else

  696.         printf("(GUID: unknown) ");

  697.     printf("0x%08x, 0x%04x, 0x%04x, {", g->v1, g->v2, g->v3);

  698.     for(i=0;i<8;i++)

  699.         printf(" 0x%02x,", g->v4[i]);

  700.     printf("}\n");

  701. }

  702. #undef PRINT_IF_GUID(g,cmp)

  703. #endif

  704. 

  705. static void get_guid(ByteIOContext *s, GUID *g)

  706. {

  707.     int i;

  708. 

  709.     g->v1 = get_le32(s);

  710.     g->v2 = get_le16(s);

  711.     g->v3 = get_le16(s);

  712.     for(i=0;i<8;i++)

  713.         g->v4[i] = get_byte(s);

  714. }

  715. 

  716. #if 0

  717. static void get_str16(ByteIOContext *pb, char *buf, int buf_size)

  718. {

  719.     int len, c;

  720.     char *q;

  721. 

  722.     len = get_le16(pb);

  723.     q = buf;

  724.     while (len > 0) {

  725.         c = get_le16(pb);

  726.         if ((q - buf) < buf_size - 1)

  727.             *q++ = c;

  728.         len--;

  729.     }

  730.     *q = '\0';

  731. }

  732. #endif

  733. 

  734. static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size)

  735. {

  736.     int c;

  737.     char *q;

  738. 

  739.     q = buf;

  740.     while (len > 0) {

  741.         c = get_le16(pb);

  742.         if ((q - buf) < buf_size - 1)

  743.             *q++ = c;

  744.         len-=2;

  745.     }

  746.     *q = '\0';

  747. }

  748. 

  749. static int asf_probe(AVProbeData *pd)

  750. {

  751.     GUID g;

  752.     const unsigned char *p;

  753.     int i;

  754. 

  755.     /* check file header */

  756.     if (pd->buf_size <= 32)

  757.         return 0;

  758.     p = pd->buf;

  759.     g.v1 = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);

  760.     p += 4;

  761.     g.v2 = p[0] | (p[1] << 8);

  762.     p += 2;

  763.     g.v3 = p[0] | (p[1] << 8);

  764.     p += 2;

  765.     for(i=0;i<8;i++)

  766.         g.v4[i] = *p++;

  767. 

  768.     if (!memcmp(&g, &asf_header, sizeof(GUID)))

  769.         return AVPROBE_SCORE_MAX;

  770.     else

  771.         return 0;

  772. }

  773. 

  774. static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)

  775. {

  776.     ASFContext *asf = s->priv_data;

  777.     GUID g;

  778.     ByteIOContext *pb = &s->pb;

  779.     AVStream *st;

  780.     ASFStream *asf_st;

  781.     int size, i;

  782.     int64_t gsize;

  783. 

  784.     av_set_pts_info(s, 32, 1, 1000); /* 32 bit pts in ms */

  785. 

  786.     get_guid(pb, &g);

  787.     if (memcmp(&g, &asf_header, sizeof(GUID)))

  788.         goto fail;

  789.     get_le64(pb);

  790.     get_le32(pb);

  791.     get_byte(pb);

  792.     get_byte(pb);

  793.     memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));

  794.     for(;;) {

  795.         get_guid(pb, &g);

  796.         gsize = get_le64(pb);

  797. #ifdef DEBUG

  798.         printf("%08Lx: ", url_ftell(pb) - 24);

  799.         print_guid(&g);

  800.         printf("  size=0x%Lx\n", gsize);

  801. #endif

  802.         if (gsize < 24)

  803.             goto fail;

  804.         if (!memcmp(&g, &file_header, sizeof(GUID))) {

  805.             get_guid(pb, &asf->hdr.guid);

  806. 	    asf->hdr.file_size		= get_le64(pb);

  807. 	    asf->hdr.create_time	= get_le64(pb);

  808. 	    asf->hdr.packets_count	= get_le64(pb);

  809. 	    asf->hdr.play_time		= get_le64(pb);

  810. 	    asf->hdr.send_time		= get_le64(pb);

  811. 	    asf->hdr.preroll		= get_le32(pb);

  812. 	    asf->hdr.ignore		= get_le32(pb);

  813. 	    asf->hdr.flags		= get_le32(pb);

  814. 	    asf->hdr.min_pktsize	= get_le32(pb);

  815. 	    asf->hdr.max_pktsize	= get_le32(pb);

  816. 	    asf->hdr.max_bitrate	= get_le32(pb);

  817. 	    asf->packet_size = asf->hdr.max_pktsize;

  818.             asf->nb_packets = asf->hdr.packets_count;

  819.         } else if (!memcmp(&g, &stream_header, sizeof(GUID))) {

  820.             int type, total_size, type_specific_size;

  821.             unsigned int tag1;

  822.             int64_t pos1, pos2;

  823. 

  824.             pos1 = url_ftell(pb);

  825. 

  826.             st = av_new_stream(s, 0);

  827.             if (!st)

  828.                 goto fail;

  829.             asf_st = av_mallocz(sizeof(ASFStream));

  830.             if (!asf_st)

  831.                 goto fail;

  832.             st->priv_data = asf_st;

  833.             st->start_time = asf->hdr.preroll / (10000000 / AV_TIME_BASE);

  834. 	    st->duration = (asf->hdr.send_time - asf->hdr.preroll) / 

  835.                 (10000000 / AV_TIME_BASE);

  836.             get_guid(pb, &g);

  837.             if (!memcmp(&g, &audio_stream, sizeof(GUID))) {

  838.                 type = CODEC_TYPE_AUDIO;

  839.             } else if (!memcmp(&g, &video_stream, sizeof(GUID))) {

  840.                 type = CODEC_TYPE_VIDEO;

  841.             } else {

  842.                 goto fail;

  843.             }

  844.             get_guid(pb, &g);

  845.             total_size = get_le64(pb);

  846.             type_specific_size = get_le32(pb);

  847.             get_le32(pb);

  848. 	    st->id = get_le16(pb) & 0x7f; /* stream id */

  849.             // mapping of asf ID to AV stream ID;

  850.             asf->asfid2avid[st->id] = s->nb_streams - 1;

  851. 

  852.             get_le32(pb);

  853. 	    st->codec.codec_type = type;

  854.             st->codec.frame_rate = 15 * s->pts_den / s->pts_num; // 15 fps default

  855.             if (type == CODEC_TYPE_AUDIO) {

  856.                 get_wav_header(pb, &st->codec, type_specific_size);

  857. 		/* We have to init the frame size at some point .... */

  858. 		pos2 = url_ftell(pb);

  859. 		if (gsize > (pos2 + 8 - pos1 + 24)) {

  860. 		    asf_st->ds_span = get_byte(pb);

  861. 		    asf_st->ds_packet_size = get_le16(pb);

  862. 		    asf_st->ds_chunk_size = get_le16(pb);

  863. 		    asf_st->ds_data_size = get_le16(pb);

  864. 		    asf_st->ds_silence_data = get_byte(pb);

  865. 		}

  866. 		//printf("Descrambling: ps:%d cs:%d ds:%d s:%d  sd:%d\n",

  867. 		//       asf_st->ds_packet_size, asf_st->ds_chunk_size,

  868. 		//       asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data);

  869. 		if (asf_st->ds_span > 1) {

  870. 		    if (!asf_st->ds_chunk_size

  871. 			|| (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1))

  872. 			asf_st->ds_span = 0; // disable descrambling

  873. 		}

  874.                 switch (st->codec.codec_id) {

  875.                 case CODEC_ID_MP3:

  876.                     st->codec.frame_size = MPA_FRAME_SIZE;

  877.                     break;

  878.                 case CODEC_ID_PCM_S16LE:

  879.                 case CODEC_ID_PCM_S16BE:

  880.                 case CODEC_ID_PCM_U16LE:

  881.                 case CODEC_ID_PCM_U16BE:

  882.                 case CODEC_ID_PCM_S8:

  883.                 case CODEC_ID_PCM_U8:

  884.                 case CODEC_ID_PCM_ALAW:

  885.                 case CODEC_ID_PCM_MULAW:

  886.                     st->codec.frame_size = 1;

  887.                     break;

  888.                 default:

  889.                     /* This is probably wrong, but it prevents a crash later */

  890.                     st->codec.frame_size = 1;

  891.                     break;

  892.                 }

  893.             } else {

  894. 		get_le32(pb);

  895.                 get_le32(pb);

  896.                 get_byte(pb);

  897.                 size = get_le16(pb); /* size */

  898.                 get_le32(pb); /* size */

  899.                 st->codec.width = get_le32(pb);

  900. 		st->codec.height = get_le32(pb);

  901.                 /* not available for asf */

  902.                 get_le16(pb); /* panes */

  903. 		st->codec.bits_per_sample = get_le16(pb); /* depth */

  904.                 tag1 = get_le32(pb);

  905. 		url_fskip(pb, 20);

  906. 		if (size > 40) {

  907. 		    st->codec.extradata_size = size - 40;

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

  909. 		    get_buffer(pb, st->codec.extradata, st->codec.extradata_size);

  910. 		}

  911.                 st->codec.codec_tag = tag1;

  912. 		st->codec.codec_id = codec_get_id(codec_bmp_tags, tag1);

  913.             }

  914.             pos2 = url_ftell(pb);

  915.             url_fskip(pb, gsize - (pos2 - pos1 + 24));

  916.         } else if (!memcmp(&g, &data_header, sizeof(GUID))) {

  917.             break;

  918.         } else if (!memcmp(&g, &comment_header, sizeof(GUID))) {

  919.             int len1, len2, len3, len4, len5;

  920. 

  921.             len1 = get_le16(pb);

  922.             len2 = get_le16(pb);

  923.             len3 = get_le16(pb);

  924.             len4 = get_le16(pb);

  925.             len5 = get_le16(pb);

  926.             get_str16_nolen(pb, len1, s->title, sizeof(s->title));

  927.             get_str16_nolen(pb, len2, s->author, sizeof(s->author));

  928.             get_str16_nolen(pb, len3, s->copyright, sizeof(s->copyright));

  929.             get_str16_nolen(pb, len4, s->comment, sizeof(s->comment));

  930. 	    url_fskip(pb, len5);

  931. #if 0

  932.         } else if (!memcmp(&g, &head1_guid, sizeof(GUID))) {

  933.             int v1, v2;

  934.             get_guid(pb, &g);

  935.             v1 = get_le32(pb);

  936.             v2 = get_le16(pb);

  937.         } else if (!memcmp(&g, &codec_comment_header, sizeof(GUID))) {

  938.             int len, v1, n, num;

  939.             char str[256], *q;

  940.             char tag[16];

  941. 

  942.             get_guid(pb, &g);

  943.             print_guid(&g);

  944. 

  945.             n = get_le32(pb);

  946.             for(i=0;i<n;i++) {

  947.                 num = get_le16(pb); /* stream number */

  948.                 get_str16(pb, str, sizeof(str));

  949.                 get_str16(pb, str, sizeof(str));

  950.                 len = get_le16(pb);

  951.                 q = tag;

  952.                 while (len > 0) {

  953.                     v1 = get_byte(pb);

  954.                     if ((q - tag) < sizeof(tag) - 1)

  955.                         *q++ = v1;

  956.                     len--;

  957.                 }

  958.                 *q = '\0';

  959.             }

  960. #endif

  961.         } else if (url_feof(pb)) {

  962.             goto fail;

  963.         } else {

  964.             url_fseek(pb, gsize - 24, SEEK_CUR);

  965.         }

  966.     }

  967.     get_guid(pb, &g);

  968.     get_le64(pb);

  969.     get_byte(pb);

  970.     get_byte(pb);

  971.     if (url_feof(pb))

  972.         goto fail;

  973.     asf->data_offset = url_ftell(pb);

  974.     asf->packet_size_left = 0;

  975. 

  976.     return 0;

  977. 

  978.  fail:

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

  980.         AVStream *st = s->streams[i];

  981. 	if (st) {

  982. 	    av_free(st->priv_data);

  983.             av_free(st->codec.extradata);

  984. 	}

  985.         av_free(st);

  986.     }

  987.     return -1;

  988. }

  989. 

  990. #define DO_2BITS(bits, var, defval) \

  991.     switch (bits & 3) \

  992.     { \

  993.     case 3: var = get_le32(pb); rsize += 4; break; \

  994.     case 2: var = get_le16(pb); rsize += 2; break; \

  995.     case 1: var = get_byte(pb); rsize++; break; \

  996.     default: var = defval; break; \

  997.     }

  998. 

  999. static int asf_get_packet(AVFormatContext *s)

  1000. {

  1001.     ASFContext *asf = s->priv_data;

  1002.     ByteIOContext *pb = &s->pb;

  1003.     uint32_t packet_length, padsize;

  1004.     int rsize = 11;

  1005.     int c = get_byte(pb);

  1006.     if (c != 0x82) {

  1007.         if (!url_feof(pb))

  1008. 	    printf("ff asf bad header %x  at:%lld\n", c, url_ftell(pb));

  1009. 	return -EIO;

  1010.     }

  1011.     if ((c & 0x0f) == 2) { // always true for now

  1012. 	if (get_le16(pb) != 0) {

  1013.             if (!url_feof(pb))

  1014. 		printf("ff asf bad non zero\n");

  1015. 	    return -EIO;

  1016. 	}

  1017.     }

  1018. 

  1019.     asf->packet_flags = get_byte(pb);

  1020.     asf->packet_property = get_byte(pb);

  1021. 

  1022.     DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size);

  1023.     DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored

  1024.     DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length

  1025. 

  1026.     asf->packet_timestamp = get_le32(pb);

  1027.     get_le16(pb); /* duration */

  1028.     // rsize has at least 11 bytes which have to be present

  1029. 

  1030.     if (asf->packet_flags & 0x01) {

  1031. 	asf->packet_segsizetype = get_byte(pb); rsize++;

  1032.         asf->packet_segments = asf->packet_segsizetype & 0x3f;

  1033.     } else {

  1034. 	asf->packet_segments = 1;

  1035.         asf->packet_segsizetype = 0x80;

  1036.     }

  1037.     asf->packet_size_left = packet_length - padsize - rsize;

  1038.     if (packet_length < asf->hdr.min_pktsize)

  1039.         padsize += asf->hdr.min_pktsize - packet_length;

  1040.     asf->packet_padsize = padsize;

  1041. #ifdef DEBUG

  1042.     printf("packet: size=%d padsize=%d  left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left);

  1043. #endif

  1044.     return 0;

  1045. }

  1046. 

  1047. static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)

  1048. {

  1049.     ASFContext *asf = s->priv_data;

  1050.     ASFStream *asf_st = 0;

  1051.     ByteIOContext *pb = &s->pb;

  1052.     //static int pc = 0;

  1053.     for (;;) {

  1054. 	int rsize = 0;

  1055. 	if (asf->packet_size_left < FRAME_HEADER_SIZE

  1056. 	    || asf->packet_segments < 1) {

  1057. 	    //asf->packet_size_left <= asf->packet_padsize) {

  1058. 	    int ret = asf->packet_size_left + asf->packet_padsize;

  1059. 	    //printf("PacketLeftSize:%d  Pad:%d Pos:%Ld\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb));

  1060. 	    /* fail safe */

  1061. 	    url_fskip(pb, ret);

  1062. 	    ret = asf_get_packet(s);

  1063. 	    //printf("READ ASF PACKET  %d   r:%d   c:%d\n", ret, asf->packet_size_left, pc++);

  1064. 	    if (ret < 0 || url_feof(pb))

  1065. 		return -EIO;

  1066.             asf->packet_time_start = 0;

  1067.             continue;

  1068. 	}

  1069. 	if (asf->packet_time_start == 0) {

  1070. 	    /* read frame header */

  1071.             int num = get_byte(pb);

  1072. 	    asf->packet_segments--;

  1073. 	    rsize++;

  1074. 	    asf->packet_key_frame = (num & 0x80) >> 7;

  1075. 	    asf->stream_index = asf->asfid2avid[num & 0x7f];

  1076. 	    // sequence should be ignored!

  1077. 	    DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);

  1078. 	    DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);

  1079. 	    DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);

  1080. 

  1081. 	    if (asf->packet_replic_size > 1) {

  1082.                 // it should be always at least 8 bytes - FIXME validate

  1083. 		asf->packet_obj_size = get_le32(pb);

  1084. 		asf->packet_frag_timestamp = get_le32(pb); // timestamp

  1085. 		if (asf->packet_replic_size > 8)

  1086. 		    url_fskip(pb, asf->packet_replic_size - 8);

  1087. 		rsize += asf->packet_replic_size; // FIXME - check validity

  1088. 	    } else {

  1089. 		// multipacket - frag_offset is begining timestamp

  1090. 		asf->packet_time_start = asf->packet_frag_offset;

  1091.                 asf->packet_frag_offset = 0;

  1092. 		asf->packet_frag_timestamp = asf->packet_timestamp;

  1093. 

  1094. 		if (asf->packet_replic_size == 1) {

  1095. 		    asf->packet_time_delta = get_byte(pb);

  1096. 		    rsize++;

  1097. 		}

  1098. 	    }

  1099. 	    if (asf->packet_flags & 0x01) {

  1100. 		DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal

  1101. #undef DO_2BITS

  1102. 		//printf("Fragsize %d\n", asf->packet_frag_size);

  1103. 	    } else {

  1104. 		asf->packet_frag_size = asf->packet_size_left - rsize;

  1105. 		//printf("Using rest  %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);

  1106. 	    }

  1107. 	    if (asf->packet_replic_size == 1) {

  1108. 		asf->packet_multi_size = asf->packet_frag_size;

  1109. 		if (asf->packet_multi_size > asf->packet_size_left) {

  1110. 		    asf->packet_segments = 0;

  1111.                     continue;

  1112. 		}

  1113. 	    }

  1114. 	    asf->packet_size_left -= rsize;

  1115. 	    //printf("___objsize____  %d   %d    rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize);

  1116. 

  1117. 	    if (asf->stream_index < 0) {

  1118.                 asf->packet_time_start = 0;

  1119. 		/* unhandled packet (should not happen) */

  1120. 		url_fskip(pb, asf->packet_frag_size);

  1121. 		asf->packet_size_left -= asf->packet_frag_size;

  1122. 		printf("ff asf skip %d  %d\n", asf->packet_frag_size, num & 0x7f);

  1123.                 continue;

  1124. 	    }

  1125. 	    asf->asf_st = s->streams[asf->stream_index]->priv_data;

  1126. 	}

  1127. 	asf_st = asf->asf_st;

  1128. 

  1129. 	if ((asf->packet_frag_offset != asf_st->frag_offset

  1130. 	     || (asf->packet_frag_offset

  1131. 		 && asf->packet_seq != asf_st->seq)) // seq should be ignored

  1132. 	   ) {

  1133. 	    /* cannot continue current packet: free it */

  1134. 	    // FIXME better check if packet was already allocated

  1135. 	    printf("ff asf parser skips: %d - %d     o:%d - %d    %d %d   fl:%d\n",

  1136. 		   asf_st->pkt.size,

  1137. 		   asf->packet_obj_size,

  1138. 		   asf->packet_frag_offset, asf_st->frag_offset,

  1139. 		   asf->packet_seq, asf_st->seq, asf->packet_frag_size);

  1140. 	    if (asf_st->pkt.size)

  1141. 		av_free_packet(&asf_st->pkt);

  1142. 	    asf_st->frag_offset = 0;

  1143. 	    if (asf->packet_frag_offset != 0) {

  1144. 		url_fskip(pb, asf->packet_frag_size);

  1145. 		printf("ff asf parser skiping %db\n", asf->packet_frag_size);

  1146. 		asf->packet_size_left -= asf->packet_frag_size;

  1147. 		continue;

  1148. 	    }

  1149. 	}

  1150. 	if (asf->packet_replic_size == 1) {

  1151. 	    // frag_offset is here used as the begining timestamp

  1152. 	    asf->packet_frag_timestamp = asf->packet_time_start;

  1153. 	    asf->packet_time_start += asf->packet_time_delta;

  1154. 	    asf->packet_obj_size = asf->packet_frag_size = get_byte(pb);

  1155. 	    asf->packet_size_left--;

  1156.             asf->packet_multi_size--;

  1157. 	    if (asf->packet_multi_size < asf->packet_obj_size)

  1158. 	    {

  1159. 		asf->packet_time_start = 0;

  1160. 		url_fskip(pb, asf->packet_multi_size);

  1161. 		asf->packet_size_left -= asf->packet_multi_size;

  1162.                 continue;

  1163. 	    }

  1164. 	    asf->packet_multi_size -= asf->packet_obj_size;

  1165. 	    //printf("COMPRESS size  %d  %d  %d   ms:%d\n", asf->packet_obj_size, asf->packet_frag_timestamp, asf->packet_size_left, asf->packet_multi_size);

  1166. 	}

  1167. 	if (asf_st->frag_offset == 0) {

  1168. 	    /* new packet */

  1169. 	    av_new_packet(&asf_st->pkt, asf->packet_obj_size);

  1170. 	    asf_st->seq = asf->packet_seq;

  1171. 	    asf_st->pkt.pts = asf->packet_frag_timestamp - asf->hdr.preroll;

  1172. 	    asf_st->pkt.stream_index = asf->stream_index;

  1173. 	    if (asf->packet_key_frame)

  1174. 		asf_st->pkt.flags |= PKT_FLAG_KEY;

  1175. 	}

  1176. 

  1177. 	/* read data */

  1178. 	//printf("READ PACKET s:%d  os:%d  o:%d,%d  l:%d   DATA:%p\n",

  1179. 	//       asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset,

  1180. 	//       asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);

  1181. 	asf->packet_size_left -= asf->packet_frag_size;

  1182. 	if (asf->packet_size_left < 0)

  1183.             continue;

  1184. 	get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset,

  1185. 		   asf->packet_frag_size);

  1186. 	asf_st->frag_offset += asf->packet_frag_size;

  1187. 	/* test if whole packet is read */

  1188. 	if (asf_st->frag_offset == asf_st->pkt.size) {

  1189. 	    /* return packet */

  1190. 	    if (asf_st->ds_span > 1) {

  1191. 		/* packet descrambling */

  1192. 		char* newdata = av_malloc(asf_st->pkt.size);

  1193. 		if (newdata) {

  1194. 		    int offset = 0;

  1195. 		    while (offset < asf_st->pkt.size) {

  1196. 			int off = offset / asf_st->ds_chunk_size;

  1197. 			int row = off / asf_st->ds_span;

  1198. 			int col = off % asf_st->ds_span;

  1199. 			int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;

  1200. 			//printf("off:%d  row:%d  col:%d  idx:%d\n", off, row, col, idx);

  1201. 			memcpy(newdata + offset,

  1202. 			       asf_st->pkt.data + idx * asf_st->ds_chunk_size,

  1203. 			       asf_st->ds_chunk_size);

  1204. 			offset += asf_st->ds_chunk_size;

  1205. 		    }

  1206. 		    av_free(asf_st->pkt.data);

  1207. 		    asf_st->pkt.data = newdata;

  1208. 		}

  1209. 	    }

  1210. 	    asf_st->frag_offset = 0;

  1211. 	    memcpy(pkt, &asf_st->pkt, sizeof(AVPacket));

  1212. 	    //printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);

  1213. 	    asf_st->pkt.size = 0;

  1214. 	    asf_st->pkt.data = 0;

  1215. 	    break; // packet completed

  1216. 	}

  1217.     }

  1218.     return 0;

  1219. }

  1220. 

  1221. static int asf_read_close(AVFormatContext *s)

  1222. {

  1223.     int i;

  1224. 

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

  1226. 	AVStream *st = s->streams[i];

  1227. 	av_free(st->priv_data);

  1228. 	av_free(st->codec.extradata);

  1229.     }

  1230.     return 0;

  1231. }

  1232. 

  1233. static int asf_read_seek(AVFormatContext *s, int64_t pts)

  1234. {

  1235.     printf("SEEK TO %lld", pts);

  1236.     return -1;

  1237. }

  1238. 

  1239. static AVInputFormat asf_iformat = {

  1240.     "asf",

  1241.     "asf format",

  1242.     sizeof(ASFContext),

  1243.     asf_probe,

  1244.     asf_read_header,

  1245.     asf_read_packet,

  1246.     asf_read_close,

  1247.     asf_read_seek,

  1248. };

  1249. 

  1250. #ifdef CONFIG_ENCODERS

  1251. static AVOutputFormat asf_oformat = {

  1252.     "asf",

  1253.     "asf format",

  1254.     "video/x-ms-asf",

  1255.     "asf,wmv",

  1256.     sizeof(ASFContext),

  1257. #ifdef CONFIG_MP3LAME

  1258.     CODEC_ID_MP3,

  1259. #else

  1260.     CODEC_ID_MP2,

  1261. #endif

  1262.     CODEC_ID_MSMPEG4V3,

  1263.     asf_write_header,

  1264.     asf_write_packet,

  1265.     asf_write_trailer,

  1266. };

  1267. 

  1268. static AVOutputFormat asf_stream_oformat = {

  1269.     "asf_stream",

  1270.     "asf format",

  1271.     "video/x-ms-asf",

  1272.     "asf,wmv",

  1273.     sizeof(ASFContext),

  1274. #ifdef CONFIG_MP3LAME

  1275.     CODEC_ID_MP3,

  1276. #else

  1277.     CODEC_ID_MP2,

  1278. #endif

  1279.     CODEC_ID_MSMPEG4V3,

  1280.     asf_write_stream_header,

  1281.     asf_write_packet,

  1282.     asf_write_trailer,

  1283. };

  1284. #endif //CONFIG_ENCODERS

  1285. 

  1286. int asf_init(void)

  1287. {

  1288.     av_register_input_format(&asf_iformat);

  1289. #ifdef CONFIG_ENCODERS

  1290.     av_register_output_format(&asf_oformat);

  1291.     av_register_output_format(&asf_stream_oformat);

  1292. #endif //CONFIG_ENCODERS

  1293.     return 0;

  1294. }