2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 // .asf fileformat docs from http://divx.euro.ru
26 #include "libavutil/common.h"
27 #include "libavutil/intreadwrite.h"
31 #include "stream/stream.h"
38 #include "asfheader.h"
41 // must be 0 for metadata record, might be non-zero for metadata lib record
42 uint16_t lang_list_index
;
51 static char* get_ucs2str(const uint16_t* inbuf
, uint16_t inlen
)
53 char* outbuf
= calloc(inlen
, 2);
58 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MemAllocFailed
);
62 for (i
= 0; i
< inlen
/ 2; i
++) {
64 PUT_UTF8(AV_RL16(&inbuf
[i
]), tmp
, *q
++ = tmp
;)
69 static const char* asf_chunk_type(unsigned char* guid
) {
74 switch(ASF_LOAD_GUID_PREFIX(guid
)){
75 case ASF_GUID_PREFIX_audio_stream
:
76 return "guid_audio_stream";
77 case ASF_GUID_PREFIX_ext_audio_stream
:
78 return "guid_ext_audio_stream";
79 case ASF_GUID_PREFIX_ext_stream_embed_stream_header
:
80 return "guid_ext_stream_embed_stream_header";
81 case ASF_GUID_PREFIX_video_stream
:
82 return "guid_video_stream";
83 case ASF_GUID_PREFIX_audio_conceal_none
:
84 return "guid_audio_conceal_none";
85 case ASF_GUID_PREFIX_audio_conceal_interleave
:
86 return "guid_audio_conceal_interleave";
87 case ASF_GUID_PREFIX_header
:
89 case ASF_GUID_PREFIX_data_chunk
:
90 return "guid_data_chunk";
91 case ASF_GUID_PREFIX_index_chunk
:
92 return "guid_index_chunk";
93 case ASF_GUID_PREFIX_stream_header
:
94 return "guid_stream_header";
95 case ASF_GUID_PREFIX_header_2_0
:
96 return "guid_header_2_0";
97 case ASF_GUID_PREFIX_file_header
:
98 return "guid_file_header";
99 case ASF_GUID_PREFIX_content_desc
:
100 return "guid_content_desc";
101 case ASF_GUID_PREFIX_dvr_ms_timing_rep_data
:
102 return "guid_dvr_ms_timing_rep_data";
103 case ASF_GUID_PREFIX_dvr_ms_vid_frame_rep_data
:
104 return "guid_dvr_ms_vid_frame_rep_data";
106 strcpy(tmp
, "unknown guid ");
107 p
= tmp
+ strlen(tmp
);
108 for (i
= 0; i
< 16; i
++) {
109 if ((1 << i
) & ((1<<4) | (1<<6) | (1<<8))) *p
++ = '-';
110 sprintf(p
, "%02x", guid
[i
]);
117 int asf_check_header(demuxer_t
*demuxer
){
118 unsigned char asfhdrguid
[16]={0x30,0x26,0xB2,0x75,0x8E,0x66,0xCF,0x11,0xA6,0xD9,0x00,0xAA,0x00,0x62,0xCE,0x6C};
119 struct asf_priv
* asf
= calloc(1,sizeof(*asf
));
120 asf
->scrambling_h
=asf
->scrambling_w
=asf
->scrambling_b
=1;
121 stream_read(demuxer
->stream
,(char*) &asf
->header
,sizeof(asf
->header
)); // header obj
122 le2me_ASF_header_t(&asf
->header
); // swap to machine endian
123 // for(i=0;i<16;i++) printf(" %02X",temp[i]);printf("\n");
124 // for(i=0;i<16;i++) printf(" %02X",asfhdrguid[i]);printf("\n");
125 if(memcmp(asfhdrguid
,asf
->header
.objh
.guid
,16)){
126 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF_check: not ASF guid!\n");
128 return 0; // not ASF guid
130 if(asf
->header
.cno
>256){
131 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF_check: invalid subchunks_no %d\n",(int) asf
->header
.cno
);
133 return 0; // invalid header???
136 return DEMUXER_TYPE_ASF
;
139 static int get_ext_stream_properties(char *buf
, int buf_len
, int stream_num
, struct asf_priv
* asf
, int is_video
)
142 uint8_t *buffer
= &buf
[0];
146 while ((pos
= find_asf_guid(buf
, asf_ext_stream_header
, pos
, buf_len
)) >= 0) {
147 int this_stream_num
, stnamect
, payct
, i
;
148 int buf_max_index
=pos
+50;
149 if (buf_max_index
> buf_len
) return 0;
152 // the following info is available
153 // some of it may be useful but we're skipping it for now
154 // starttime(8 bytes), endtime(8),
155 // leak-datarate(4), bucket-datasize(4), init-bucket-fullness(4),
156 // alt-leak-datarate(4), alt-bucket-datasize(4), alt-init-bucket-fullness(4),
157 // max-object-size(4),
158 // flags(4) (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
161 bitrate
= AV_RL32(buffer
);
163 this_stream_num
=AV_RL16(buffer
);buffer
+=2;
165 if (this_stream_num
== stream_num
) {
167 if (buf_max_index
> buf_len
) return 0;
168 buffer
+=2; //skip stream-language-id-index
169 avg_ft
= AV_RL64(buffer
); // provided in 100ns units
171 asf
->bps
= bitrate
/ 8;
173 // after this are values for stream-name-count and
174 // payload-extension-system-count
175 // followed by associated info for each
176 stnamect
= AV_RL16(buffer
);buffer
+=2;
177 payct
= AV_RL16(buffer
);buffer
+=2;
179 // need to read stream names if present in order
180 // to get lengths - values are ignored for now
181 for (i
=0; i
<stnamect
; i
++) {
184 if (buf_max_index
> buf_len
) return 0;
185 buffer
+=2; //language_id_index
186 stream_name_len
= AV_RL16(buffer
);buffer
+=2;
187 buffer
+=stream_name_len
; //stream_name
188 buf_max_index
+=stream_name_len
;
189 if (buf_max_index
> buf_len
) return 0;
193 asf
->vid_repdata_count
= payct
;
194 asf
->vid_repdata_sizes
= malloc(payct
*sizeof(int));
196 asf
->aud_repdata_count
= payct
;
197 asf
->aud_repdata_sizes
= malloc(payct
*sizeof(int));
200 for (i
=0; i
<payct
; i
++) {
203 if (buf_max_index
> buf_len
) return 0;
204 // Each payload extension definition starts with a GUID.
205 // In dvr-ms files one of these indicates the presence an
206 // extension that contains pts values and this is always present
207 // in the video and audio streams.
208 // Another GUID indicates the presence of an extension
209 // that contains useful video frame demuxing information.
210 // Note that the extension data in each packet does not contain
211 // these GUIDs and that this header section defines the order the data
213 if (memcmp(buffer
, asf_dvr_ms_timing_rep_data
, 16) == 0) {
215 asf
->vid_ext_timing_index
= i
;
217 asf
->aud_ext_timing_index
= i
;
218 } else if (is_video
&& memcmp(buffer
, asf_dvr_ms_vid_frame_rep_data
, 16) == 0)
219 asf
->vid_ext_frame_index
= i
;
222 payload_len
= AV_RL16(buffer
);buffer
+=2;
225 asf
->vid_repdata_sizes
[i
] = payload_len
;
227 asf
->aud_repdata_sizes
[i
] = payload_len
;
237 #define CHECKDEC(l, n) if (((l) -= (n)) < 0) return 0
238 static char* read_meta_record(ASF_meta_record_t
* dest
, char* buf
,
241 CHECKDEC(*buf_len
, 2 + 2 + 2 + 2 + 4);
242 dest
->lang_list_index
= AV_RL16(buf
);
243 dest
->stream_num
= AV_RL16(&buf
[2]);
244 dest
->name_length
= AV_RL16(&buf
[4]);
245 dest
->data_type
= AV_RL16(&buf
[6]);
246 dest
->data_length
= AV_RL32(&buf
[8]);
247 buf
+= 2 + 2 + 2 + 2 + 4;
248 CHECKDEC(*buf_len
, dest
->name_length
);
249 dest
->name
= (uint16_t*)buf
;
250 buf
+= dest
->name_length
;
251 CHECKDEC(*buf_len
, dest
->data_length
);
253 buf
+= dest
->data_length
;
257 static int get_meta(char *buf
, int buf_len
, int this_stream_num
,
261 uint16_t records_count
;
262 uint16_t x
= 0, y
= 0;
264 if ((pos
= find_asf_guid(buf
, asf_metadata_header
, pos
, buf_len
)) < 0)
267 CHECKDEC(buf_len
, pos
);
269 CHECKDEC(buf_len
, 2);
270 records_count
= AV_RL16(buf
);
273 while (records_count
--) {
274 ASF_meta_record_t record_entry
;
277 if (!(buf
= read_meta_record(&record_entry
, buf
, &buf_len
)))
279 /* reserved, must be zero */
280 if (record_entry
.lang_list_index
)
282 /* match stream number: 0 to match all */
283 if (record_entry
.stream_num
&& record_entry
.stream_num
!= this_stream_num
)
285 if (!(name
= get_ucs2str(record_entry
.name
, record_entry
.name_length
))) {
286 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MemAllocFailed
);
289 if (strcmp(name
, "AspectRatioX") == 0)
290 x
= AV_RL16(record_entry
.data
);
291 else if (strcmp(name
, "AspectRatioY") == 0)
292 y
= AV_RL16(record_entry
.data
);
296 *asp_ratio
= (float)x
/ (float)y
;
302 static int is_drm(char* buf
, int buf_len
)
304 uint32_t data_len
, type_len
, key_len
, url_len
;
305 int pos
= find_asf_guid(buf
, asf_content_encryption
, 0, buf_len
);
310 CHECKDEC(buf_len
, pos
+ 4);
312 data_len
= AV_RL32(buf
);
314 CHECKDEC(buf_len
, data_len
);
316 type_len
= AV_RL32(buf
);
319 CHECKDEC(buf_len
, 4 + type_len
+ 4);
322 if (buf
[0] != 'D' || buf
[1] != 'R' || buf
[2] != 'M' || buf
[3] != '\0')
326 key_len
= AV_RL32(buf
);
327 CHECKDEC(buf_len
, key_len
+ 4);
330 buf
[key_len
- 1] = '\0';
331 mp_msg(MSGT_HEADER
, MSGL_V
, "DRM Key ID: %s\n", buf
);
334 url_len
= AV_RL32(buf
);
335 CHECKDEC(buf_len
, url_len
);
338 buf
[url_len
- 1] = '\0';
339 mp_msg(MSGT_HEADER
, MSGL_INFO
, MSGTR_MPDEMUX_ASFHDR_DRMLicenseURL
, buf
);
343 static int asf_init_audio_stream(demuxer_t
*demuxer
,struct asf_priv
* asf
, sh_audio_t
* sh_audio
, ASF_stream_header_t
*streamh
, int *ppos
, uint8_t** buf
, char *hdr
, unsigned int hdr_len
)
345 uint8_t *buffer
= *buf
;
348 sh_audio
->wf
=calloc((streamh
->type_size
<sizeof(WAVEFORMATEX
))?sizeof(WAVEFORMATEX
):streamh
->type_size
,1);
349 memcpy(sh_audio
->wf
,buffer
,streamh
->type_size
);
350 le2me_WAVEFORMATEX(sh_audio
->wf
);
351 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_wave_header(sh_audio
->wf
,MSGL_V
);
352 if(ASF_LOAD_GUID_PREFIX(streamh
->concealment
)==ASF_GUID_PREFIX_audio_conceal_interleave
){
354 pos
+= streamh
->stream_size
;
355 if (pos
> hdr_len
) return 0;
356 asf
->scrambling_h
=buffer
[0];
357 asf
->scrambling_w
=(buffer
[2]<<8)|buffer
[1];
358 asf
->scrambling_b
=(buffer
[4]<<8)|buffer
[3];
359 if(asf
->scrambling_b
>0){
360 asf
->scrambling_w
/=asf
->scrambling_b
;
363 asf
->scrambling_b
=asf
->scrambling_h
=asf
->scrambling_w
=1;
365 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF: audio scrambling: %d x %d x %d\n",asf
->scrambling_h
,asf
->scrambling_w
,asf
->scrambling_b
);
369 static int find_backwards_asf_guid(char *buf
, const char *guid
, int cur_pos
)
372 for (i
=cur_pos
-16; i
>0; i
--) {
373 if (memcmp(&buf
[i
], guid
, 16) == 0)
374 return i
+ 16 + 8; // point after guid + length
379 int read_asf_header(demuxer_t
*demuxer
,struct asf_priv
* asf
){
380 int hdr_len
= asf
->header
.objh
.size
- sizeof(asf
->header
);
383 char guid_buffer
[16];
384 int pos
, start
= stream_tell(demuxer
->stream
);
385 uint32_t* streams
= NULL
;
388 uint16_t stream_count
=0;
392 ASF_stream_header_t
*streamh
;
397 mp_msg(MSGT_HEADER
, MSGL_FATAL
, "Header size is too small.\n");
401 if (hdr_len
> 1024 * 1024) {
402 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MPDEMUX_ASFHDR_HeaderSizeOver1MB
,
404 hdr_skip
= hdr_len
- 1024 * 1024;
405 hdr_len
= 1024 * 1024;
407 hdr
= malloc(hdr_len
);
409 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_HeaderMallocFailed
,
413 stream_read(demuxer
->stream
, hdr
, hdr_len
);
415 stream_skip(demuxer
->stream
, hdr_skip
);
416 if (stream_eof(demuxer
->stream
)) {
417 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_EOFWhileReadingHeader
);
421 if (is_drm(hdr
, hdr_len
))
422 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_DRMProtected
);
424 if ((pos
= find_asf_guid(hdr
, asf_ext_stream_audio
, 0, hdr_len
)) >= 0)
426 // Special case: found GUID for dvr-ms audio.
427 // Now skip back to associated stream header.
430 sh_pos
= find_backwards_asf_guid(hdr
, asf_stream_header_guid
, pos
);
433 sh_audio_t
*sh_audio
;
435 mp_msg(MSGT_HEADER
, MSGL_V
, "read_asf_header found dvr-ms audio stream header pos=%d\n", sh_pos
);
436 // found audio stream header - following code reads header and
437 // initializes audio stream.
438 audio_pos
= pos
- 16 - 8;
439 streamh
= (ASF_stream_header_t
*)&hdr
[sh_pos
];
440 le2me_ASF_stream_header_t(streamh
);
441 audio_pos
+= 64; //16+16+4+4+4+16+4;
442 buffer
= &hdr
[audio_pos
];
443 sh_audio
=new_sh_audio(demuxer
,streamh
->stream_no
& 0x7F);
444 sh_audio
->needs_parsing
= 1;
445 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_AudioID
, "asfheader", streamh
->stream_no
& 0x7F);
447 if (!asf_init_audio_stream(demuxer
, asf
, sh_audio
, streamh
, &audio_pos
, &buffer
, hdr
, hdr_len
))
449 if (!get_ext_stream_properties(hdr
, hdr_len
, streamh
->stream_no
, asf
, 0))
453 // find stream headers
454 // only reset pos if we didnt find dvr_ms audio stream
455 // if we did find it then we want to avoid reading its header twice
459 while ((pos
= find_asf_guid(hdr
, asf_stream_header_guid
, pos
, hdr_len
)) >= 0)
461 streamh
= (ASF_stream_header_t
*)&hdr
[pos
];
462 pos
+= sizeof(ASF_stream_header_t
);
463 if (pos
> hdr_len
) goto len_err_out
;
464 le2me_ASF_stream_header_t(streamh
);
465 mp_msg(MSGT_HEADER
, MSGL_V
, "stream type: %s\n",
466 asf_chunk_type(streamh
->type
));
467 mp_msg(MSGT_HEADER
, MSGL_V
, "stream concealment: %s\n",
468 asf_chunk_type(streamh
->concealment
));
469 mp_msg(MSGT_HEADER
, MSGL_V
, "type: %d bytes, stream: %d bytes ID: %d\n",
470 (int)streamh
->type_size
, (int)streamh
->stream_size
,
471 (int)streamh
->stream_no
);
472 mp_msg(MSGT_HEADER
, MSGL_V
, "unk1: %lX unk2: %X\n",
473 (unsigned long)streamh
->unk1
, (unsigned int)streamh
->unk2
);
474 mp_msg(MSGT_HEADER
, MSGL_V
, "FILEPOS=0x%X\n", pos
+ start
);
475 // type-specific data:
477 pos
+= streamh
->type_size
;
478 if (pos
> hdr_len
) goto len_err_out
;
479 switch(ASF_LOAD_GUID_PREFIX(streamh
->type
)){
480 case ASF_GUID_PREFIX_audio_stream
: {
481 sh_audio_t
* sh_audio
=new_sh_audio(demuxer
,streamh
->stream_no
& 0x7F);
482 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_AudioID
, "asfheader", streamh
->stream_no
& 0x7F);
484 if (!asf_init_audio_stream(demuxer
, asf
, sh_audio
, streamh
, &pos
, &buffer
, hdr
, hdr_len
))
486 //if(demuxer->audio->id==-1) demuxer->audio->id=streamh.stream_no & 0x7F;
489 case ASF_GUID_PREFIX_video_stream
: {
492 sh_video_t
* sh_video
=new_sh_video(demuxer
,streamh
->stream_no
& 0x7F);
493 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_VideoID
, "asfheader", streamh
->stream_no
& 0x7F);
494 len
=streamh
->type_size
-(4+4+1+2);
496 // sh_video->bih=malloc(chunksize); memset(sh_video->bih,0,chunksize);
497 sh_video
->bih
=calloc((len
<sizeof(BITMAPINFOHEADER
))?sizeof(BITMAPINFOHEADER
):len
,1);
498 memcpy(sh_video
->bih
,&buffer
[4+4+1+2],len
);
499 le2me_BITMAPINFOHEADER(sh_video
->bih
);
500 if (sh_video
->bih
->biSize
> len
&& sh_video
->bih
->biSize
> sizeof(BITMAPINFOHEADER
))
501 sh_video
->bih
->biSize
= len
;
502 if (sh_video
->bih
->biCompression
== mmioFOURCC('D', 'V', 'R', ' ')) {
503 //mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_MPDEMUX_ASFHDR_DVRWantsLibavformat);
504 //sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
505 //sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
506 asf
->asf_frame_state
=-1;
507 asf
->asf_frame_start_found
=0;
508 asf
->asf_is_dvr_ms
=1;
509 asf
->dvr_last_vid_pts
=0.0;
510 } else asf
->asf_is_dvr_ms
=0;
511 if (!get_ext_stream_properties(hdr
, hdr_len
, streamh
->stream_no
, asf
, 1))
513 if (get_meta(hdr
, hdr_len
, streamh
->stream_no
, &asp_ratio
)) {
514 sh_video
->aspect
= asp_ratio
* sh_video
->bih
->biWidth
/
515 sh_video
->bih
->biHeight
;
517 sh_video
->i_bps
= asf
->bps
;
519 if( mp_msg_test(MSGT_DEMUX
,MSGL_V
) ) print_video_header(sh_video
->bih
, MSGL_V
);
520 //asf_video_id=streamh.stream_no & 0x7F;
521 //if(demuxer->video->id==-1) demuxer->video->id=streamh.stream_no & 0x7F;
525 // stream-specific data:
526 // stream_read(demuxer->stream,(char*) buffer,streamh.stream_size);
530 pos
= find_asf_guid(hdr
, asf_file_header_guid
, 0, hdr_len
);
532 ASF_file_header_t
*fileh
= (ASF_file_header_t
*)&hdr
[pos
];
533 pos
+= sizeof(ASF_file_header_t
);
534 if (pos
> hdr_len
) goto len_err_out
;
535 le2me_ASF_file_header_t(fileh
);
536 mp_msg(MSGT_HEADER
, MSGL_V
, "ASF: packets: %d flags: %d "
537 "max_packet_size: %d min_packet_size: %d max_bitrate: %d "
539 (int)fileh
->num_packets
, (int)fileh
->flags
,
540 (int)fileh
->min_packet_size
, (int)fileh
->max_packet_size
,
541 (int)fileh
->max_bitrate
, (int)fileh
->preroll
);
542 asf
->packetsize
=fileh
->max_packet_size
;
543 asf
->packet
=malloc(asf
->packetsize
); // !!!
544 asf
->packetrate
=fileh
->max_bitrate
/8.0/(double)asf
->packetsize
;
545 asf
->movielength
=(fileh
->play_duration
-10000*fileh
->preroll
)/10000000.0;
548 // find content header
549 pos
= find_asf_guid(hdr
, asf_content_desc_guid
, 0, hdr_len
);
551 ASF_content_description_t
*contenth
= (ASF_content_description_t
*)&hdr
[pos
];
553 uint16_t* wstring
= NULL
;
555 pos
+= sizeof(ASF_content_description_t
);
556 if (pos
> hdr_len
) goto len_err_out
;
557 le2me_ASF_content_description_t(contenth
);
558 mp_msg(MSGT_HEADER
,MSGL_V
,"\n");
560 if((len
= contenth
->title_size
) != 0) {
561 wstring
= (uint16_t*)&hdr
[pos
];
563 if (pos
> hdr_len
) goto len_err_out
;
564 if ((string
= get_ucs2str(wstring
, len
))) {
565 mp_msg(MSGT_HEADER
,MSGL_V
," Title: %s\n", string
);
566 demux_info_add(demuxer
, "title", string
);
570 // extract the author
571 if((len
= contenth
->author_size
) != 0) {
572 wstring
= (uint16_t*)&hdr
[pos
];
574 if (pos
> hdr_len
) goto len_err_out
;
575 if ((string
= get_ucs2str(wstring
, len
))) {
576 mp_msg(MSGT_HEADER
,MSGL_V
," Author: %s\n", string
);
577 demux_info_add(demuxer
, "author", string
);
581 // extract the copyright
582 if((len
= contenth
->copyright_size
) != 0) {
583 wstring
= (uint16_t*)&hdr
[pos
];
585 if (pos
> hdr_len
) goto len_err_out
;
586 if ((string
= get_ucs2str(wstring
, len
))) {
587 mp_msg(MSGT_HEADER
,MSGL_V
," Copyright: %s\n", string
);
588 demux_info_add(demuxer
, "copyright", string
);
592 // extract the comment
593 if((len
= contenth
->comment_size
) != 0) {
594 wstring
= (uint16_t*)&hdr
[pos
];
596 if (pos
> hdr_len
) goto len_err_out
;
597 if ((string
= get_ucs2str(wstring
, len
))) {
598 mp_msg(MSGT_HEADER
,MSGL_V
," Comment: %s\n", string
);
599 demux_info_add(demuxer
, "comments", string
);
603 // extract the rating
604 if((len
= contenth
->rating_size
) != 0) {
605 wstring
= (uint16_t*)&hdr
[pos
];
607 if (pos
> hdr_len
) goto len_err_out
;
608 if ((string
= get_ucs2str(wstring
, len
))) {
609 mp_msg(MSGT_HEADER
,MSGL_V
," Rating: %s\n", string
);
613 mp_msg(MSGT_HEADER
,MSGL_V
,"\n");
616 // find content header
617 pos
= find_asf_guid(hdr
, asf_stream_group_guid
, 0, hdr_len
);
619 int max_streams
= (hdr_len
- pos
- 2) / 6;
620 uint16_t stream_id
, i
;
621 uint32_t max_bitrate
;
622 char *ptr
= &hdr
[pos
];
623 mp_msg(MSGT_HEADER
,MSGL_V
,"============ ASF Stream group == START ===\n");
624 if(max_streams
<= 0) goto len_err_out
;
625 stream_count
= AV_RL16(ptr
);
626 ptr
+= sizeof(uint16_t);
627 if(stream_count
> max_streams
) stream_count
= max_streams
;
629 streams
= malloc(2*stream_count
*sizeof(uint32_t));
630 mp_msg(MSGT_HEADER
,MSGL_V
," stream count=[0x%x][%u]\n", stream_count
, stream_count
);
631 for( i
=0 ; i
<stream_count
; i
++ ) {
632 stream_id
= AV_RL16(ptr
);
633 ptr
+= sizeof(uint16_t);
634 memcpy(&max_bitrate
, ptr
, sizeof(uint32_t));// workaround unaligment bug on sparc
635 max_bitrate
= le2me_32(max_bitrate
);
636 ptr
+= sizeof(uint32_t);
637 mp_msg(MSGT_HEADER
,MSGL_V
," stream id=[0x%x][%u]\n", stream_id
, stream_id
);
638 mp_msg(MSGT_HEADER
,MSGL_V
," max bitrate=[0x%x][%u]\n", max_bitrate
, max_bitrate
);
639 streams
[2*i
] = stream_id
;
640 streams
[2*i
+1] = max_bitrate
;
642 mp_msg(MSGT_HEADER
,MSGL_V
,"============ ASF Stream group == END ===\n");
646 start
= stream_tell(demuxer
->stream
); // start of first data chunk
647 stream_read(demuxer
->stream
, guid_buffer
, 16);
648 if (memcmp(guid_buffer
, asf_data_chunk_guid
, 16) != 0) {
649 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_NoDataChunkAfterHeader
);
654 // read length of chunk
655 stream_read(demuxer
->stream
, (char *)&data_len
, sizeof(data_len
));
656 data_len
= le2me_64(data_len
);
657 demuxer
->movi_start
= stream_tell(demuxer
->stream
) + 26;
658 demuxer
->movi_end
= start
+ data_len
;
659 mp_msg(MSGT_HEADER
, MSGL_V
, "Found movie at 0x%X - 0x%X\n",
660 (int)demuxer
->movi_start
, (int)demuxer
->movi_end
);
663 // stream selection is done in the network code, it shouldn't be done here
664 // as the servers often do not care about what we requested.
666 uint32_t vr
= 0, ar
= 0,i
;
667 #ifdef CONFIG_NETWORK
668 if( demuxer
->stream
->streaming_ctrl
!=NULL
) {
669 if( demuxer
->stream
->streaming_ctrl
->bandwidth
!=0 && demuxer
->stream
->streaming_ctrl
->data
!=NULL
) {
670 best_audio
= ((asf_http_streaming_ctrl_t
*)demuxer
->stream
->streaming_ctrl
->data
)->audio_id
;
671 best_video
= ((asf_http_streaming_ctrl_t
*)demuxer
->stream
->streaming_ctrl
->data
)->video_id
;
675 for(i
= 0; i
< stream_count
; i
++) {
676 uint32_t id
= streams
[2*i
];
677 uint32_t rate
= streams
[2*i
+1];
678 if(demuxer
->v_streams
[id
] && rate
> vr
) {
681 } else if(demuxer
->a_streams
[id
] && rate
> ar
) {
691 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF: %d audio and %d video streams found\n",audio_streams
,video_streams
);
692 if(!audio_streams
) demuxer
->audio
->id
=-2; // nosound
693 else if(best_audio
> 0 && demuxer
->audio
->id
== -1) demuxer
->audio
->id
=best_audio
;
696 mp_msg(MSGT_HEADER
,MSGL_ERR
,MSGTR_MPDEMUX_ASFHDR_AudioVideoHeaderNotFound
);
699 demuxer
->video
->id
=-2; // audio-only
700 } else if (best_video
> 0 && demuxer
->video
->id
== -1) demuxer
->video
->id
= best_video
;
703 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ){
704 printf("ASF duration: %d\n",(int)fileh
.duration
);
705 printf("ASF start pts: %d\n",(int)fileh
.start_timestamp
);
706 printf("ASF end pts: %d\n",(int)fileh
.end_timestamp
);
713 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_InvalidLengthInASFHeader
);
716 if (streams
) free(streams
);