2 * ASF file parser for DEMUXER v0.3
3 * copyright (c) 2001 A'rpi/ESP-team
5 * This file is part of MPlayer.
7 * MPlayer is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * MPlayer is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
31 #include "stream/stream.h"
35 #include "libvo/fastmemcpy.h"
36 #include "libavutil/intreadwrite.h"
38 // defined at asfheader.c:
40 int asf_check_header(demuxer_t
*demuxer
);
41 int read_asf_header(demuxer_t
*demuxer
,struct asf_priv
* asf
);
43 // based on asf file-format doc by Eugene [http://divx.euro.ru]
46 * \brief reads int stored in number of bytes given by len
47 * \param ptr pointer to read from, is incremented appropriately
48 * \param len lowest 2 bits indicate number of bytes to read
49 * \param def default value to return if len is invalid
51 static inline unsigned read_varlen(uint8_t **ptr
, int len
, int def
) {
52 const uint8_t *p
= *ptr
;
55 case 1: *ptr
+= 1; return *p
;
56 case 2: *ptr
+= 2; return AV_RL16(p
);
57 case 3: *ptr
+= 4; return AV_RL32(p
);
63 * \brief checks if there is enough data to read the bytes given by len
64 * \param ptr pointer to read from
65 * \param endptr pointer to the end of the buffer
66 * \param len lowest 2 bits indicate number of bytes to read
68 static inline int check_varlen(uint8_t *ptr
, uint8_t *endptr
, int len
) {
69 return len
&3 ? ptr
+ (1<<((len
&3) - 1)) <= endptr
: 1;
72 static void asf_descrambling(unsigned char **src
,unsigned len
, struct asf_priv
* asf
){
74 unsigned char *s2
=*src
;
76 if (len
> UINT_MAX
- MP_INPUT_BUFFER_PADDING_SIZE
)
78 dst
= malloc(len
+ MP_INPUT_BUFFER_PADDING_SIZE
);
79 while(len
>=asf
->scrambling_h
*asf
->scrambling_w
*asf
->scrambling_b
+i
){
80 // mp_msg(MSGT_DEMUX,MSGL_DBG4,"descrambling! (w=%d b=%d)\n",w,asf_scrambling_b);
81 //i+=asf_scrambling_h*asf_scrambling_w;
82 for(x
=0;x
<asf
->scrambling_w
;x
++)
83 for(y
=0;y
<asf
->scrambling_h
;y
++){
84 fast_memcpy(dst
+i
,s2
+(y
*asf
->scrambling_w
+x
)*asf
->scrambling_b
,asf
->scrambling_b
);
87 s2
+=asf
->scrambling_h
*asf
->scrambling_w
*asf
->scrambling_b
;
89 //if(i<len) fast_memcpy(dst+i,src+i,len-i);
94 /*****************************************************************
95 * \brief initializes asf private data
98 static void init_priv (struct asf_priv
* asf
){
100 asf
->vid_ext_timing_index
=-1;
101 asf
->aud_ext_timing_index
=-1;
102 asf
->vid_ext_frame_index
=-1;
105 static void demux_asf_append_to_packet(demux_packet_t
* dp
,unsigned char *data
,int len
,int offs
)
107 if(dp
->len
!=offs
&& offs
!=-1) mp_msg(MSGT_DEMUX
,MSGL_V
,"warning! fragment.len=%d BUT next fragment offset=%d \n",dp
->len
,offs
);
108 dp
->buffer
=realloc(dp
->buffer
,dp
->len
+len
+MP_INPUT_BUFFER_PADDING_SIZE
);
109 fast_memcpy(dp
->buffer
+dp
->len
,data
,len
);
110 memset(dp
->buffer
+dp
->len
+len
, 0, MP_INPUT_BUFFER_PADDING_SIZE
);
111 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"data appended! %d+%d\n",dp
->len
,len
);
115 static int demux_asf_read_packet(demuxer_t
*demux
,unsigned char *data
,int len
,int id
,int seq
,uint64_t time
,unsigned short dur
,int offs
,int keyframe
){
116 struct asf_priv
* asf
= demux
->priv
;
117 demux_stream_t
*ds
=NULL
;
120 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"demux_asf.read_packet: id=%d seq=%d len=%d\n",id
,seq
,len
);
122 if(demux
->video
->id
==-1)
123 if(demux
->v_streams
[id
])
126 if(demux
->audio
->id
==-1)
127 if(demux
->a_streams
[id
])
130 if(id
==demux
->audio
->id
){
134 ds
->sh
=demux
->a_streams
[id
];
135 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected ASF audio ID = %d\n",ds
->id
);
138 if(id
==demux
->video
->id
){
142 ds
->sh
=demux
->v_streams
[id
];
143 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected ASF video ID = %d\n",ds
->id
);
149 demux_packet_t
* dp
=ds
->asf_packet
;
151 if (ds
==demux
->video
&& asf
->asf_is_dvr_ms
) {
152 if (asf
->new_vid_frame_seg
) {
153 dp
->pos
=demux
->filepos
;
155 } else seq
= ds
->asf_seq
;
156 } else close_seg
= ds
->asf_seq
!=seq
;
159 // closed segment, finalize packet:
161 if(asf
->scrambling_h
>1 && asf
->scrambling_w
>1 && asf
->scrambling_b
>0)
162 asf_descrambling(&ds
->asf_packet
->buffer
,ds
->asf_packet
->len
,asf
);
163 ds_add_packet(ds
,ds
->asf_packet
);
166 // append data to it!
167 demux_asf_append_to_packet(dp
,data
,len
,offs
);
172 // create new packet:
173 { demux_packet_t
* dp
;
175 mp_msg(MSGT_DEMUX
,MSGL_V
,"warning! broken fragment, %d bytes missing \n",offs
);
178 dp
=new_demux_packet(len
);
179 fast_memcpy(dp
->buffer
,data
,len
);
180 if (asf
->asf_is_dvr_ms
)
181 dp
->pts
=time
*0.0000001;
185 // if(ds==demux->video) printf("ASF time: %8d dur: %5d \n",time,dur);
186 dp
->pos
=demux
->filepos
;
197 /*****************************************************************
198 * \brief read the replicated data associated with each segment
199 * \parameter pp reference to replicated data
200 * \parameter id stream number
201 * \parameter seq media object number
202 * \parameter keyframe key frame indicator - set to zero if keyframe, non-zero otherwise
203 * \parameter seg_time set to payload time when valid, if audio or new video frame payload, zero otherwise
206 static void get_payload_extension_data(demuxer_t
*demux
, unsigned char** pp
, unsigned char id
, unsigned int seq
, int *keyframe
, uint64_t *seg_time
){
207 struct asf_priv
* asf
= demux
->priv
;
208 uint64_t payload_time
; //100ns units
209 int i
, ext_max
, ext_timing_index
;
212 if(demux
->video
->id
==-1)
213 if(demux
->v_streams
[id
])
216 if(demux
->audio
->id
==-1)
217 if(demux
->a_streams
[id
])
220 if (id
!=demux
->video
->id
&& id
!=demux
->audio
->id
) return;
222 if (id
==demux
->video
->id
) {
223 ext_max
= asf
->vid_repdata_count
;
224 ext_timing_index
= asf
->vid_ext_timing_index
;
226 ext_max
= asf
->aud_repdata_count
;
227 ext_timing_index
= asf
->aud_ext_timing_index
;
231 asf
->new_vid_frame_seg
= 0;
233 for (i
=0; i
<ext_max
; i
++) {
235 uint8_t segment_marker
;
237 if (id
==demux
->video
->id
)
238 payextsize
= asf
->vid_repdata_sizes
[i
];
240 payextsize
= asf
->aud_repdata_sizes
[i
];
242 if (payextsize
== 65535) {
243 payextsize
= AV_RL16(pi
);
247 // if this is the timing info extension then read the payload time
248 if (i
== ext_timing_index
)
249 payload_time
= AV_RL64(pi
+8);
251 // if this is the video frame info extension then
252 // set the keyframe indicator, the 'new frame segment' indicator
253 // and (initially) the 'frame time'
254 if (i
== asf
->vid_ext_frame_index
&& id
==demux
->video
->id
) {
255 segment_marker
= pi
[0];
256 // Known video stream segment_marker values that
257 // contain useful information:
259 // NTSC/ATSC (29.97fps): 0X4A 01001010
263 // PAL/ATSC (25fps): 0X3A 00111010
267 // ATSC progressive (29.97fps): 0X7A 01111010
271 // ^ this is new video frame marker
273 // ^^^^ these bits indicate the framerate
274 // 0X4 is 29.97i, 0X3 is 25i, 0X7 is 29.97p, ???=25p
276 // ^^^ these bits indicate the frame type:
278 // 010 and 011 probably mean P and B
280 asf
->new_vid_frame_seg
= (0X08 & segment_marker
) && seq
!= asf
->last_vid_seq
;
282 if (asf
->new_vid_frame_seg
) asf
->last_vid_seq
= seq
;
284 if (asf
->avg_vid_frame_time
== 0) {
285 // set the average frame time initially (in 100ns units).
286 // This is based on what works for known samples.
287 // It can be extended if more samples of different types can be obtained.
288 if (((segment_marker
& 0XF0) >> 4) == 4) {
289 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 30.0) * 10000000.0);
290 asf
->know_frame_time
=1;
291 } else if (((segment_marker
& 0XF0) >> 4) == 3) {
292 asf
->avg_vid_frame_time
= (uint64_t)(0.04 * 10000000.0);
293 asf
->know_frame_time
=1;
294 } else if (((segment_marker
& 0XF0) >> 4) == 6) {
295 asf
->avg_vid_frame_time
= (uint64_t)(0.02 * 10000000.0);
296 asf
->know_frame_time
=1;
297 } else if (((segment_marker
& 0XF0) >> 4) == 7) {
298 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 60.0) * 10000000.0);
299 asf
->know_frame_time
=1;
301 // we dont know the frame time initially so
302 // make a guess and then recalculate as we go.
303 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 60.0) * 10000000.0);
304 asf
->know_frame_time
=0;
307 *keyframe
= (asf
->new_vid_frame_seg
&& (segment_marker
& 0X07) == 1);
312 if (id
==demux
->video
->id
&& asf
->new_vid_frame_seg
) {
314 // Some samples only have timings on key frames and
315 // the rest contain non-cronological timestamps. Interpolating
316 // the values between key frames works for all samples.
318 asf
->found_first_key_frame
=1;
319 if (!asf
->know_frame_time
&& asf
->last_key_payload_time
> 0) {
320 // We dont know average frametime so recalculate.
321 // Giving precedence to the 'weight' of the existing
322 // average limits damage done to new value when there is
323 // a sudden time jump which happens occasionally.
324 asf
->avg_vid_frame_time
=
325 (0.9 * asf
->avg_vid_frame_time
) +
326 (0.1 * ((payload_time
- asf
->last_key_payload_time
) / asf
->vid_frame_ct
));
328 asf
->last_key_payload_time
= payload_time
;
329 asf
->vid_frame_ct
= 1;
330 *seg_time
= payload_time
;
332 *seg_time
= (asf
->last_key_payload_time
+ (asf
->avg_vid_frame_time
* (asf
->vid_frame_ct
-1)));
335 if (id
==demux
->audio
->id
) {
336 if (payload_time
!= -1)
337 asf
->last_aud_diff
= payload_time
- asf
->last_aud_pts
;
338 asf
->last_aud_pts
+= asf
->last_aud_diff
;
339 *seg_time
= asf
->last_aud_pts
;
342 //static int num_elementary_packets100=0;
343 //static int num_elementary_packets101=0;
346 // 0 = EOF or no stream found
347 // 1 = successfully read a packet
348 static int demux_asf_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
){
349 struct asf_priv
* asf
= demux
->priv
;
351 demux
->filepos
=stream_tell(demux
->stream
);
352 // Brodcast stream have movi_start==movi_end
354 if((demux
->movi_start
< demux
->movi_end
) && (demux
->filepos
>=demux
->movi_end
)){
355 demux
->stream
->eof
=1;
359 stream_read(demux
->stream
,asf
->packet
,asf
->packetsize
);
360 if(demux
->stream
->eof
) return 0; // EOF
361 if(asf
->packetsize
< 2) return 0; // Packet too short
364 unsigned char* p
=asf
->packet
;
365 unsigned char* p_end
=asf
->packet
+asf
->packetsize
;
366 unsigned char flags
=p
[0];
367 unsigned char segtype
=p
[1];
371 unsigned long time
=0;
372 unsigned short duration
=0;
375 unsigned char segsizetype
=0x80;
378 if( mp_msg_test(MSGT_DEMUX
,MSGL_DBG2
) ){
380 for(i
=0;i
<FFMIN(16, asf
->packetsize
);i
++) printf(" %02X",asf
->packet
[i
]);
384 // skip ECC data if present by testing bit 7 of flags
385 // 1xxxbbbb -> ecc data present, skip bbbb byte(s)
386 // 0xxxxxxx -> payload parsing info starts
389 p
+= (flags
& 0x0f)+1;
390 if (p
+1 >= p_end
) return 0; // Packet too short
395 //if(segtype!=0x5d) printf("Warning! packet[4] != 0x5d \n");
397 p
+=2; // skip flags & segtype
399 // Read packet size (plen):
400 if(!check_varlen(p
, p_end
, flags
>> 5)) return 0; // Not enough data
401 plen
= read_varlen(&p
, flags
>> 5, 0);
404 if(!check_varlen(p
, p_end
, flags
>> 1)) return 0; // Not enough data
405 sequence
= read_varlen(&p
, flags
>> 1, 0);
407 // Read padding size (padding):
408 if(!check_varlen(p
, p_end
, flags
>> 3)) return 0; // Not enough data
409 padding
= read_varlen(&p
, flags
>> 3, 0);
411 if(((flags
>>5)&3)!=0){
412 // Explicit (absoulte) packet size
413 mp_dbg(MSGT_DEMUX
,MSGL_DBG2
,"Explicit packet size specified: %d \n",plen
);
414 if(plen
>asf
->packetsize
) mp_msg(MSGT_DEMUX
,MSGL_V
,"Warning! plen>packetsize! (%d>%d) \n",plen
,asf
->packetsize
);
416 // Padding (relative) size
417 plen
=asf
->packetsize
-padding
;
420 // Read time & duration:
421 if (p
+5 >= p_end
) return 0; // Packet too short
422 time
= AV_RL32(p
); p
+=4;
423 duration
= AV_RL16(p
); p
+=2;
425 // Read payload flags:
427 // multiple sub-packets
428 if (p
>= p_end
) return 0; // Packet too short
433 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"%08"PRIu64
": flag=%02X segs=%d seq=%u plen=%u pad=%u time=%ld dur=%d\n",
434 (uint64_t)demux
->filepos
,flags
,segs
,sequence
,plen
,padding
,time
,duration
);
436 for(seg
=0;seg
<segs
;seg
++){
438 unsigned char streamno
;
440 unsigned int x
; // offset or timestamp
448 mp_msg(MSGT_DEMUX
,MSGL_V
,"Warning! invalid packet 1, aborting parsing...\n");
452 if( mp_msg_test(MSGT_DEMUX
,MSGL_DBG2
) ){
454 printf("seg %d:",seg
);
455 for(i
=0;i
<FFMIN(16, p_end
- p
);i
++) printf(" %02X",p
[i
]);
460 if(p
[0]&0x80) keyframe
=1;
463 // Read media object number (seq):
464 if(!check_varlen(p
, p_end
, segtype
>> 4)) break; // Not enough data
465 seq
= read_varlen(&p
, segtype
>> 4, 0);
467 // Read offset or timestamp:
468 if(!check_varlen(p
, p_end
, segtype
>> 2)) break; // Not enough data
469 x
= read_varlen(&p
, segtype
>> 2, 0);
471 // Read replic.data len:
472 if(!check_varlen(p
, p_end
, segtype
)) break; // Not enough data
473 rlen
= read_varlen(&p
, segtype
, 0);
475 // printf("### rlen=%d \n",rlen);
478 case 0x01: // 1 = special, means grouping
479 //printf("grouping: %02X \n",p[0]);
480 ++p
; // skip PTS delta
484 p
+=4; // skip object size
485 if (p
+3 >= p_end
) break; // Packet too short
486 time2
=AV_RL32(p
); // read PTS
487 if (asf
->asf_is_dvr_ms
)
488 get_payload_extension_data(demux
, &p
, streamno
, seq
, &keyframe
, &time2
);
491 mp_msg(MSGT_DEMUX
,MSGL_V
,"unknown segment type (rlen): 0x%02X \n",rlen
);
499 if(!check_varlen(p
, p_end
, segsizetype
)) break; // Not enough data
500 len
= read_varlen(&p
, segsizetype
, plen
-(p
-asf
->packet
));
503 len
=plen
-(p
-asf
->packet
);
505 if(len
<0 || (p
+len
)>p_end
){
506 mp_msg(MSGT_DEMUX
,MSGL_V
,"ASF_parser: warning! segment len=%d\n",len
);
509 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
," seg #%d: streamno=%d seq=%d type=%02X len=%d\n",seg
,streamno
,seq
,rlen
,len
);
514 //printf("ASF_parser: warning! grouping (flag=1) not yet supported!\n",len);
515 //printf(" total: %d \n",len);
519 //printf(" group part: %d bytes\n",len2);
520 if(len2
> len
- 1 || len2
< 0) break; // Not enough data
521 len2
= FFMIN(len2
, asf
->packetsize
);
522 demux_asf_read_packet(demux
,p
,len2
,streamno
,seq
,x
,duration
,-1,keyframe
);
528 mp_msg(MSGT_DEMUX
,MSGL_V
,"ASF_parser: warning! groups total != len\n");
533 //printf("fragment offset: %d \n",sh->x);
535 if (!asf
->asf_is_dvr_ms
|| asf
->found_first_key_frame
) {
536 len
= FFMIN(len
, asf
->packetsize
);
537 demux_asf_read_packet(demux
,p
,len
,streamno
,seq
,time2
,duration
,x
,keyframe
);
547 mp_msg(MSGT_DEMUX
,MSGL_V
,"%08"PRIX64
": UNKNOWN TYPE %02X %02X %02X %02X %02X...\n",(int64_t)demux
->filepos
,asf
->packet
[0],asf
->packet
[1],asf
->packet
[2],asf
->packet
[3],asf
->packet
[4]);
551 #include "stheader.h"
553 void skip_audio_frame(sh_audio_t
*sh_audio
);
555 static void demux_seek_asf(demuxer_t
*demuxer
,float rel_seek_secs
,float audio_delay
,int flags
){
556 struct asf_priv
* asf
= demuxer
->priv
;
557 demux_stream_t
*d_audio
=demuxer
->audio
;
558 demux_stream_t
*d_video
=demuxer
->video
;
559 sh_audio_t
*sh_audio
=d_audio
->sh
;
560 // sh_video_t *sh_video=d_video->sh;
562 //FIXME: OFF_T - didn't test ASF case yet (don't have a large asf...)
563 //FIXME: reports good or bad to steve@daviesfam.org please
565 //================= seek in ASF ==========================
566 float p_rate
=asf
->packetrate
; // packets / sec
567 off_t rel_seek_packs
=(flags
&SEEK_FACTOR
)? // FIXME: int may be enough?
568 (rel_seek_secs
*(demuxer
->movi_end
-demuxer
->movi_start
)/asf
->packetsize
):
569 (rel_seek_secs
*p_rate
);
570 off_t rel_seek_bytes
=rel_seek_packs
*asf
->packetsize
;
572 //printf("ASF: packs: %d duration: %d \n",(int)fileh.packets,*((int*)&fileh.duration));
573 // printf("ASF_seek: %d secs -> %d packs -> %d bytes \n",
574 // rel_seek_secs,rel_seek_packs,rel_seek_bytes);
575 newpos
=((flags
&SEEK_ABSOLUTE
)?demuxer
->movi_start
:demuxer
->filepos
)+rel_seek_bytes
;
576 if(newpos
<0 || newpos
<demuxer
->movi_start
) newpos
=demuxer
->movi_start
;
577 // printf("\r -- asf: newpos=%d -- \n",newpos);
578 stream_seek(demuxer
->stream
,newpos
);
580 if (asf
->asf_is_dvr_ms
) asf
->dvr_last_vid_pts
= 0.0f
;
582 if (d_video
->id
>= 0)
583 ds_fill_buffer(d_video
);
585 ds_fill_buffer(d_audio
);
588 if (d_video
->id
>= 0)
590 if(sh_audio
&& !d_audio
->eof
){
591 float a_pts
=d_audio
->pts
;
592 a_pts
+=(ds_tell_pts(d_audio
)-sh_audio
->a_in_buffer_len
)/(float)sh_audio
->i_bps
;
594 if (d_video
->pts
> a_pts
){
595 skip_audio_frame(sh_audio
);
596 // if(!ds_fill_buffer(d_audio)) sh_audio=NULL; // skip audio. EOF?
600 if(d_video
->flags
&1) break; // found a keyframe!
601 if(!ds_fill_buffer(d_video
)) break; // skip frame. EOF?
607 static int demux_asf_control(demuxer_t
*demuxer
,int cmd
, void *arg
){
608 struct asf_priv
* asf
= demuxer
->priv
;
609 /* demux_stream_t *d_audio=demuxer->audio;
610 demux_stream_t *d_video=demuxer->video;
611 sh_audio_t *sh_audio=d_audio->sh;
612 sh_video_t *sh_video=d_video->sh;
615 case DEMUXER_CTRL_GET_TIME_LENGTH
:
616 *((double *)arg
)=(double)(asf
->movielength
);
617 return DEMUXER_CTRL_OK
;
619 case DEMUXER_CTRL_GET_PERCENT_POS
:
620 return DEMUXER_CTRL_DONTKNOW
;
623 return DEMUXER_CTRL_NOTIMPL
;
628 static demuxer_t
* demux_open_asf(demuxer_t
* demuxer
)
630 struct asf_priv
* asf
= demuxer
->priv
;
631 sh_audio_t
*sh_audio
=NULL
;
632 sh_video_t
*sh_video
=NULL
;
635 if(!asf
) return NULL
;
637 if (!read_asf_header(demuxer
,asf
))
639 stream_reset(demuxer
->stream
);
640 stream_seek(demuxer
->stream
,demuxer
->movi_start
);
641 // demuxer->idx_pos=0;
642 // demuxer->endpos=avi_header.movi_end;
643 if(demuxer
->video
->id
!= -2) {
644 if(!ds_fill_buffer(demuxer
->video
)){
645 mp_msg(MSGT_DEMUXER
,MSGL_WARN
,"ASF: " MSGTR_MissingVideoStream
);
646 demuxer
->video
->sh
=NULL
;
647 //printf("ASF: missing video stream!? contact the author, it may be a bug :(\n");
649 sh_video
=demuxer
->video
->sh
;sh_video
->ds
=demuxer
->video
;
650 sh_video
->fps
=1000.0f
; sh_video
->frametime
=0.001f
;
652 if (asf
->asf_is_dvr_ms
) {
653 sh_video
->bih
->biWidth
= 0;
654 sh_video
->bih
->biHeight
= 0;
659 if(demuxer
->audio
->id
!=-2){
660 mp_msg(MSGT_DEMUXER
,MSGL_V
,MSGTR_ASFSearchingForAudioStream
,demuxer
->audio
->id
);
661 if(!ds_fill_buffer(demuxer
->audio
)){
662 mp_msg(MSGT_DEMUXER
,MSGL_INFO
,"ASF: " MSGTR_MissingAudioStream
);
663 demuxer
->audio
->sh
=NULL
;
665 sh_audio
=demuxer
->audio
->sh
;sh_audio
->ds
=demuxer
->audio
;
666 sh_audio
->format
=sh_audio
->wf
->wFormatTag
;
669 if(!demuxer
->stream
->seek
)
676 static void demux_close_asf(demuxer_t
*demuxer
) {
677 struct asf_priv
* asf
= demuxer
->priv
;
681 if (asf
->aud_repdata_sizes
)
682 free(asf
->aud_repdata_sizes
);
684 if (asf
->vid_repdata_sizes
)
685 free(asf
->vid_repdata_sizes
);
690 const demuxer_desc_t demuxer_desc_asf
= {
697 1, // safe autodetect
699 demux_asf_fill_buffer
,