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

809 lines
27KB
Raw Blame History 

  1. /*

  2.  * ASF compatible 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. #include "asf.h"

  23. 

  24. #undef NDEBUG

  25. #include <assert.h>

  26. 

  27. #define FRAME_HEADER_SIZE 17

  28. // Fix Me! FRAME_HEADER_SIZE may be different. 

  29. 

  30. static const GUID index_guid = {

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

  32. };

  33. 

  34. /**********************************/

  35. /* decoding */

  36. 

  37. //#define DEBUG

  38. 

  39. #ifdef DEBUG

  40. #define PRINT_IF_GUID(g,cmp) \

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

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

  43. 

  44. static void print_guid(const GUID *g)

  45. {

  46.     int i;

  47.     PRINT_IF_GUID(g, asf_header);

  48.     else PRINT_IF_GUID(g, file_header);

  49.     else PRINT_IF_GUID(g, stream_header);

  50.     else PRINT_IF_GUID(g, audio_stream);

  51.     else PRINT_IF_GUID(g, audio_conceal_none);

  52.     else PRINT_IF_GUID(g, video_stream);

  53.     else PRINT_IF_GUID(g, video_conceal_none);

  54.     else PRINT_IF_GUID(g, command_stream);

  55.     else PRINT_IF_GUID(g, comment_header);

  56.     else PRINT_IF_GUID(g, codec_comment_header);

  57.     else PRINT_IF_GUID(g, codec_comment1_header);

  58.     else PRINT_IF_GUID(g, data_header);

  59.     else PRINT_IF_GUID(g, index_guid);

  60.     else PRINT_IF_GUID(g, head1_guid);

  61.     else PRINT_IF_GUID(g, head2_guid);

  62.     else PRINT_IF_GUID(g, my_guid);

  63.     else

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

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

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

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

  68.     printf("}\n");

  69. }

  70. #undef PRINT_IF_GUID(g,cmp)

  71. #endif

  72. 

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

  74. {

  75.     int i;

  76. 

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

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

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

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

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

  82. }

  83. 

  84. #if 0

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

  86. {

  87.     int len, c;

  88.     char *q;

  89. 

  90.     len = get_le16(pb);

  91.     q = buf;

  92.     while (len > 0) {

  93.         c = get_le16(pb);

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

  95.             *q++ = c;

  96.         len--;

  97.     }

  98.     *q = '\0';

  99. }

  100. #endif

  101. 

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

  103. {

  104.     int c;

  105.     char *q;

  106. 

  107.     q = buf;

  108.     while (len > 0) {

  109.         c = get_le16(pb);

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

  111.             *q++ = c;

  112.         len-=2;

  113.     }

  114.     *q = '\0';

  115. }

  116. 

  117. static int asf_probe(AVProbeData *pd)

  118. {

  119.     GUID g;

  120.     const unsigned char *p;

  121.     int i;

  122. 

  123.     /* check file header */

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

  125.         return 0;

  126.     p = pd->buf;

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

  128.     p += 4;

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

  130.     p += 2;

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

  132.     p += 2;

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

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

  135. 

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

  137.         return AVPROBE_SCORE_MAX;

  138.     else

  139.         return 0;

  140. }

  141. 

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

  143. {

  144.     ASFContext *asf = s->priv_data;

  145.     GUID g;

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

  147.     AVStream *st;

  148.     ASFStream *asf_st;

  149.     int size, i;

  150.     int64_t gsize;

  151. 

  152.     get_guid(pb, &g);

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

  154.         goto fail;

  155.     get_le64(pb);

  156.     get_le32(pb);

  157.     get_byte(pb);

  158.     get_byte(pb);

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

  160.     for(;;) {

  161.         get_guid(pb, &g);

  162.         gsize = get_le64(pb);

  163. #ifdef DEBUG

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

  165.         print_guid(&g);

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

  167. #endif

  168.         if (gsize < 24)

  169.             goto fail;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  186.             int type, total_size, type_specific_size, sizeX;

  187.             unsigned int tag1;

  188.             int64_t pos1, pos2;

  189. 

  190.             pos1 = url_ftell(pb);

  191. 

  192.             st = av_new_stream(s, 0);

  193.             if (!st)

  194.                 goto fail;

  195.             av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */

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

  197.             if (!asf_st)

  198.                 goto fail;

  199.             st->priv_data = asf_st;

  200.             st->start_time = asf->hdr.preroll;

  201.             st->duration = asf->hdr.send_time / 

  202.                 (10000000 / 1000) - st->start_time;

  203.             get_guid(pb, &g);

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

  205.                 type = CODEC_TYPE_AUDIO;

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

  207.                 type = CODEC_TYPE_VIDEO;

  208.             } else if (!memcmp(&g, &command_stream, sizeof(GUID))) {

  209.                 type = CODEC_TYPE_UNKNOWN;

  210.             } else {

  211.                 goto fail;

  212.             }

  213.             get_guid(pb, &g);

  214.             total_size = get_le64(pb);

  215.             type_specific_size = get_le32(pb);

  216.             get_le32(pb);

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

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

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

  220. 

  221.             get_le32(pb);

  222. 	    st->codec->codec_type = type;

  223.             if (type == CODEC_TYPE_AUDIO) {

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

  225.                 st->need_parsing = 1;

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

  227. 		pos2 = url_ftell(pb);

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

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

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

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

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

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

  234. 		}

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

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

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

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

  239. 		    if (!asf_st->ds_chunk_size

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

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

  242. 		}

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

  244.                 case CODEC_ID_MP3:

  245.                     st->codec->frame_size = MPA_FRAME_SIZE;

  246.                     break;

  247.                 case CODEC_ID_PCM_S16LE:

  248.                 case CODEC_ID_PCM_S16BE:

  249.                 case CODEC_ID_PCM_U16LE:

  250.                 case CODEC_ID_PCM_U16BE:

  251.                 case CODEC_ID_PCM_S8:

  252.                 case CODEC_ID_PCM_U8:

  253.                 case CODEC_ID_PCM_ALAW:

  254.                 case CODEC_ID_PCM_MULAW:

  255.                     st->codec->frame_size = 1;

  256.                     break;

  257.                 default:

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

  259.                     st->codec->frame_size = 1;

  260.                     break;

  261.                 }

  262.             } else {

  263. 		get_le32(pb);

  264.                 get_le32(pb);

  265.                 get_byte(pb);

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

  267.                 sizeX= get_le32(pb); /* size */

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

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

  270.                 /* not available for asf */

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

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

  273.                 tag1 = get_le32(pb);

  274. 		url_fskip(pb, 20);

  275. //                av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);

  276.                 size= sizeX;

  277. 		if (size > 40) {

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

  279. 		    st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

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

  281. 		}

  282. 

  283.         /* Extract palette from extradata if bpp <= 8 */

  284.         /* This code assumes that extradata contains only palette */

  285.         /* This is true for all paletted codecs implemented in ffmpeg */

  286.         if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) {

  287.             st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));

  288. #ifdef WORDS_BIGENDIAN

  289.             for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)

  290.                 st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);

  291. #else

  292.             memcpy(st->codec->palctrl->palette, st->codec->extradata,

  293.                    FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));

  294. #endif

  295.             st->codec->palctrl->palette_changed = 1;

  296.         }

  297. 

  298.                 st->codec->codec_tag = tag1;

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

  300.                 if(tag1 == MKTAG('D', 'V', 'R', ' '))

  301.                     st->need_parsing = 1;

  302.             }

  303.             pos2 = url_ftell(pb);

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

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

  306.             break;

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

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

  309. 

  310.             len1 = get_le16(pb);

  311.             len2 = get_le16(pb);

  312.             len3 = get_le16(pb);

  313.             len4 = get_le16(pb);

  314.             len5 = get_le16(pb);

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

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

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

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

  319. 	    url_fskip(pb, len5);

  320.        } else if (!memcmp(&g, &extended_content_header, sizeof(GUID))) {

  321.                 int desc_count, i;

  322. 

  323.                 desc_count = get_le16(pb);

  324.                 for(i=0;i<desc_count;i++)

  325.                 {

  326.                         int name_len,value_type,value_len,value_num = 0;

  327.                         char *name, *value;

  328. 

  329.                         name_len = get_le16(pb);

  330.                         name = (char *)av_mallocz(name_len);

  331.                         get_str16_nolen(pb, name_len, name, name_len);

  332.                         value_type = get_le16(pb);

  333.                         value_len = get_le16(pb);

  334.                         if ((value_type == 0) || (value_type == 1)) // unicode or byte

  335.                         {

  336.                                 value = (char *)av_mallocz(value_len);

  337.                                 get_str16_nolen(pb, value_len, value, value_len);

  338.                                 if (strcmp(name,"WM/AlbumTitle")==0) { pstrcpy(s->album, sizeof(s->album), value); }

  339.                                 av_free(value);

  340.                         }

  341.                         if ((value_type >= 2) && (value_type <= 5)) // boolean or DWORD or QWORD or WORD

  342.                         {

  343.                                 if (value_type==2) value_num = get_le32(pb);

  344.                                 if (value_type==3) value_num = get_le32(pb);

  345.                                 if (value_type==4) value_num = get_le64(pb);

  346.                                 if (value_type==5) value_num = get_le16(pb);

  347.                                 if (strcmp(name,"WM/Track")==0) s->track = value_num + 1;

  348.                                 if (strcmp(name,"WM/TrackNumber")==0) s->track = value_num;

  349.                         }

  350.                         av_free(name);

  351.                 }

  352. #if 0

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

  354.             int v1, v2;

  355.             get_guid(pb, &g);

  356.             v1 = get_le32(pb);

  357.             v2 = get_le16(pb);

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

  359.             int len, v1, n, num;

  360.             char str[256], *q;

  361.             char tag[16];

  362. 

  363.             get_guid(pb, &g);

  364.             print_guid(&g);

  365. 

  366.             n = get_le32(pb);

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

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

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

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

  371.                 len = get_le16(pb);

  372.                 q = tag;

  373.                 while (len > 0) {

  374.                     v1 = get_byte(pb);

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

  376.                         *q++ = v1;

  377.                     len--;

  378.                 }

  379.                 *q = '\0';

  380.             }

  381. #endif

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

  383.             goto fail;

  384.         } else {

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

  386.         }

  387.     }

  388.     get_guid(pb, &g);

  389.     get_le64(pb);

  390.     get_byte(pb);

  391.     get_byte(pb);

  392.     if (url_feof(pb))

  393.         goto fail;

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

  395.     asf->packet_size_left = 0;

  396. 

  397.     return 0;

  398. 

  399.  fail:

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

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

  402. 	if (st) {

  403. 	    av_free(st->priv_data);

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

  405. 	}

  406.         av_free(st);

  407.     }

  408.     return -1;

  409. }

  410. 

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

  412.     switch (bits & 3) \

  413.     { \

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

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

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

  417.     default: var = defval; break; \

  418.     }

  419. 

  420. static int asf_get_packet(AVFormatContext *s)

  421. {

  422.     ASFContext *asf = s->priv_data;

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

  424.     uint32_t packet_length, padsize;

  425.     int rsize = 9;

  426.     int c;

  427.     

  428.     assert((url_ftell(&s->pb) - s->data_offset) % asf->packet_size == 0);

  429.     

  430.     c = get_byte(pb);

  431.     if (c != 0x82) {

  432.         if (!url_feof(pb))

  433. 	    av_log(s, AV_LOG_ERROR, "ff asf bad header %x  at:%lld\n", c, url_ftell(pb));

  434.     }

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

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

  437.             if (!url_feof(pb))

  438. 		av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");

  439. 	    return AVERROR_IO;

  440. 	}

  441.         rsize+=2;

  442. /*    }else{

  443.         if (!url_feof(pb))

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

  445. 	return AVERROR_IO;*/

  446.     }

  447. 

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

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

  450. 

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

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

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

  454. 

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

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

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

  458. 

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

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

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

  462.     } else {

  463. 	asf->packet_segments = 1;

  464.         asf->packet_segsizetype = 0x80;

  465.     }

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

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

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

  469.     asf->packet_padsize = padsize;

  470. #ifdef DEBUG

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

  472. #endif

  473.     return 0;

  474. }

  475. 

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

  477. {

  478.     ASFContext *asf = s->priv_data;

  479.     ASFStream *asf_st = 0;

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

  481.     //static int pc = 0;

  482.     for (;;) {

  483. 	int rsize = 0;

  484. 	if (asf->packet_size_left < FRAME_HEADER_SIZE

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

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

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

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

  489.             if((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size)

  490.                 ret += asf->packet_size - ((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size);

  491. 	    /* fail safe */

  492. 	    url_fskip(pb, ret);

  493.             asf->packet_pos= url_ftell(&s->pb);

  494. 	    ret = asf_get_packet(s);

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

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

  497. 		return AVERROR_IO;

  498.             asf->packet_time_start = 0;

  499.             continue;

  500. 	}

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

  502. 	    /* read frame header */

  503.             int num = get_byte(pb);

  504. 	    asf->packet_segments--;

  505. 	    rsize++;

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

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

  508. 	    // sequence should be ignored!

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

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

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

  512. //printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size);

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

  514.                 assert(asf->packet_replic_size >= 8);

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

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

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

  518. 		if (asf->packet_replic_size > 8)

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

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

  521. 	    } else if (asf->packet_replic_size==1){

  522. 		// multipacket - frag_offset is begining timestamp

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

  524.                 asf->packet_frag_offset = 0;

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

  526. 

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

  528. 		rsize++;

  529. 	    }else{

  530.                 assert(asf->packet_replic_size==0);

  531.             }

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

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

  534. #undef DO_2BITS

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

  536. 	    } else {

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

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

  539. 	    }

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

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

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

  543. 		    asf->packet_segments = 0;

  544.                     continue;

  545. 		}

  546. 	    }

  547. 	    asf->packet_size_left -= rsize;

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

  549. 

  550. 	    if (asf->stream_index < 0

  551.                 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL

  552.                 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)

  553.                 ) {

  554.                 asf->packet_time_start = 0;

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

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

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

  558.                 if(asf->stream_index < 0)

  559.                     av_log(s, AV_LOG_ERROR, "ff asf skip %d  %d\n", asf->packet_frag_size, num & 0x7f);

  560.                 continue;

  561. 	    }

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

  563. 	}

  564. 	asf_st = asf->asf_st;

  565. 

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

  567. 	     || (asf->packet_frag_offset

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

  569. 	   ) {

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

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

  572. 	    av_log(s, AV_LOG_INFO, "ff asf parser skips: %d - %d     o:%d - %d    %d %d   fl:%d\n",

  573. 		   asf_st->pkt.size,

  574. 		   asf->packet_obj_size,

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

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

  577. 	    if (asf_st->pkt.size)

  578. 		av_free_packet(&asf_st->pkt);

  579. 	    asf_st->frag_offset = 0;

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

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

  582. 		av_log(s, AV_LOG_INFO, "ff asf parser skipping %db\n", asf->packet_frag_size);

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

  584. 		continue;

  585. 	    }

  586. 	}

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

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

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

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

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

  592. 	    asf->packet_size_left--;

  593.             asf->packet_multi_size--;

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

  595. 	    {

  596. 		asf->packet_time_start = 0;

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

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

  599.                 continue;

  600. 	    }

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

  602. 	    //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);

  603. 	}

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

  605. 	    /* new packet */

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

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

  608. 	    asf_st->pkt.pts = asf->packet_frag_timestamp;

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

  610.             asf_st->pkt.pos = 

  611.             asf_st->packet_pos= asf->packet_pos;            

  612. //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n", 

  613. //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,

  614. //s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);

  615. 	    if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO) 

  616. 		asf->packet_key_frame = 1;

  617. 	    if (asf->packet_key_frame)

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

  619. 	}

  620. 

  621. 	/* read data */

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

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

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

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

  626. 	if (asf->packet_size_left < 0)

  627.             continue;

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

  629. 		   asf->packet_frag_size);

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

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

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

  633. 	    /* return packet */

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

  635. 		/* packet descrambling */

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

  637. 		if (newdata) {

  638. 		    int offset = 0;

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

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

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

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

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

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

  645. 			memcpy(newdata + offset,

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

  647. 			       asf_st->ds_chunk_size);

  648. 			offset += asf_st->ds_chunk_size;

  649. 		    }

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

  651. 		    asf_st->pkt.data = newdata;

  652. 		}

  653. 	    }

  654. 	    asf_st->frag_offset = 0;

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

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

  657. 	    asf_st->pkt.size = 0;

  658. 	    asf_st->pkt.data = 0;

  659. 	    break; // packet completed

  660. 	}

  661.     }

  662.     return 0;

  663. }

  664. 

  665. static int asf_read_close(AVFormatContext *s)

  666. {

  667.     int i;

  668. 

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

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

  671. 	av_free(st->priv_data);

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

  673.     av_free(st->codec->palctrl);

  674.     }

  675.     return 0;

  676. }

  677. 

  678. // Added to support seeking after packets have been read

  679. // If information is not reset, read_packet fails due to

  680. // leftover information from previous reads

  681. static void asf_reset_header(AVFormatContext *s)

  682. {

  683.     ASFContext *asf = s->priv_data;

  684.     ASFStream *asf_st;

  685.     int i;

  686. 

  687.     asf->packet_nb_frames = 0;

  688.     asf->packet_timestamp_start = -1;

  689.     asf->packet_timestamp_end = -1;

  690.     asf->packet_size_left = 0;

  691.     asf->packet_segments = 0;

  692.     asf->packet_flags = 0;

  693.     asf->packet_property = 0;

  694.     asf->packet_timestamp = 0;

  695.     asf->packet_segsizetype = 0;

  696.     asf->packet_segments = 0;

  697.     asf->packet_seq = 0;

  698.     asf->packet_replic_size = 0;

  699.     asf->packet_key_frame = 0;

  700.     asf->packet_padsize = 0;

  701.     asf->packet_frag_offset = 0;

  702.     asf->packet_frag_size = 0;

  703.     asf->packet_frag_timestamp = 0;

  704.     asf->packet_multi_size = 0;

  705.     asf->packet_obj_size = 0;

  706.     asf->packet_time_delta = 0;

  707.     asf->packet_time_start = 0;

  708.     

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

  710.         asf_st= s->streams[i]->priv_data;

  711.         av_free_packet(&asf_st->pkt);

  712.         asf_st->frag_offset=0;

  713.         asf_st->seq=0;

  714.     }

  715.     asf->asf_st= NULL;

  716. }

  717. 

  718. static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)

  719. {

  720.     ASFContext *asf = s->priv_data;

  721.     AVPacket pkt1, *pkt = &pkt1;

  722.     ASFStream *asf_st;

  723.     int64_t pts;

  724.     int64_t pos= *ppos;

  725.     int i;

  726.     int64_t start_pos[s->nb_streams];

  727.     

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

  729.         start_pos[i]= pos;

  730.     }

  731.     

  732.     pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset;

  733.     *ppos= pos;

  734.     url_fseek(&s->pb, pos, SEEK_SET);

  735.     

  736. //printf("asf_read_pts\n");

  737.     asf_reset_header(s);

  738.     for(;;){

  739.         if (av_read_frame(s, pkt) < 0){

  740.             av_log(s, AV_LOG_INFO, "seek failed\n");

  741.     	    return AV_NOPTS_VALUE;

  742.         }

  743.         

  744.         pts= pkt->pts * 1000 / AV_TIME_BASE;

  745. 

  746.         av_free_packet(pkt);

  747.         if(pkt->flags&PKT_FLAG_KEY){

  748.             i= pkt->stream_index;

  749. 

  750.             asf_st= s->streams[i]->priv_data;

  751. 

  752.             assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0);

  753.             pos= asf_st->packet_pos;

  754. 

  755.             av_add_index_entry(s->streams[i], pos, pts, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);

  756.             start_pos[i]= asf_st->packet_pos + 1;

  757.             

  758.             if(pkt->stream_index == stream_index)

  759.                break;

  760.         }

  761.     }

  762. 

  763.     *ppos= pos;

  764. //printf("found keyframe at %Ld stream %d stamp:%Ld\n", *ppos, stream_index, pts);

  765. 

  766.     return pts;

  767. }

  768. 

  769. static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)

  770. {

  771.     ASFContext *asf = s->priv_data;

  772.     

  773.     if (asf->packet_size <= 0)

  774.         return -1;

  775. 

  776.     if(av_seek_frame_binary(s, stream_index, pts, flags)<0)

  777.         return -1;

  778. 

  779.     asf_reset_header(s);

  780.     return 0;

  781. }

  782. 

  783. static AVInputFormat asf_iformat = {

  784.     "asf",

  785.     "asf format",

  786.     sizeof(ASFContext),

  787.     asf_probe,

  788.     asf_read_header,

  789.     asf_read_packet,

  790.     asf_read_close,

  791.     asf_read_seek,

  792.     asf_read_pts,

  793. };

  794. 

  795. #ifdef CONFIG_MUXERS

  796.     extern AVOutputFormat asf_oformat;

  797.     extern AVOutputFormat asf_stream_oformat;

  798. #endif //CONFIG_MUXERS

  799. 

  800. int asf_init(void)

  801. {

  802.     av_register_input_format(&asf_iformat);

  803. #ifdef CONFIG_MUXERS

  804.     av_register_output_format(&asf_oformat);

  805.     av_register_output_format(&asf_stream_oformat);

  806. #endif //CONFIG_MUXERS

  807.     return 0;

  808. }