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

893 lines
29KB
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, comment_header);

  55.     else PRINT_IF_GUID(g, codec_comment_header);

  56.     else PRINT_IF_GUID(g, codec_comment1_header);

  57.     else PRINT_IF_GUID(g, data_header);

  58.     else PRINT_IF_GUID(g, index_guid);

  59.     else PRINT_IF_GUID(g, head1_guid);

  60.     else PRINT_IF_GUID(g, head2_guid);

  61.     else PRINT_IF_GUID(g, my_guid);

  62.     else

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

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

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

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

  67.     printf("}\n");

  68. }

  69. #undef PRINT_IF_GUID(g,cmp)

  70. #endif

  71. 

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

  73. {

  74.     int i;

  75. 

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

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

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

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

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

  81. }

  82. 

  83. #if 0

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

  85. {

  86.     int len, c;

  87.     char *q;

  88. 

  89.     len = get_le16(pb);

  90.     q = buf;

  91.     while (len > 0) {

  92.         c = get_le16(pb);

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

  94.             *q++ = c;

  95.         len--;

  96.     }

  97.     *q = '\0';

  98. }

  99. #endif

  100. 

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

  102. {

  103.     int c;

  104.     char *q;

  105. 

  106.     q = buf;

  107.     while (len > 0) {

  108.         c = get_le16(pb);

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

  110.             *q++ = c;

  111.         len-=2;

  112.     }

  113.     *q = '\0';

  114. }

  115. 

  116. static int asf_probe(AVProbeData *pd)

  117. {

  118.     GUID g;

  119.     const unsigned char *p;

  120.     int i;

  121. 

  122.     /* check file header */

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

  124.         return 0;

  125.     p = pd->buf;

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

  127.     p += 4;

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

  129.     p += 2;

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

  131.     p += 2;

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

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

  134. 

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

  136.         return AVPROBE_SCORE_MAX;

  137.     else

  138.         return 0;

  139. }

  140. 

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

  142. {

  143.     ASFContext *asf = s->priv_data;

  144.     GUID g;

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

  146.     AVStream *st;

  147.     ASFStream *asf_st;

  148.     int size, i;

  149.     int64_t gsize;

  150. 

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

  152. 

  153.     get_guid(pb, &g);

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

  155.         goto fail;

  156.     get_le64(pb);

  157.     get_le32(pb);

  158.     get_byte(pb);

  159.     get_byte(pb);

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

  161.     for(;;) {

  162.         get_guid(pb, &g);

  163.         gsize = get_le64(pb);

  164. #ifdef DEBUG

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

  166.         print_guid(&g);

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

  168. #endif

  169.         if (gsize < 24)

  170.             goto fail;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  187.             int type, total_size, type_specific_size;

  188.             unsigned int tag1;

  189.             int64_t pos1, pos2;

  190. 

  191.             pos1 = url_ftell(pb);

  192. 

  193.             st = av_new_stream(s, 0);

  194.             if (!st)

  195.                 goto fail;

  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 / (10000000 / AV_TIME_BASE);

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

  202.                 (10000000 / AV_TIME_BASE);

  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 {

  209.                 goto fail;

  210.             }

  211.             get_guid(pb, &g);

  212.             total_size = get_le64(pb);

  213.             type_specific_size = get_le32(pb);

  214.             get_le32(pb);

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

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

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

  218. 

  219.             get_le32(pb);

  220. 	    st->codec.codec_type = type;

  221.             /* 1 fps default (XXX: put 0 fps instead) */

  222.             st->codec.frame_rate = 1; 

  223.             st->codec.frame_rate_base = 1;

  224.             if (type == CODEC_TYPE_AUDIO) {

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

  226.                 st->need_parsing = 1;

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

  228. 		pos2 = url_ftell(pb);

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

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

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

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

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

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

  235. 		}

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

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

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

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

  240. 		    if (!asf_st->ds_chunk_size

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

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

  243. 		}

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

  245.                 case CODEC_ID_MP3:

  246.                     st->codec.frame_size = MPA_FRAME_SIZE;

  247.                     break;

  248.                 case CODEC_ID_PCM_S16LE:

  249.                 case CODEC_ID_PCM_S16BE:

  250.                 case CODEC_ID_PCM_U16LE:

  251.                 case CODEC_ID_PCM_U16BE:

  252.                 case CODEC_ID_PCM_S8:

  253.                 case CODEC_ID_PCM_U8:

  254.                 case CODEC_ID_PCM_ALAW:

  255.                 case CODEC_ID_PCM_MULAW:

  256.                     st->codec.frame_size = 1;

  257.                     break;

  258.                 default:

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

  260.                     st->codec.frame_size = 1;

  261.                     break;

  262.                 }

  263.             } else {

  264. 		get_le32(pb);

  265.                 get_le32(pb);

  266.                 get_byte(pb);

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

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

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

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

  271.                 /* not available for asf */

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

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

  274.                 tag1 = get_le32(pb);

  275. 		url_fskip(pb, 20);

  276. 		if (size > 40) {

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

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

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

  280. 		}

  281. 

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

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

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

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

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

  287. #ifdef WORDS_BIGENDIAN

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

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

  290. #else

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

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

  293. #endif

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

  295.         }

  296. 

  297.                 st->codec.codec_tag = tag1;

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

  299.             }

  300.             pos2 = url_ftell(pb);

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

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

  303.             break;

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

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

  306. 

  307.             len1 = get_le16(pb);

  308.             len2 = get_le16(pb);

  309.             len3 = get_le16(pb);

  310.             len4 = get_le16(pb);

  311.             len5 = get_le16(pb);

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

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

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

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

  316. 	    url_fskip(pb, len5);

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

  318.                 int desc_count, i;

  319. 

  320.                 desc_count = get_le16(pb);

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

  322.                 {

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

  324.                         char *name, *value;

  325. 

  326.                         name_len = get_le16(pb);

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

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

  329.                         value_type = get_le16(pb);

  330.                         value_len = get_le16(pb);

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

  332.                         {

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

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

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

  336.                                 av_free(value);

  337.                         }

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

  339.                         {

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

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

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

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

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

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

  346.                         }

  347.                         av_free(name);

  348.                 }

  349. #if 0

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

  351.             int v1, v2;

  352.             get_guid(pb, &g);

  353.             v1 = get_le32(pb);

  354.             v2 = get_le16(pb);

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

  356.             int len, v1, n, num;

  357.             char str[256], *q;

  358.             char tag[16];

  359. 

  360.             get_guid(pb, &g);

  361.             print_guid(&g);

  362. 

  363.             n = get_le32(pb);

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

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

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

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

  368.                 len = get_le16(pb);

  369.                 q = tag;

  370.                 while (len > 0) {

  371.                     v1 = get_byte(pb);

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

  373.                         *q++ = v1;

  374.                     len--;

  375.                 }

  376.                 *q = '\0';

  377.             }

  378. #endif

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

  380.             goto fail;

  381.         } else {

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

  383.         }

  384.     }

  385.     get_guid(pb, &g);

  386.     get_le64(pb);

  387.     get_byte(pb);

  388.     get_byte(pb);

  389.     if (url_feof(pb))

  390.         goto fail;

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

  392.     asf->packet_size_left = 0;

  393. 

  394.     return 0;

  395. 

  396.  fail:

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

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

  399. 	if (st) {

  400. 	    av_free(st->priv_data);

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

  402. 	}

  403.         av_free(st);

  404.     }

  405.     return -1;

  406. }

  407. 

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

  409.     switch (bits & 3) \

  410.     { \

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

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

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

  414.     default: var = defval; break; \

  415.     }

  416. 

  417. static int asf_get_packet(AVFormatContext *s)

  418. {

  419.     ASFContext *asf = s->priv_data;

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

  421.     uint32_t packet_length, padsize;

  422.     int rsize = 9;

  423.     int c;

  424.     

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

  426.     

  427.     c = get_byte(pb);

  428.     if (c != 0x82) {

  429.         if (!url_feof(pb))

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

  431.     }

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

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

  434.             if (!url_feof(pb))

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

  436. 	    return -EIO;

  437. 	}

  438.         rsize+=2;

  439. /*    }else{

  440.         if (!url_feof(pb))

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

  442. 	return -EIO;*/

  443.     }

  444. 

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

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

  447. 

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

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

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

  451. 

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

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

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

  455. 

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

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

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

  459.     } else {

  460. 	asf->packet_segments = 1;

  461.         asf->packet_segsizetype = 0x80;

  462.     }

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

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

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

  466.     asf->packet_padsize = padsize;

  467. #ifdef DEBUG

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

  469. #endif

  470.     return 0;

  471. }

  472. 

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

  474. {

  475.     ASFContext *asf = s->priv_data;

  476.     ASFStream *asf_st = 0;

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

  478.     //static int pc = 0;

  479.     for (;;) {

  480. 	int rsize = 0;

  481. 	if (asf->packet_size_left < FRAME_HEADER_SIZE

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

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

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

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

  486. 	    /* fail safe */

  487. 	    url_fskip(pb, ret);

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

  489. 	    ret = asf_get_packet(s);

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

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

  492. 		return -EIO;

  493.             asf->packet_time_start = 0;

  494.             continue;

  495. 	}

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

  497. 	    /* read frame header */

  498.             int num = get_byte(pb);

  499. 	    asf->packet_segments--;

  500. 	    rsize++;

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

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

  503. 	    // sequence should be ignored!

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

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

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

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

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

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

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

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

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

  513. 		if (asf->packet_replic_size > 8)

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

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

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

  517. 		// multipacket - frag_offset is begining timestamp

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

  519.                 asf->packet_frag_offset = 0;

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

  521. 

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

  523. 		rsize++;

  524. 	    }else{

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

  526.             }

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

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

  529. #undef DO_2BITS

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

  531. 	    } else {

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

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

  534. 	    }

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

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

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

  538. 		    asf->packet_segments = 0;

  539.                     continue;

  540. 		}

  541. 	    }

  542. 	    asf->packet_size_left -= rsize;

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

  544. 

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

  546.                 asf->packet_time_start = 0;

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

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

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

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

  551.                 continue;

  552. 	    }

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

  554. 	}

  555. 	asf_st = asf->asf_st;

  556. 

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

  558. 	     || (asf->packet_frag_offset

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

  560. 	   ) {

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

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

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

  564. 		   asf_st->pkt.size,

  565. 		   asf->packet_obj_size,

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

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

  568. 	    if (asf_st->pkt.size)

  569. 		av_free_packet(&asf_st->pkt);

  570. 	    asf_st->frag_offset = 0;

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

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

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

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

  575. 		continue;

  576. 	    }

  577. 	}

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

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

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

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

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

  583. 	    asf->packet_size_left--;

  584.             asf->packet_multi_size--;

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

  586. 	    {

  587. 		asf->packet_time_start = 0;

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

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

  590.                 continue;

  591. 	    }

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

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

  594. 	}

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

  596. 	    /* new packet */

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

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

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

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

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

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

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

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

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

  606. 		asf->packet_key_frame = 1;

  607. 	    if (asf->packet_key_frame)

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

  609. 	}

  610. 

  611. 	/* read data */

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

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

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

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

  616. 	if (asf->packet_size_left < 0)

  617.             continue;

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

  619. 		   asf->packet_frag_size);

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

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

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

  623. 	    /* return packet */

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

  625. 		/* packet descrambling */

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

  627. 		if (newdata) {

  628. 		    int offset = 0;

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

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

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

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

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

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

  635. 			memcpy(newdata + offset,

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

  637. 			       asf_st->ds_chunk_size);

  638. 			offset += asf_st->ds_chunk_size;

  639. 		    }

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

  641. 		    asf_st->pkt.data = newdata;

  642. 		}

  643. 	    }

  644. 	    asf_st->frag_offset = 0;

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

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

  647. 	    asf_st->pkt.size = 0;

  648. 	    asf_st->pkt.data = 0;

  649. 	    break; // packet completed

  650. 	}

  651.     }

  652.     return 0;

  653. }

  654. 

  655. static int asf_read_close(AVFormatContext *s)

  656. {

  657.     int i;

  658. 

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

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

  661. 	av_free(st->priv_data);

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

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

  664.     }

  665.     return 0;

  666. }

  667. 

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

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

  670. // leftover information from previous reads

  671. static void asf_reset_header(AVFormatContext *s)

  672. {

  673.     ASFContext *asf = s->priv_data;

  674.     ASFStream *asf_st;

  675.     int i;

  676. 

  677.     asf->packet_nb_frames = 0;

  678.     asf->packet_timestamp_start = -1;

  679.     asf->packet_timestamp_end = -1;

  680.     asf->packet_size_left = 0;

  681.     asf->packet_segments = 0;

  682.     asf->packet_flags = 0;

  683.     asf->packet_property = 0;

  684.     asf->packet_timestamp = 0;

  685.     asf->packet_segsizetype = 0;

  686.     asf->packet_segments = 0;

  687.     asf->packet_seq = 0;

  688.     asf->packet_replic_size = 0;

  689.     asf->packet_key_frame = 0;

  690.     asf->packet_padsize = 0;

  691.     asf->packet_frag_offset = 0;

  692.     asf->packet_frag_size = 0;

  693.     asf->packet_frag_timestamp = 0;

  694.     asf->packet_multi_size = 0;

  695.     asf->packet_obj_size = 0;

  696.     asf->packet_time_delta = 0;

  697.     asf->packet_time_start = 0;

  698.     

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

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

  701.         av_free_packet(&asf_st->pkt);

  702.         asf_st->frag_offset=0;

  703.         asf_st->seq=0;

  704.     }

  705.     asf->asf_st= NULL;

  706. }

  707. 

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

  709. {

  710.     ASFContext *asf = s->priv_data;

  711.     AVPacket pkt1, *pkt = &pkt1;

  712.     ASFStream *asf_st;

  713.     int64_t pts;

  714.     int64_t pos= *ppos;

  715.     int i;

  716.     int64_t start_pos[s->nb_streams];

  717.     

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

  719.         start_pos[i]= pos;

  720.     }

  721. 

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

  723.     url_fseek(&s->pb, pos*asf->packet_size + s->data_offset, SEEK_SET);

  724.     asf_reset_header(s);

  725.     for(;;){

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

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

  728.     	    return AV_NOPTS_VALUE;

  729.         }

  730.         pts= pkt->pts;

  731. 

  732.         av_free_packet(pkt);

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

  734.             i= pkt->stream_index;

  735. 

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

  737. 

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

  739.             pos= (asf_st->packet_pos - s->data_offset) / asf->packet_size;

  740. 

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

  742.             start_pos[i]= pos + 1;

  743.             

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

  745.                break;

  746.         }

  747.     }

  748. 

  749.     *ppos= pos;

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

  751. 

  752.     return pts;

  753. }

  754. 

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

  756. {

  757.     ASFContext *asf = s->priv_data;

  758.     AVStream *st;

  759.     int64_t pos;

  760.     int64_t pos_min, pos_max, pts_min, pts_max, cur_pts, pos_limit;

  761.     int no_change;

  762.     

  763.     if (stream_index == -1)

  764.         stream_index= av_find_default_stream_index(s);

  765.     

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

  767.         return -1;

  768. 

  769.     pts_max=

  770.     pts_min= AV_NOPTS_VALUE;

  771.     pos_max= pos_limit= -1; // gcc thinks its uninitalized

  772. 

  773.     st= s->streams[stream_index];

  774.     if(st->index_entries){

  775.         AVIndexEntry *e;

  776.         int index;

  777. 

  778.         index= av_index_search_timestamp(st, pts);

  779.         e= &st->index_entries[index];

  780.         if(e->timestamp <= pts){

  781.             pos_min= e->pos;

  782.             pts_min= e->timestamp;

  783. #ifdef DEBUG_SEEK

  784.         printf("unsing cached pos_min=0x%llx dts_min=%0.3f\n", 

  785.                pos_min,pts_min / 90000.0);

  786. #endif

  787.         }else{

  788.             assert(index==0);

  789.         }

  790.         index++;

  791.         if(index < st->nb_index_entries){

  792.             e= &st->index_entries[index];

  793.             assert(e->timestamp >= pts);

  794.             pos_max= e->pos;

  795.             pts_max= e->timestamp;

  796.             pos_limit= pos_max - e->min_distance;

  797. #ifdef DEBUG_SEEK

  798.         printf("unsing cached pos_max=0x%llx dts_max=%0.3f\n", 

  799.                pos_max,pts_max / 90000.0);

  800. #endif

  801.         }

  802.     }

  803. 

  804.     if(pts_min == AV_NOPTS_VALUE){

  805.         pos_min = 0;

  806.         pts_min = asf_read_pts(s, &pos_min, stream_index);

  807.         if (pts_min == AV_NOPTS_VALUE) return -1;

  808.     }

  809.     if(pts_max == AV_NOPTS_VALUE){

  810.         pos_max = (url_filesize(url_fileno(&s->pb)) - 1 - s->data_offset) / asf->packet_size; //FIXME wrong

  811.         pts_max = s->duration; //FIXME wrong

  812.         pos_limit= pos_max;

  813.     } 

  814. 

  815.     no_change=0;

  816.     while (pos_min < pos_limit) {

  817.         int64_t start_pos;

  818.         assert(pos_limit <= pos_max);

  819. 

  820.         if(no_change==0){

  821.             int64_t approximate_keyframe_distance= pos_max - pos_limit;

  822.             // interpolate position (better than dichotomy)

  823.             pos = (int64_t)((double)(pos_max - pos_min) *

  824.                             (double)(pts - pts_min) /

  825.                             (double)(pts_max - pts_min)) + pos_min - approximate_keyframe_distance;

  826.         }else if(no_change==1){

  827.             // bisection, if interpolation failed to change min or max pos last time

  828.             pos = (pos_min + pos_limit)>>1;

  829.         }else{

  830.             // linear search if bisection failed, can only happen if there are very few or no keyframes between min/max

  831.             pos=pos_min;

  832.         }

  833.         if(pos <= pos_min)

  834.             pos= pos_min + 1;

  835.         else if(pos > pos_limit)

  836.             pos= pos_limit;

  837.         start_pos= pos;

  838. 

  839.         // read the next timestamp 

  840.     	cur_pts = asf_read_pts(s, &pos, stream_index);    

  841.         if(pos == pos_max)

  842.             no_change++;

  843.         else

  844.             no_change=0;

  845. 

  846. #ifdef DEBUG_SEEK

  847. printf("%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld\n", pos_min, pos, pos_max, pts_min, cur_pts, pts_max, pts, pos_limit, start_pos);

  848. #endif

  849.         assert (cur_pts != AV_NOPTS_VALUE);

  850.         if (pts < cur_pts) {

  851.             pos_limit = start_pos - 1;

  852.             pos_max = pos;

  853.             pts_max = cur_pts;

  854.         } else {

  855.             pos_min = pos;

  856.             pts_min = cur_pts;

  857.             /* check if we are lucky */

  858.             if (pts == cur_pts)

  859.                 break;

  860.         }

  861.     }

  862.     pos = pos_min;

  863.     url_fseek(&s->pb, pos*asf->packet_size + s->data_offset, SEEK_SET);

  864.     asf_reset_header(s);

  865.     return 0;

  866. }

  867. 

  868. static AVInputFormat asf_iformat = {

  869.     "asf",

  870.     "asf format",

  871.     sizeof(ASFContext),

  872.     asf_probe,

  873.     asf_read_header,

  874.     asf_read_packet,

  875.     asf_read_close,

  876.     asf_read_seek,

  877. };

  878. 

  879. #ifdef CONFIG_ENCODERS

  880.     extern AVOutputFormat asf_oformat;

  881.     extern AVOutputFormat asf_stream_oformat;

  882. #endif //CONFIG_ENCODERS

  883. 

  884. int asf_init(void)

  885. {

  886.     av_register_input_format(&asf_iformat);

  887. #ifdef CONFIG_ENCODERS

  888.     av_register_output_format(&asf_oformat);

  889.     av_register_output_format(&asf_stream_oformat);

  890. #endif //CONFIG_ENCODERS

  891.     return 0;

  892. }