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"
40 // must be 0 for metadata record, might be non-zero for metadata lib record
41 uint16_t lang_list_index
;
50 static char* get_ucs2str(const uint16_t* inbuf
, uint16_t inlen
)
52 char* outbuf
= calloc(inlen
, 2);
57 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MemAllocFailed
);
61 for (i
= 0; i
< inlen
/ 2; i
++) {
63 PUT_UTF8(AV_RL16(&inbuf
[i
]), tmp
, *q
++ = tmp
;)
68 static const char* asf_chunk_type(unsigned char* guid
) {
73 switch(ASF_LOAD_GUID_PREFIX(guid
)){
74 case ASF_GUID_PREFIX_audio_stream
:
75 return "guid_audio_stream";
76 case ASF_GUID_PREFIX_ext_audio_stream
:
77 return "guid_ext_audio_stream";
78 case ASF_GUID_PREFIX_ext_stream_embed_stream_header
:
79 return "guid_ext_stream_embed_stream_header";
80 case ASF_GUID_PREFIX_video_stream
:
81 return "guid_video_stream";
82 case ASF_GUID_PREFIX_audio_conceal_none
:
83 return "guid_audio_conceal_none";
84 case ASF_GUID_PREFIX_audio_conceal_interleave
:
85 return "guid_audio_conceal_interleave";
86 case ASF_GUID_PREFIX_header
:
88 case ASF_GUID_PREFIX_data_chunk
:
89 return "guid_data_chunk";
90 case ASF_GUID_PREFIX_index_chunk
:
91 return "guid_index_chunk";
92 case ASF_GUID_PREFIX_stream_header
:
93 return "guid_stream_header";
94 case ASF_GUID_PREFIX_header_2_0
:
95 return "guid_header_2_0";
96 case ASF_GUID_PREFIX_file_header
:
97 return "guid_file_header";
98 case ASF_GUID_PREFIX_content_desc
:
99 return "guid_content_desc";
100 case ASF_GUID_PREFIX_dvr_ms_timing_rep_data
:
101 return "guid_dvr_ms_timing_rep_data";
102 case ASF_GUID_PREFIX_dvr_ms_vid_frame_rep_data
:
103 return "guid_dvr_ms_vid_frame_rep_data";
105 strcpy(tmp
, "unknown guid ");
106 p
= tmp
+ strlen(tmp
);
107 for (i
= 0; i
< 16; i
++) {
108 if ((1 << i
) & ((1<<4) | (1<<6) | (1<<8))) *p
++ = '-';
109 sprintf(p
, "%02x", guid
[i
]);
116 int asf_check_header(demuxer_t
*demuxer
){
117 unsigned char asfhdrguid
[16]={0x30,0x26,0xB2,0x75,0x8E,0x66,0xCF,0x11,0xA6,0xD9,0x00,0xAA,0x00,0x62,0xCE,0x6C};
118 struct asf_priv
* asf
= calloc(1,sizeof(*asf
));
119 asf
->scrambling_h
=asf
->scrambling_w
=asf
->scrambling_b
=1;
120 stream_read(demuxer
->stream
,(char*) &asf
->header
,sizeof(asf
->header
)); // header obj
121 le2me_ASF_header_t(&asf
->header
); // swap to machine endian
122 // for(i=0;i<16;i++) printf(" %02X",temp[i]);printf("\n");
123 // for(i=0;i<16;i++) printf(" %02X",asfhdrguid[i]);printf("\n");
124 if(memcmp(asfhdrguid
,asf
->header
.objh
.guid
,16)){
125 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF_check: not ASF guid!\n");
127 return 0; // not ASF guid
129 if(asf
->header
.cno
>256){
130 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF_check: invalid subchunks_no %d\n",(int) asf
->header
.cno
);
132 return 0; // invalid header???
135 return DEMUXER_TYPE_ASF
;
138 void print_wave_header(WAVEFORMATEX
*h
, int verbose_level
);
139 void print_video_header(BITMAPINFOHEADER
*h
, int verbose_level
);
142 static int get_ext_stream_properties(char *buf
, int buf_len
, int stream_num
, struct asf_priv
* asf
, int is_video
)
145 uint8_t *buffer
= &buf
[0];
149 while ((pos
= find_asf_guid(buf
, asf_ext_stream_header
, pos
, buf_len
)) >= 0) {
150 int this_stream_num
, stnamect
, payct
, i
;
151 int buf_max_index
=pos
+50;
152 if (buf_max_index
> buf_len
) return 0;
155 // the following info is available
156 // some of it may be useful but we're skipping it for now
157 // starttime(8 bytes), endtime(8),
158 // leak-datarate(4), bucket-datasize(4), init-bucket-fullness(4),
159 // alt-leak-datarate(4), alt-bucket-datasize(4), alt-init-bucket-fullness(4),
160 // max-object-size(4),
161 // flags(4) (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
164 bitrate
= AV_RL32(buffer
);
166 this_stream_num
=AV_RL16(buffer
);buffer
+=2;
168 if (this_stream_num
== stream_num
) {
170 if (buf_max_index
> buf_len
) return 0;
171 buffer
+=2; //skip stream-language-id-index
172 avg_ft
= AV_RL64(buffer
); // provided in 100ns units
174 asf
->bps
= bitrate
/ 8;
176 // after this are values for stream-name-count and
177 // payload-extension-system-count
178 // followed by associated info for each
179 stnamect
= AV_RL16(buffer
);buffer
+=2;
180 payct
= AV_RL16(buffer
);buffer
+=2;
182 // need to read stream names if present in order
183 // to get lengths - values are ignored for now
184 for (i
=0; i
<stnamect
; i
++) {
187 if (buf_max_index
> buf_len
) return 0;
188 buffer
+=2; //language_id_index
189 stream_name_len
= AV_RL16(buffer
);buffer
+=2;
190 buffer
+=stream_name_len
; //stream_name
191 buf_max_index
+=stream_name_len
;
192 if (buf_max_index
> buf_len
) return 0;
196 asf
->vid_repdata_count
= payct
;
197 asf
->vid_repdata_sizes
= malloc(payct
*sizeof(int));
199 asf
->aud_repdata_count
= payct
;
200 asf
->aud_repdata_sizes
= malloc(payct
*sizeof(int));
203 for (i
=0; i
<payct
; i
++) {
206 if (buf_max_index
> buf_len
) return 0;
207 // Each payload extension definition starts with a GUID.
208 // In dvr-ms files one of these indicates the presence an
209 // extension that contains pts values and this is always present
210 // in the video and audio streams.
211 // Another GUID indicates the presence of an extension
212 // that contains useful video frame demuxing information.
213 // Note that the extension data in each packet does not contain
214 // these GUIDs and that this header section defines the order the data
216 if (memcmp(buffer
, asf_dvr_ms_timing_rep_data
, 16) == 0) {
218 asf
->vid_ext_timing_index
= i
;
220 asf
->aud_ext_timing_index
= i
;
221 } else if (is_video
&& memcmp(buffer
, asf_dvr_ms_vid_frame_rep_data
, 16) == 0)
222 asf
->vid_ext_frame_index
= i
;
225 payload_len
= AV_RL16(buffer
);buffer
+=2;
228 asf
->vid_repdata_sizes
[i
] = payload_len
;
230 asf
->aud_repdata_sizes
[i
] = payload_len
;
240 #define CHECKDEC(l, n) if (((l) -= (n)) < 0) return 0
241 static char* read_meta_record(ASF_meta_record_t
* dest
, char* buf
,
244 CHECKDEC(*buf_len
, 2 + 2 + 2 + 2 + 4);
245 dest
->lang_list_index
= AV_RL16(buf
);
246 dest
->stream_num
= AV_RL16(&buf
[2]);
247 dest
->name_length
= AV_RL16(&buf
[4]);
248 dest
->data_type
= AV_RL16(&buf
[6]);
249 dest
->data_length
= AV_RL32(&buf
[8]);
250 buf
+= 2 + 2 + 2 + 2 + 4;
251 CHECKDEC(*buf_len
, dest
->name_length
);
252 dest
->name
= (uint16_t*)buf
;
253 buf
+= dest
->name_length
;
254 CHECKDEC(*buf_len
, dest
->data_length
);
256 buf
+= dest
->data_length
;
260 static int get_meta(char *buf
, int buf_len
, int this_stream_num
,
264 uint16_t records_count
;
265 uint16_t x
= 0, y
= 0;
267 if ((pos
= find_asf_guid(buf
, asf_metadata_header
, pos
, buf_len
)) < 0)
270 CHECKDEC(buf_len
, pos
);
272 CHECKDEC(buf_len
, 2);
273 records_count
= AV_RL16(buf
);
276 while (records_count
--) {
277 ASF_meta_record_t record_entry
;
280 if (!(buf
= read_meta_record(&record_entry
, buf
, &buf_len
)))
282 /* reserved, must be zero */
283 if (record_entry
.lang_list_index
)
285 /* match stream number: 0 to match all */
286 if (record_entry
.stream_num
&& record_entry
.stream_num
!= this_stream_num
)
288 if (!(name
= get_ucs2str(record_entry
.name
, record_entry
.name_length
))) {
289 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MemAllocFailed
);
292 if (strcmp(name
, "AspectRatioX") == 0)
293 x
= AV_RL16(record_entry
.data
);
294 else if (strcmp(name
, "AspectRatioY") == 0)
295 y
= AV_RL16(record_entry
.data
);
299 *asp_ratio
= (float)x
/ (float)y
;
305 static int is_drm(char* buf
, int buf_len
)
307 uint32_t data_len
, type_len
, key_len
, url_len
;
308 int pos
= find_asf_guid(buf
, asf_content_encryption
, 0, buf_len
);
313 CHECKDEC(buf_len
, pos
+ 4);
315 data_len
= AV_RL32(buf
);
317 CHECKDEC(buf_len
, data_len
);
319 type_len
= AV_RL32(buf
);
322 CHECKDEC(buf_len
, 4 + type_len
+ 4);
325 if (buf
[0] != 'D' || buf
[1] != 'R' || buf
[2] != 'M' || buf
[3] != '\0')
329 key_len
= AV_RL32(buf
);
330 CHECKDEC(buf_len
, key_len
+ 4);
333 buf
[key_len
- 1] = '\0';
334 mp_msg(MSGT_HEADER
, MSGL_V
, "DRM Key ID: %s\n", buf
);
337 url_len
= AV_RL32(buf
);
338 CHECKDEC(buf_len
, url_len
);
341 buf
[url_len
- 1] = '\0';
342 mp_msg(MSGT_HEADER
, MSGL_INFO
, MSGTR_MPDEMUX_ASFHDR_DRMLicenseURL
, buf
);
346 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
)
348 uint8_t *buffer
= *buf
;
351 sh_audio
->wf
=calloc((streamh
->type_size
<sizeof(WAVEFORMATEX
))?sizeof(WAVEFORMATEX
):streamh
->type_size
,1);
352 memcpy(sh_audio
->wf
,buffer
,streamh
->type_size
);
353 le2me_WAVEFORMATEX(sh_audio
->wf
);
354 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_wave_header(sh_audio
->wf
,MSGL_V
);
355 if(ASF_LOAD_GUID_PREFIX(streamh
->concealment
)==ASF_GUID_PREFIX_audio_conceal_interleave
){
357 pos
+= streamh
->stream_size
;
358 if (pos
> hdr_len
) return 0;
359 asf
->scrambling_h
=buffer
[0];
360 asf
->scrambling_w
=(buffer
[2]<<8)|buffer
[1];
361 asf
->scrambling_b
=(buffer
[4]<<8)|buffer
[3];
362 if(asf
->scrambling_b
>0){
363 asf
->scrambling_w
/=asf
->scrambling_b
;
366 asf
->scrambling_b
=asf
->scrambling_h
=asf
->scrambling_w
=1;
368 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF: audio scrambling: %d x %d x %d\n",asf
->scrambling_h
,asf
->scrambling_w
,asf
->scrambling_b
);
372 static int find_backwards_asf_guid(char *buf
, const char *guid
, int cur_pos
)
375 for (i
=cur_pos
-16; i
>0; i
--) {
376 if (memcmp(&buf
[i
], guid
, 16) == 0)
377 return i
+ 16 + 8; // point after guid + length
382 int read_asf_header(demuxer_t
*demuxer
,struct asf_priv
* asf
){
383 int hdr_len
= asf
->header
.objh
.size
- sizeof(asf
->header
);
386 char guid_buffer
[16];
387 int pos
, start
= stream_tell(demuxer
->stream
);
388 uint32_t* streams
= NULL
;
391 uint16_t stream_count
=0;
395 ASF_stream_header_t
*streamh
;
400 mp_msg(MSGT_HEADER
, MSGL_FATAL
, "Header size is too small.\n");
404 if (hdr_len
> 1024 * 1024) {
405 mp_msg(MSGT_HEADER
, MSGL_ERR
, MSGTR_MPDEMUX_ASFHDR_HeaderSizeOver1MB
,
407 hdr_skip
= hdr_len
- 1024 * 1024;
408 hdr_len
= 1024 * 1024;
410 hdr
= malloc(hdr_len
);
412 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_HeaderMallocFailed
,
416 stream_read(demuxer
->stream
, hdr
, hdr_len
);
418 stream_skip(demuxer
->stream
, hdr_skip
);
419 if (stream_eof(demuxer
->stream
)) {
420 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_EOFWhileReadingHeader
);
424 if (is_drm(hdr
, hdr_len
))
425 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_DRMProtected
);
427 if ((pos
= find_asf_guid(hdr
, asf_ext_stream_audio
, 0, hdr_len
)) >= 0)
429 // Special case: found GUID for dvr-ms audio.
430 // Now skip back to associated stream header.
433 sh_pos
= find_backwards_asf_guid(hdr
, asf_stream_header_guid
, pos
);
436 sh_audio_t
*sh_audio
;
438 mp_msg(MSGT_HEADER
, MSGL_V
, "read_asf_header found dvr-ms audio stream header pos=%d\n", sh_pos
);
439 // found audio stream header - following code reads header and
440 // initializes audio stream.
441 audio_pos
= pos
- 16 - 8;
442 streamh
= (ASF_stream_header_t
*)&hdr
[sh_pos
];
443 le2me_ASF_stream_header_t(streamh
);
444 audio_pos
+= 64; //16+16+4+4+4+16+4;
445 buffer
= &hdr
[audio_pos
];
446 sh_audio
=new_sh_audio(demuxer
,streamh
->stream_no
& 0x7F);
447 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_AudioID
, "asfheader", streamh
->stream_no
& 0x7F);
449 if (!asf_init_audio_stream(demuxer
, asf
, sh_audio
, streamh
, &audio_pos
, &buffer
, hdr
, hdr_len
))
451 if (!get_ext_stream_properties(hdr
, hdr_len
, streamh
->stream_no
, asf
, 0))
455 // find stream headers
456 // only reset pos if we didnt find dvr_ms audio stream
457 // if we did find it then we want to avoid reading its header twice
461 while ((pos
= find_asf_guid(hdr
, asf_stream_header_guid
, pos
, hdr_len
)) >= 0)
463 streamh
= (ASF_stream_header_t
*)&hdr
[pos
];
464 pos
+= sizeof(ASF_stream_header_t
);
465 if (pos
> hdr_len
) goto len_err_out
;
466 le2me_ASF_stream_header_t(streamh
);
467 mp_msg(MSGT_HEADER
, MSGL_V
, "stream type: %s\n",
468 asf_chunk_type(streamh
->type
));
469 mp_msg(MSGT_HEADER
, MSGL_V
, "stream concealment: %s\n",
470 asf_chunk_type(streamh
->concealment
));
471 mp_msg(MSGT_HEADER
, MSGL_V
, "type: %d bytes, stream: %d bytes ID: %d\n",
472 (int)streamh
->type_size
, (int)streamh
->stream_size
,
473 (int)streamh
->stream_no
);
474 mp_msg(MSGT_HEADER
, MSGL_V
, "unk1: %lX unk2: %X\n",
475 (unsigned long)streamh
->unk1
, (unsigned int)streamh
->unk2
);
476 mp_msg(MSGT_HEADER
, MSGL_V
, "FILEPOS=0x%X\n", pos
+ start
);
477 // type-specific data:
479 pos
+= streamh
->type_size
;
480 if (pos
> hdr_len
) goto len_err_out
;
481 switch(ASF_LOAD_GUID_PREFIX(streamh
->type
)){
482 case ASF_GUID_PREFIX_audio_stream
: {
483 sh_audio_t
* sh_audio
=new_sh_audio(demuxer
,streamh
->stream_no
& 0x7F);
484 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_AudioID
, "asfheader", streamh
->stream_no
& 0x7F);
486 if (!asf_init_audio_stream(demuxer
, asf
, sh_audio
, streamh
, &pos
, &buffer
, hdr
, hdr_len
))
488 //if(demuxer->audio->id==-1) demuxer->audio->id=streamh.stream_no & 0x7F;
491 case ASF_GUID_PREFIX_video_stream
: {
494 sh_video_t
* sh_video
=new_sh_video(demuxer
,streamh
->stream_no
& 0x7F);
495 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_VideoID
, "asfheader", streamh
->stream_no
& 0x7F);
496 len
=streamh
->type_size
-(4+4+1+2);
498 // sh_video->bih=malloc(chunksize); memset(sh_video->bih,0,chunksize);
499 sh_video
->bih
=calloc((len
<sizeof(BITMAPINFOHEADER
))?sizeof(BITMAPINFOHEADER
):len
,1);
500 memcpy(sh_video
->bih
,&buffer
[4+4+1+2],len
);
501 le2me_BITMAPINFOHEADER(sh_video
->bih
);
502 if (sh_video
->bih
->biSize
> len
&& sh_video
->bih
->biSize
> sizeof(BITMAPINFOHEADER
))
503 sh_video
->bih
->biSize
= len
;
504 if (sh_video
->bih
->biCompression
== mmioFOURCC('D', 'V', 'R', ' ')) {
505 //mp_msg(MSGT_DEMUXER, MSGL_WARN, MSGTR_MPDEMUX_ASFHDR_DVRWantsLibavformat);
506 //sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
507 //sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
508 asf
->asf_frame_state
=-1;
509 asf
->asf_frame_start_found
=0;
510 asf
->asf_is_dvr_ms
=1;
511 asf
->dvr_last_vid_pts
=0.0;
512 } else asf
->asf_is_dvr_ms
=0;
513 if (!get_ext_stream_properties(hdr
, hdr_len
, streamh
->stream_no
, asf
, 1))
515 if (get_meta(hdr
, hdr_len
, streamh
->stream_no
, &asp_ratio
)) {
516 sh_video
->aspect
= asp_ratio
* sh_video
->bih
->biWidth
/
517 sh_video
->bih
->biHeight
;
519 sh_video
->i_bps
= asf
->bps
;
521 if( mp_msg_test(MSGT_DEMUX
,MSGL_V
) ) print_video_header(sh_video
->bih
, MSGL_V
);
522 //asf_video_id=streamh.stream_no & 0x7F;
523 //if(demuxer->video->id==-1) demuxer->video->id=streamh.stream_no & 0x7F;
527 // stream-specific data:
528 // stream_read(demuxer->stream,(char*) buffer,streamh.stream_size);
532 pos
= find_asf_guid(hdr
, asf_file_header_guid
, 0, hdr_len
);
534 ASF_file_header_t
*fileh
= (ASF_file_header_t
*)&hdr
[pos
];
535 pos
+= sizeof(ASF_file_header_t
);
536 if (pos
> hdr_len
) goto len_err_out
;
537 le2me_ASF_file_header_t(fileh
);
538 mp_msg(MSGT_HEADER
, MSGL_V
, "ASF: packets: %d flags: %d "
539 "max_packet_size: %d min_packet_size: %d max_bitrate: %d "
541 (int)fileh
->num_packets
, (int)fileh
->flags
,
542 (int)fileh
->min_packet_size
, (int)fileh
->max_packet_size
,
543 (int)fileh
->max_bitrate
, (int)fileh
->preroll
);
544 asf
->packetsize
=fileh
->max_packet_size
;
545 asf
->packet
=malloc(asf
->packetsize
); // !!!
546 asf
->packetrate
=fileh
->max_bitrate
/8.0/(double)asf
->packetsize
;
547 asf
->movielength
=(fileh
->play_duration
-fileh
->preroll
)/10000000LL;
550 // find content header
551 pos
= find_asf_guid(hdr
, asf_content_desc_guid
, 0, hdr_len
);
553 ASF_content_description_t
*contenth
= (ASF_content_description_t
*)&hdr
[pos
];
555 uint16_t* wstring
= NULL
;
557 pos
+= sizeof(ASF_content_description_t
);
558 if (pos
> hdr_len
) goto len_err_out
;
559 le2me_ASF_content_description_t(contenth
);
560 mp_msg(MSGT_HEADER
,MSGL_V
,"\n");
562 if((len
= contenth
->title_size
) != 0) {
563 wstring
= (uint16_t*)&hdr
[pos
];
565 if (pos
> hdr_len
) goto len_err_out
;
566 if ((string
= get_ucs2str(wstring
, len
))) {
567 mp_msg(MSGT_HEADER
,MSGL_V
," Title: %s\n", string
);
568 demux_info_add(demuxer
, "title", string
);
572 // extract the author
573 if((len
= contenth
->author_size
) != 0) {
574 wstring
= (uint16_t*)&hdr
[pos
];
576 if (pos
> hdr_len
) goto len_err_out
;
577 if ((string
= get_ucs2str(wstring
, len
))) {
578 mp_msg(MSGT_HEADER
,MSGL_V
," Author: %s\n", string
);
579 demux_info_add(demuxer
, "author", string
);
583 // extract the copyright
584 if((len
= contenth
->copyright_size
) != 0) {
585 wstring
= (uint16_t*)&hdr
[pos
];
587 if (pos
> hdr_len
) goto len_err_out
;
588 if ((string
= get_ucs2str(wstring
, len
))) {
589 mp_msg(MSGT_HEADER
,MSGL_V
," Copyright: %s\n", string
);
590 demux_info_add(demuxer
, "copyright", string
);
594 // extract the comment
595 if((len
= contenth
->comment_size
) != 0) {
596 wstring
= (uint16_t*)&hdr
[pos
];
598 if (pos
> hdr_len
) goto len_err_out
;
599 if ((string
= get_ucs2str(wstring
, len
))) {
600 mp_msg(MSGT_HEADER
,MSGL_V
," Comment: %s\n", string
);
601 demux_info_add(demuxer
, "comments", string
);
605 // extract the rating
606 if((len
= contenth
->rating_size
) != 0) {
607 wstring
= (uint16_t*)&hdr
[pos
];
609 if (pos
> hdr_len
) goto len_err_out
;
610 if ((string
= get_ucs2str(wstring
, len
))) {
611 mp_msg(MSGT_HEADER
,MSGL_V
," Rating: %s\n", string
);
615 mp_msg(MSGT_HEADER
,MSGL_V
,"\n");
618 // find content header
619 pos
= find_asf_guid(hdr
, asf_stream_group_guid
, 0, hdr_len
);
621 int max_streams
= (hdr_len
- pos
- 2) / 6;
622 uint16_t stream_id
, i
;
623 uint32_t max_bitrate
;
624 char *ptr
= &hdr
[pos
];
625 mp_msg(MSGT_HEADER
,MSGL_V
,"============ ASF Stream group == START ===\n");
626 if(max_streams
<= 0) goto len_err_out
;
627 stream_count
= AV_RL16(ptr
);
628 ptr
+= sizeof(uint16_t);
629 if(stream_count
> max_streams
) stream_count
= max_streams
;
631 streams
= malloc(2*stream_count
*sizeof(uint32_t));
632 mp_msg(MSGT_HEADER
,MSGL_V
," stream count=[0x%x][%u]\n", stream_count
, stream_count
);
633 for( i
=0 ; i
<stream_count
; i
++ ) {
634 stream_id
= AV_RL16(ptr
);
635 ptr
+= sizeof(uint16_t);
636 memcpy(&max_bitrate
, ptr
, sizeof(uint32_t));// workaround unaligment bug on sparc
637 max_bitrate
= le2me_32(max_bitrate
);
638 ptr
+= sizeof(uint32_t);
639 mp_msg(MSGT_HEADER
,MSGL_V
," stream id=[0x%x][%u]\n", stream_id
, stream_id
);
640 mp_msg(MSGT_HEADER
,MSGL_V
," max bitrate=[0x%x][%u]\n", max_bitrate
, max_bitrate
);
641 streams
[2*i
] = stream_id
;
642 streams
[2*i
+1] = max_bitrate
;
644 mp_msg(MSGT_HEADER
,MSGL_V
,"============ ASF Stream group == END ===\n");
648 start
= stream_tell(demuxer
->stream
); // start of first data chunk
649 stream_read(demuxer
->stream
, guid_buffer
, 16);
650 if (memcmp(guid_buffer
, asf_data_chunk_guid
, 16) != 0) {
651 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_NoDataChunkAfterHeader
);
656 // read length of chunk
657 stream_read(demuxer
->stream
, (char *)&data_len
, sizeof(data_len
));
658 data_len
= le2me_64(data_len
);
659 demuxer
->movi_start
= stream_tell(demuxer
->stream
) + 26;
660 demuxer
->movi_end
= start
+ data_len
;
661 mp_msg(MSGT_HEADER
, MSGL_V
, "Found movie at 0x%X - 0x%X\n",
662 (int)demuxer
->movi_start
, (int)demuxer
->movi_end
);
665 // stream selection is done in the network code, it shouldn't be done here
666 // as the servers often do not care about what we requested.
668 uint32_t vr
= 0, ar
= 0,i
;
669 #ifdef CONFIG_NETWORK
670 if( demuxer
->stream
->streaming_ctrl
!=NULL
) {
671 if( demuxer
->stream
->streaming_ctrl
->bandwidth
!=0 && demuxer
->stream
->streaming_ctrl
->data
!=NULL
) {
672 best_audio
= ((asf_http_streaming_ctrl_t
*)demuxer
->stream
->streaming_ctrl
->data
)->audio_id
;
673 best_video
= ((asf_http_streaming_ctrl_t
*)demuxer
->stream
->streaming_ctrl
->data
)->video_id
;
677 for(i
= 0; i
< stream_count
; i
++) {
678 uint32_t id
= streams
[2*i
];
679 uint32_t rate
= streams
[2*i
+1];
680 if(demuxer
->v_streams
[id
] && rate
> vr
) {
683 } else if(demuxer
->a_streams
[id
] && rate
> ar
) {
693 mp_msg(MSGT_HEADER
,MSGL_V
,"ASF: %d audio and %d video streams found\n",audio_streams
,video_streams
);
694 if(!audio_streams
) demuxer
->audio
->id
=-2; // nosound
695 else if(best_audio
> 0 && demuxer
->audio
->id
== -1) demuxer
->audio
->id
=best_audio
;
698 mp_msg(MSGT_HEADER
,MSGL_ERR
,MSGTR_MPDEMUX_ASFHDR_AudioVideoHeaderNotFound
);
701 demuxer
->video
->id
=-2; // audio-only
702 } else if (best_video
> 0 && demuxer
->video
->id
== -1) demuxer
->video
->id
= best_video
;
705 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ){
706 printf("ASF duration: %d\n",(int)fileh
.duration
);
707 printf("ASF start pts: %d\n",(int)fileh
.start_timestamp
);
708 printf("ASF end pts: %d\n",(int)fileh
.end_timestamp
);
715 mp_msg(MSGT_HEADER
, MSGL_FATAL
, MSGTR_MPDEMUX_ASFHDR_InvalidLengthInASFHeader
);
718 if (streams
) free(streams
);