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.
27 #include <libavutil/intreadwrite.h>
32 #include "stream/stream.h"
34 #include "asfheader.h"
36 #include "libmpcodecs/dec_audio.h"
37 #include "libvo/fastmemcpy.h"
39 // based on asf file-format doc by Eugene [http://divx.euro.ru]
42 * \brief reads int stored in number of bytes given by len
43 * \param ptr pointer to read from, is incremented appropriately
44 * \param len lowest 2 bits indicate number of bytes to read
45 * \param def default value to return if len is invalid
47 static inline unsigned read_varlen(uint8_t **ptr
, int len
, int def
) {
48 const uint8_t *p
= *ptr
;
51 case 1: *ptr
+= 1; return *p
;
52 case 2: *ptr
+= 2; return AV_RL16(p
);
53 case 3: *ptr
+= 4; return AV_RL32(p
);
59 * \brief checks if there is enough data to read the bytes given by len
60 * \param ptr pointer to read from
61 * \param endptr pointer to the end of the buffer
62 * \param len lowest 2 bits indicate number of bytes to read
64 static inline int check_varlen(uint8_t *ptr
, uint8_t *endptr
, int len
) {
65 return len
&3 ? ptr
+ (1<<((len
&3) - 1)) <= endptr
: 1;
68 static void asf_descrambling(unsigned char **src
,unsigned len
, struct asf_priv
* asf
){
70 unsigned char *s2
=*src
;
72 if (len
> UINT_MAX
- MP_INPUT_BUFFER_PADDING_SIZE
)
74 dst
= malloc(len
+ MP_INPUT_BUFFER_PADDING_SIZE
);
75 while(len
>=asf
->scrambling_h
*asf
->scrambling_w
*asf
->scrambling_b
+i
){
76 // mp_msg(MSGT_DEMUX,MSGL_DBG4,"descrambling! (w=%d b=%d)\n",w,asf_scrambling_b);
77 //i+=asf_scrambling_h*asf_scrambling_w;
78 for(x
=0;x
<asf
->scrambling_w
;x
++)
79 for(y
=0;y
<asf
->scrambling_h
;y
++){
80 fast_memcpy(dst
+i
,s2
+(y
*asf
->scrambling_w
+x
)*asf
->scrambling_b
,asf
->scrambling_b
);
83 s2
+=asf
->scrambling_h
*asf
->scrambling_w
*asf
->scrambling_b
;
85 //if(i<len) fast_memcpy(dst+i,src+i,len-i);
90 /*****************************************************************
91 * \brief initializes asf private data
94 static void init_priv (struct asf_priv
* asf
){
96 asf
->vid_ext_timing_index
=-1;
97 asf
->aud_ext_timing_index
=-1;
98 asf
->vid_ext_frame_index
=-1;
101 static void demux_asf_append_to_packet(demux_packet_t
* dp
,unsigned char *data
,int len
,int offs
)
103 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
);
104 dp
->buffer
=realloc(dp
->buffer
,dp
->len
+len
+MP_INPUT_BUFFER_PADDING_SIZE
);
105 fast_memcpy(dp
->buffer
+dp
->len
,data
,len
);
106 memset(dp
->buffer
+dp
->len
+len
, 0, MP_INPUT_BUFFER_PADDING_SIZE
);
107 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"data appended! %d+%d\n",dp
->len
,len
);
111 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
){
112 struct asf_priv
* asf
= demux
->priv
;
113 demux_stream_t
*ds
=NULL
;
116 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"demux_asf.read_packet: id=%d seq=%d len=%d\n",id
,seq
,len
);
118 if(demux
->video
->id
==-1)
119 if(demux
->v_streams
[id
])
122 if(demux
->audio
->id
==-1)
123 if(demux
->a_streams
[id
])
126 if(id
==demux
->audio
->id
){
130 ds
->sh
=demux
->a_streams
[id
];
131 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected ASF audio ID = %d\n",ds
->id
);
134 if(id
==demux
->video
->id
){
138 ds
->sh
=demux
->v_streams
[id
];
139 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected ASF video ID = %d\n",ds
->id
);
145 demux_packet_t
* dp
=ds
->asf_packet
;
147 if (ds
==demux
->video
&& asf
->asf_is_dvr_ms
) {
148 if (asf
->new_vid_frame_seg
) {
149 dp
->pos
=demux
->filepos
;
151 } else seq
= ds
->asf_seq
;
152 } else close_seg
= ds
->asf_seq
!=seq
;
155 // closed segment, finalize packet:
157 if(asf
->scrambling_h
>1 && asf
->scrambling_w
>1 && asf
->scrambling_b
>0)
158 asf_descrambling(&ds
->asf_packet
->buffer
,ds
->asf_packet
->len
,asf
);
159 ds_add_packet(ds
,ds
->asf_packet
);
162 // append data to it!
163 demux_asf_append_to_packet(dp
,data
,len
,offs
);
168 // create new packet:
169 { demux_packet_t
* dp
;
171 mp_msg(MSGT_DEMUX
,MSGL_V
,"warning! broken fragment, %d bytes missing \n",offs
);
174 dp
=new_demux_packet(len
);
175 fast_memcpy(dp
->buffer
,data
,len
);
176 if (asf
->asf_is_dvr_ms
)
177 dp
->pts
=time
*0.0000001;
181 // if(ds==demux->video) printf("ASF time: %8d dur: %5d \n",time,dur);
182 dp
->pos
=demux
->filepos
;
193 /*****************************************************************
194 * \brief read the replicated data associated with each segment
195 * \parameter pp reference to replicated data
196 * \parameter id stream number
197 * \parameter seq media object number
198 * \parameter keyframe key frame indicator - set to zero if keyframe, non-zero otherwise
199 * \parameter seg_time set to payload time when valid, if audio or new video frame payload, zero otherwise
202 static void get_payload_extension_data(demuxer_t
*demux
, unsigned char** pp
, unsigned char id
, unsigned int seq
, int *keyframe
, uint64_t *seg_time
){
203 struct asf_priv
* asf
= demux
->priv
;
204 uint64_t payload_time
= -1; //100ns units
205 int i
, ext_max
, ext_timing_index
;
208 if(demux
->video
->id
==-1)
209 if(demux
->v_streams
[id
])
212 if(demux
->audio
->id
==-1)
213 if(demux
->a_streams
[id
])
216 if (id
!=demux
->video
->id
&& id
!=demux
->audio
->id
) return;
218 if (id
==demux
->video
->id
) {
219 ext_max
= asf
->vid_repdata_count
;
220 ext_timing_index
= asf
->vid_ext_timing_index
;
222 ext_max
= asf
->aud_repdata_count
;
223 ext_timing_index
= asf
->aud_ext_timing_index
;
227 asf
->new_vid_frame_seg
= 0;
229 for (i
=0; i
<ext_max
; i
++) {
231 uint8_t segment_marker
;
233 if (id
==demux
->video
->id
)
234 payextsize
= asf
->vid_repdata_sizes
[i
];
236 payextsize
= asf
->aud_repdata_sizes
[i
];
238 if (payextsize
== 65535) {
239 payextsize
= AV_RL16(pi
);
243 // if this is the timing info extension then read the payload time
244 if (i
== ext_timing_index
)
245 payload_time
= AV_RL64(pi
+8);
247 // if this is the video frame info extension then
248 // set the keyframe indicator, the 'new frame segment' indicator
249 // and (initially) the 'frame time'
250 if (i
== asf
->vid_ext_frame_index
&& id
==demux
->video
->id
) {
251 segment_marker
= pi
[0];
252 // Known video stream segment_marker values that
253 // contain useful information:
255 // NTSC/ATSC (29.97fps): 0X4A 01001010
259 // PAL/ATSC (25fps): 0X3A 00111010
263 // ATSC progressive (29.97fps): 0X7A 01111010
267 // ^ this is new video frame marker
269 // ^^^^ these bits indicate the framerate
270 // 0X4 is 29.97i, 0X3 is 25i, 0X7 is 29.97p, ???=25p
272 // ^^^ these bits indicate the frame type:
274 // 010 and 011 probably mean P and B
276 asf
->new_vid_frame_seg
= (0X08 & segment_marker
) && seq
!= asf
->last_vid_seq
;
278 if (asf
->new_vid_frame_seg
) asf
->last_vid_seq
= seq
;
280 if (asf
->avg_vid_frame_time
== 0) {
281 // set the average frame time initially (in 100ns units).
282 // This is based on what works for known samples.
283 // It can be extended if more samples of different types can be obtained.
284 if (((segment_marker
& 0XF0) >> 4) == 4) {
285 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 30.0) * 10000000.0);
286 asf
->know_frame_time
=1;
287 } else if (((segment_marker
& 0XF0) >> 4) == 3) {
288 asf
->avg_vid_frame_time
= (uint64_t)(0.04 * 10000000.0);
289 asf
->know_frame_time
=1;
290 } else if (((segment_marker
& 0XF0) >> 4) == 6) {
291 asf
->avg_vid_frame_time
= (uint64_t)(0.02 * 10000000.0);
292 asf
->know_frame_time
=1;
293 } else if (((segment_marker
& 0XF0) >> 4) == 7) {
294 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 60.0) * 10000000.0);
295 asf
->know_frame_time
=1;
297 // we dont know the frame time initially so
298 // make a guess and then recalculate as we go.
299 asf
->avg_vid_frame_time
= (uint64_t)((1.001 / 60.0) * 10000000.0);
300 asf
->know_frame_time
=0;
303 *keyframe
= (asf
->new_vid_frame_seg
&& (segment_marker
& 0X07) == 1);
308 if (id
==demux
->video
->id
&& asf
->new_vid_frame_seg
) {
310 // Some samples only have timings on key frames and
311 // the rest contain non-cronological timestamps. Interpolating
312 // the values between key frames works for all samples.
314 asf
->found_first_key_frame
=1;
315 if (!asf
->know_frame_time
&& asf
->last_key_payload_time
> 0) {
316 // We dont know average frametime so recalculate.
317 // Giving precedence to the 'weight' of the existing
318 // average limits damage done to new value when there is
319 // a sudden time jump which happens occasionally.
320 asf
->avg_vid_frame_time
=
321 (0.9 * asf
->avg_vid_frame_time
) +
322 (0.1 * ((payload_time
- asf
->last_key_payload_time
) / asf
->vid_frame_ct
));
324 asf
->last_key_payload_time
= payload_time
;
325 asf
->vid_frame_ct
= 1;
326 *seg_time
= payload_time
;
328 *seg_time
= (asf
->last_key_payload_time
+ (asf
->avg_vid_frame_time
* (asf
->vid_frame_ct
-1)));
331 if (id
==demux
->audio
->id
) {
332 if (payload_time
!= -1)
333 asf
->last_aud_diff
= payload_time
- asf
->last_aud_pts
;
334 asf
->last_aud_pts
+= asf
->last_aud_diff
;
335 *seg_time
= asf
->last_aud_pts
;
338 //static int num_elementary_packets100=0;
339 //static int num_elementary_packets101=0;
342 // 0 = EOF or no stream found
343 // 1 = successfully read a packet
344 static int demux_asf_fill_buffer(demuxer_t
*demux
, demux_stream_t
*ds
){
345 struct asf_priv
* asf
= demux
->priv
;
347 demux
->filepos
=stream_tell(demux
->stream
);
348 // Brodcast stream have movi_start==movi_end
350 if((demux
->movi_start
< demux
->movi_end
) && (demux
->filepos
>=demux
->movi_end
)){
351 demux
->stream
->eof
=1;
355 stream_read(demux
->stream
,asf
->packet
,asf
->packetsize
);
356 if(demux
->stream
->eof
) return 0; // EOF
357 if(asf
->packetsize
< 2) return 0; // Packet too short
360 unsigned char* p
=asf
->packet
;
361 unsigned char* p_end
=asf
->packet
+asf
->packetsize
;
362 unsigned char flags
=p
[0];
363 unsigned char segtype
=p
[1];
366 unsigned sequence av_unused
;
367 unsigned long time av_unused
= 0;
368 unsigned short duration
=0;
371 unsigned char segsizetype
=0x80;
374 if( mp_msg_test(MSGT_DEMUX
,MSGL_DBG2
) ){
376 for(i
=0;i
<FFMIN(16, asf
->packetsize
);i
++) printf(" %02X",asf
->packet
[i
]);
380 // skip ECC data if present by testing bit 7 of flags
381 // 1xxxbbbb -> ecc data present, skip bbbb byte(s)
382 // 0xxxxxxx -> payload parsing info starts
385 p
+= (flags
& 0x0f)+1;
386 if (p
+1 >= p_end
) return 0; // Packet too short
391 //if(segtype!=0x5d) printf("Warning! packet[4] != 0x5d \n");
393 p
+=2; // skip flags & segtype
395 // Read packet size (plen):
396 if(!check_varlen(p
, p_end
, flags
>> 5)) return 0; // Not enough data
397 plen
= read_varlen(&p
, flags
>> 5, 0);
400 if(!check_varlen(p
, p_end
, flags
>> 1)) return 0; // Not enough data
401 sequence
= read_varlen(&p
, flags
>> 1, 0);
403 // Read padding size (padding):
404 if(!check_varlen(p
, p_end
, flags
>> 3)) return 0; // Not enough data
405 padding
= read_varlen(&p
, flags
>> 3, 0);
407 if(((flags
>>5)&3)!=0){
408 // Explicit (absoulte) packet size
409 mp_dbg(MSGT_DEMUX
,MSGL_DBG2
,"Explicit packet size specified: %d \n",plen
);
410 if(plen
>asf
->packetsize
) mp_msg(MSGT_DEMUX
,MSGL_V
,"Warning! plen>packetsize! (%d>%d) \n",plen
,asf
->packetsize
);
412 // Padding (relative) size
413 plen
=asf
->packetsize
-padding
;
416 // Read time & duration:
417 if (p
+5 >= p_end
) return 0; // Packet too short
418 time
= AV_RL32(p
); p
+=4;
419 duration
= AV_RL16(p
); p
+=2;
421 // Read payload flags:
423 // multiple sub-packets
424 if (p
>= p_end
) return 0; // Packet too short
429 mp_dbg(MSGT_DEMUX
,MSGL_DBG4
,"%08"PRIu64
": flag=%02X segs=%d seq=%u plen=%u pad=%u time=%ld dur=%d\n",
430 (uint64_t)demux
->filepos
,flags
,segs
,sequence
,plen
,padding
,time
,duration
);
432 for(seg
=0;seg
<segs
;seg
++){
434 unsigned char streamno
;
436 unsigned int x
; // offset or timestamp
444 mp_msg(MSGT_DEMUX
,MSGL_V
,"Warning! invalid packet 1, aborting parsing...\n");
448 if( mp_msg_test(MSGT_DEMUX
,MSGL_DBG2
) ){
450 printf("seg %d:",seg
);
451 for(i
=0;i
<FFMIN(16, p_end
- p
);i
++) printf(" %02X",p
[i
]);
456 if(p
[0]&0x80) keyframe
=1;
459 // Read media object number (seq):
460 if(!check_varlen(p
, p_end
, segtype
>> 4)) break; // Not enough data
461 seq
= read_varlen(&p
, segtype
>> 4, 0);
463 // Read offset or timestamp:
464 if(!check_varlen(p
, p_end
, segtype
>> 2)) break; // Not enough data
465 x
= read_varlen(&p
, segtype
>> 2, 0);
467 // Read replic.data len:
468 if(!check_varlen(p
, p_end
, segtype
)) break; // Not enough data
469 rlen
= read_varlen(&p
, segtype
, 0);
471 // printf("### rlen=%d \n",rlen);
472 if (rlen
> p_end
- p
) {
473 mp_msg(MSGT_DEMUX
, MSGL_V
, "invalid rlen=%u\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 static void demux_seek_asf(demuxer_t
*demuxer
,float rel_seek_secs
,float audio_delay
,int flags
){
554 struct asf_priv
* asf
= demuxer
->priv
;
555 demux_stream_t
*d_audio
=demuxer
->audio
;
556 demux_stream_t
*d_video
=demuxer
->video
;
557 sh_audio_t
*sh_audio
=d_audio
->sh
;
558 // sh_video_t *sh_video=d_video->sh;
560 //FIXME: OFF_T - didn't test ASF case yet (don't have a large asf...)
561 //FIXME: reports good or bad to steve@daviesfam.org please
563 //================= seek in ASF ==========================
564 float p_rate
=asf
->packetrate
; // packets / sec
565 off_t rel_seek_packs
=(flags
&SEEK_FACTOR
)? // FIXME: int may be enough?
566 (rel_seek_secs
*(demuxer
->movi_end
-demuxer
->movi_start
)/asf
->packetsize
):
567 (rel_seek_secs
*p_rate
);
568 off_t rel_seek_bytes
=rel_seek_packs
*asf
->packetsize
;
570 //printf("ASF: packs: %d duration: %d \n",(int)fileh.packets,*((int*)&fileh.duration));
571 // printf("ASF_seek: %d secs -> %d packs -> %d bytes \n",
572 // rel_seek_secs,rel_seek_packs,rel_seek_bytes);
573 newpos
=((flags
&SEEK_ABSOLUTE
)?demuxer
->movi_start
:demuxer
->filepos
)+rel_seek_bytes
;
574 if(newpos
<0 || newpos
<demuxer
->movi_start
) newpos
=demuxer
->movi_start
;
575 // printf("\r -- asf: newpos=%d -- \n",newpos);
576 stream_seek(demuxer
->stream
,newpos
);
578 if (asf
->asf_is_dvr_ms
) asf
->dvr_last_vid_pts
= 0.0f
;
580 if (d_video
->id
>= 0)
581 ds_fill_buffer(d_video
);
583 ds_fill_buffer(d_audio
);
586 if (d_video
->id
>= 0)
588 if(sh_audio
&& !d_audio
->eof
){
589 float a_pts
=d_audio
->pts
;
590 a_pts
+=(ds_tell_pts(d_audio
)-sh_audio
->a_in_buffer_len
)/(float)sh_audio
->i_bps
;
592 if (d_video
->pts
> a_pts
){
593 skip_audio_frame(sh_audio
);
594 // if(!ds_fill_buffer(d_audio)) sh_audio=NULL; // skip audio. EOF?
598 if(d_video
->flags
&1) break; // found a keyframe!
599 if(!ds_fill_buffer(d_video
)) break; // skip frame. EOF?
605 static int demux_asf_control(demuxer_t
*demuxer
,int cmd
, void *arg
){
606 struct asf_priv
* asf
= demuxer
->priv
;
607 /* demux_stream_t *d_audio=demuxer->audio;
608 demux_stream_t *d_video=demuxer->video;
609 sh_audio_t *sh_audio=d_audio->sh;
610 sh_video_t *sh_video=d_video->sh;
613 case DEMUXER_CTRL_GET_TIME_LENGTH
:
614 *((double *)arg
)=asf
->movielength
;
615 return DEMUXER_CTRL_OK
;
617 case DEMUXER_CTRL_GET_PERCENT_POS
:
618 return DEMUXER_CTRL_DONTKNOW
;
621 return DEMUXER_CTRL_NOTIMPL
;
626 static demuxer_t
* demux_open_asf(demuxer_t
* demuxer
)
628 struct asf_priv
* asf
= demuxer
->priv
;
629 sh_video_t
*sh_video
=NULL
;
632 if(!asf
) return NULL
;
634 if (!read_asf_header(demuxer
,asf
))
636 stream_reset(demuxer
->stream
);
637 stream_seek(demuxer
->stream
,demuxer
->movi_start
);
638 // demuxer->idx_pos=0;
639 // demuxer->endpos=avi_header.movi_end;
640 if(demuxer
->video
->id
!= -2) {
641 if(!ds_fill_buffer(demuxer
->video
)){
642 mp_msg(MSGT_DEMUXER
, MSGL_WARN
, "ASF: %s",
643 mp_gtext("No video stream found.\n"));
644 demuxer
->video
->sh
=NULL
;
645 //printf("ASF: missing video stream!? contact the author, it may be a bug :(\n");
647 sh_video
=demuxer
->video
->sh
;
648 sh_video
->fps
=1000.0f
; sh_video
->frametime
=0.001f
;
650 if (asf
->asf_is_dvr_ms
) {
651 sh_video
->bih
->biWidth
= 0;
652 sh_video
->bih
->biHeight
= 0;
657 if(demuxer
->audio
->id
!=-2){
658 mp_tmsg(MSGT_DEMUXER
,MSGL_V
,"ASF: Searching for audio stream (id:%d).\n",demuxer
->audio
->id
);
659 if(!ds_fill_buffer(demuxer
->audio
)){
660 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "ASF: %s",
661 mp_gtext("No audio stream found -> no sound.\n"));
662 demuxer
->audio
->sh
=NULL
;
665 if(!demuxer
->stream
->seek
)
672 static void demux_close_asf(demuxer_t
*demuxer
) {
673 struct asf_priv
* asf
= demuxer
->priv
;
677 free(asf
->aud_repdata_sizes
);
678 free(asf
->vid_repdata_sizes
);
683 const demuxer_desc_t demuxer_desc_asf
= {
690 1, // safe autodetect
692 demux_asf_fill_buffer
,