Mercurial > mplayer.hg
annotate libmpdemux/demux_real.c @ 26096:e6a565ec1a3b
New S3 VIDIX driver.
Provides support for S3 Trio and S3 Virge chipsets.
This deprecates the old Savage driver that worked with latest chips only.
(synchronized with vidix.sf.net r326 and r327)
author | ben |
---|---|
date | Fri, 29 Feb 2008 20:01:28 +0000 |
parents | 1318e956c092 |
children | 4617c374f752 |
rev | line source |
---|---|
3777 | 1 /* |
2 Real parser & demuxer | |
3 | |
10368 | 4 (C) Alex Beregszaszi |
17388
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
5 (C) 2005, 2006 Roberto Togni |
3777 | 6 |
7 Based on FFmpeg's libav/rm.c. | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
8 |
3795 | 9 Audio codecs: (supported by RealPlayer8 for Linux) |
4235 | 10 DNET - RealAudio 3.0, really it's AC3 in swapped-byteorder |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
11 SIPR - SiproLab's audio codec, ACELP decoder working with MPlayer, |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
12 needs fine-tuning too :) |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
13 ATRC - RealAudio 8 (ATRAC3) - www.minidisc.org/atrac3_article.pdf, |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
14 ACM decoder uploaded, needs some fine-tuning to work |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
15 -> RealAudio 8 |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
16 COOK/COKR - Real Cooker -> RealAudio G2 |
3795 | 17 |
18 Video codecs: (supported by RealPlayer8 for Linux) | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
19 RV10 - H.263 based, working with libavcodec's decoder |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
20 RV20-RV40 - using RealPlayer's codec plugins |
3788 | 21 */ |
22 | |
3777 | 23 #include <stdio.h> |
24 #include <stdlib.h> | |
25 #include <unistd.h> | |
23632 | 26 #include <inttypes.h> |
3777 | 27 |
28 #include "config.h" | |
29 #include "mp_msg.h" | |
30 #include "help_mp.h" | |
31 | |
22605
4d81dbdf46b9
Add explicit location for headers from the stream/ directory.
diego
parents:
22018
diff
changeset
|
32 #include "stream/stream.h" |
3777 | 33 #include "demuxer.h" |
34 #include "stheader.h" | |
35 | |
26069
1318e956c092
FFmpeg now uses different (unified) #include paths.
diego
parents:
25919
diff
changeset
|
36 #ifdef USE_LIBAVCODEC |
17343
b07bb7ee7ce4
include the right avcodec.h, consistently with the rest of mplayer
nicodvb
parents:
17318
diff
changeset
|
37 #include "libavcodec/avcodec.h" |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
38 #else |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
39 #define FF_INPUT_BUFFER_PADDING_SIZE 8 |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
40 #endif |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
41 |
6369 | 42 //#define mp_dbg(mod,lev, args... ) mp_msg_c((mod<<8)|lev, ## args ) |
43 | |
3777 | 44 #define MKTAG(a, b, c, d) (a | (b << 8) | (c << 16) | (d << 24)) |
45 | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
46 #define MAX_STREAMS 32 |
3777 | 47 |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
48 static unsigned char sipr_swaps[38][2]={ |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
49 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68}, |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
50 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46}, |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
51 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56}, |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
52 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83}, |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
53 {77,80} }; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
54 |
3777 | 55 typedef struct { |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
56 unsigned int timestamp; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
57 int offset; |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
58 // int packetno; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
59 // int len; /* only filled by our index generator */ |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
60 // int flags; /* only filled by our index generator */ |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
61 } real_index_table_t; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
62 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
63 typedef struct { |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
64 /* for seeking */ |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
65 int index_chunk_offset; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
66 real_index_table_t *index_table[MAX_STREAMS]; |
11441 | 67 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
68 // int *index_table[MAX_STREAMS]; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
69 int index_table_size[MAX_STREAMS]; |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
70 int index_malloc_size[MAX_STREAMS]; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
71 int data_chunk_offset; |
3777 | 72 int num_of_packets; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
73 int current_packet; |
11441 | 74 |
75 // need for seek | |
76 int audio_need_keyframe; | |
77 int video_after_seek; | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
78 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
79 int current_apacket; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
80 int current_vpacket; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
81 |
6423 | 82 // timestamp correction: |
20229
cd827d62fb71
Fix timestamps for streams where kf_base gets negative
rtogni
parents:
20198
diff
changeset
|
83 int64_t kf_base;// timestamp of the prev. video keyframe |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
84 unsigned int kf_pts; // timestamp of next video keyframe |
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
85 unsigned int a_pts; // previous audio timestamp |
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
86 double v_pts; // previous video timestamp |
11441 | 87 unsigned long duration; |
6423 | 88 |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
89 /* stream id table */ |
7710 | 90 // int last_a_stream; |
91 // int a_streams[MAX_STREAMS]; | |
92 // int last_v_stream; | |
93 // int v_streams[MAX_STREAMS]; | |
14402 | 94 |
95 /** | |
96 * Used to demux multirate files | |
97 */ | |
98 int is_multirate; ///< != 0 for multirate files | |
99 int str_data_offset[MAX_STREAMS]; ///< Data chunk offset for every audio/video stream | |
100 int audio_curpos; ///< Current file position for audio demuxing | |
101 int video_curpos; ///< Current file position for video demuxing | |
102 int a_num_of_packets; ///< Number of audio packets | |
103 int v_num_of_packets; ///< Number of video packets | |
104 int a_idx_ptr; ///< Audio index position pointer | |
105 int v_idx_ptr; ///< Video index position pointer | |
106 int a_bitrate; ///< Audio bitrate | |
107 int v_bitrate; ///< Video bitrate | |
108 int stream_switch; ///< Flag used to switch audio/video demuxing | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
109 |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
110 /** |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
111 * Used to reorder audio data |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
112 */ |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
113 unsigned int intl_id[MAX_STREAMS]; ///< interleaver id, per stream |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
114 int sub_packet_size[MAX_STREAMS]; ///< sub packet size, per stream |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
115 int sub_packet_h[MAX_STREAMS]; ///< number of coded frames per block |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
116 int coded_framesize[MAX_STREAMS]; ///< coded frame size, per stream |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
117 int audiopk_size[MAX_STREAMS]; ///< audio packet size |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
118 unsigned char *audio_buf; ///< place to store reordered audio data |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
119 double *audio_timestamp; ///< timestamp for each audio packet |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
120 int sub_packet_cnt; ///< number of subpacket already received |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
121 int audio_filepos; ///< file position of first audio packet in block |
3777 | 122 } real_priv_t; |
123 | |
18444
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
124 //! use at most 200 MB of memory for index, corresponds to around 25 million entries |
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
125 #define MAX_INDEX_ENTRIES (200*1024*1024 / sizeof(real_index_table_t)) |
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
126 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
127 /* originally from FFmpeg */ |
3777 | 128 static void get_str(int isbyte, demuxer_t *demuxer, char *buf, int buf_size) |
129 { | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
130 int len; |
3777 | 131 |
132 if (isbyte) | |
133 len = stream_read_char(demuxer->stream); | |
134 else | |
135 len = stream_read_word(demuxer->stream); | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
136 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
137 stream_read(demuxer->stream, buf, (len > buf_size) ? buf_size : len); |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
138 if (len > buf_size) |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
139 stream_skip(demuxer->stream, len-buf_size); |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
140 |
11870 | 141 mp_msg(MSGT_DEMUX, MSGL_V, "read_str: %d bytes read\n", len); |
3777 | 142 } |
143 | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
144 static void dump_index(demuxer_t *demuxer, int stream_id) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
145 { |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
146 real_priv_t *priv = demuxer->priv; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
147 real_index_table_t *index; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
148 int i, entries; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
149 |
17932 | 150 if ( mp_msg_test(MSGT_DEMUX,MSGL_V) ) |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
151 return; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
152 |
18106
3a34a728fa1b
always cast stream IDs to unsigned before comparing to MAX_STREAMS.
reimar
parents:
17977
diff
changeset
|
153 if ((unsigned)stream_id >= MAX_STREAMS) |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
154 return; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
155 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
156 index = priv->index_table[stream_id]; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
157 entries = priv->index_table_size[stream_id]; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
158 |
11870 | 159 mp_msg(MSGT_DEMUX, MSGL_V, "Index table for stream %d\n", stream_id); |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
160 for (i = 0; i < entries; i++) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
161 { |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
162 #if 1 |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
163 mp_msg(MSGT_DEMUX, MSGL_V,"i: %d, pos: %d, timestamp: %u\n", i, index[i].offset, index[i].timestamp); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
164 #else |
11870 | 165 mp_msg(MSGT_DEMUX, MSGL_V,"packetno: %x pos: %x len: %x timestamp: %x flags: %x\n", |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
166 index[i].packetno, index[i].offset, index[i].len, index[i].timestamp, |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
167 index[i].flags); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
168 #endif |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
169 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
170 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
171 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
172 static int parse_index_chunk(demuxer_t *demuxer) |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
173 { |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
174 real_priv_t *priv = demuxer->priv; |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
175 int origpos = stream_tell(demuxer->stream); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
176 int next_header_pos = priv->index_chunk_offset; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
177 int i, entries, stream_id; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
178 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
179 read_index: |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
180 stream_seek(demuxer->stream, next_header_pos); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
181 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
182 i = stream_read_dword_le(demuxer->stream); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
183 if ((i == -256) || (i != MKTAG('I', 'N', 'D', 'X'))) |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
184 { |
11870 | 185 mp_msg(MSGT_DEMUX, MSGL_WARN,"Something went wrong, no index chunk found on given address (%d)\n", |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
186 next_header_pos); |
11441 | 187 index_mode = -1; |
188 if (i == -256) | |
189 stream_reset(demuxer->stream); | |
190 stream_seek(demuxer->stream, origpos); | |
191 return 0; | |
192 //goto end; | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
193 } |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
194 |
11870 | 195 mp_msg(MSGT_DEMUX, MSGL_V,"Reading index table from index chunk (%d)\n", |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
196 next_header_pos); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
197 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
198 i = stream_read_dword(demuxer->stream); |
11870 | 199 mp_msg(MSGT_DEMUX, MSGL_V,"size: %d bytes\n", i); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
200 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
201 i = stream_read_word(demuxer->stream); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
202 if (i != 0) |
11870 | 203 mp_msg(MSGT_DEMUX, MSGL_WARN,"Hmm, index table with unknown version (%d), please report it to MPlayer developers!\n", i); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
204 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
205 entries = stream_read_dword(demuxer->stream); |
11870 | 206 mp_msg(MSGT_DEMUX, MSGL_V,"entries: %d\n", entries); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
207 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
208 stream_id = stream_read_word(demuxer->stream); |
11870 | 209 mp_msg(MSGT_DEMUX, MSGL_V,"stream_id: %d\n", stream_id); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
210 |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
211 next_header_pos = stream_read_dword(demuxer->stream); |
11870 | 212 mp_msg(MSGT_DEMUX, MSGL_V,"next_header_pos: %d\n", next_header_pos); |
18444
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
213 if (entries <= 0 || entries > MAX_INDEX_ENTRIES) |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
214 { |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
215 if (next_header_pos) |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
216 goto read_index; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
217 i = entries; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
218 goto end; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
219 } |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
220 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
221 priv->index_table_size[stream_id] = entries; |
18444
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
222 priv->index_table[stream_id] = calloc(priv->index_table_size[stream_id], sizeof(real_index_table_t)); |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
223 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
224 for (i = 0; i < entries; i++) |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
225 { |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
226 stream_skip(demuxer->stream, 2); /* version */ |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
227 priv->index_table[stream_id][i].timestamp = stream_read_dword(demuxer->stream); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
228 priv->index_table[stream_id][i].offset = stream_read_dword(demuxer->stream); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
229 stream_skip(demuxer->stream, 4); /* packetno */ |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
230 // priv->index_table[stream_id][i].packetno = stream_read_dword(demuxer->stream); |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
231 // printf("Index table: Stream#%d: entry: %d: pos: %d\n", |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
232 // stream_id, i, priv->index_table[stream_id][i].offset); |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
233 } |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
234 |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
235 dump_index(demuxer, stream_id); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
236 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
237 if (next_header_pos > 0) |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
238 goto read_index; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
239 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
240 end: |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
241 if (i == -256) |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
242 stream_reset(demuxer->stream); |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
243 stream_seek(demuxer->stream, origpos); |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
244 if (i == -256) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
245 return 0; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
246 else |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
247 return 1; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
248 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
249 |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
250 #if 1 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
251 |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
252 static void add_index_item(demuxer_t *demuxer, int stream_id, unsigned int timestamp, int offset) |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
253 { |
12665
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
254 if ((unsigned)stream_id < MAX_STREAMS) |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
255 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
256 real_priv_t *priv = demuxer->priv; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
257 real_index_table_t *index; |
18444
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
258 if (priv->index_table_size[stream_id] >= MAX_INDEX_ENTRIES) { |
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
259 mp_msg(MSGT_DEMUXER, MSGL_WARN, "Index too large during building\n"); |
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
260 return; |
fa603193eccf
Fix potential integer overflows in memory allocation. Patch by Reimar and me, SIZE_MAX by Rich
rtognimp
parents:
18176
diff
changeset
|
261 } |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
262 if (priv->index_table_size[stream_id] >= priv->index_malloc_size[stream_id]) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
263 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
264 if (priv->index_malloc_size[stream_id] == 0) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
265 priv->index_malloc_size[stream_id] = 2048; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
266 else |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
267 priv->index_malloc_size[stream_id] += priv->index_malloc_size[stream_id] / 2; |
14897 | 268 // in case we have a really large chunk... |
269 if (priv->index_table_size[stream_id] >= | |
270 priv->index_malloc_size[stream_id]) | |
271 priv->index_malloc_size[stream_id] = | |
272 priv->index_table_size[stream_id] + 1; | |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
273 priv->index_table[stream_id] = realloc(priv->index_table[stream_id], priv->index_malloc_size[stream_id]*sizeof(priv->index_table[0][0])); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
274 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
275 if (priv->index_table_size[stream_id] > 0) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
276 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
277 index = &priv->index_table[stream_id][priv->index_table_size[stream_id] - 1]; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
278 if (index->timestamp >= timestamp || index->offset >= offset) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
279 return; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
280 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
281 index = &priv->index_table[stream_id][priv->index_table_size[stream_id]++]; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
282 index->timestamp = timestamp; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
283 index->offset = offset; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
284 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
285 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
286 |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
287 static void add_index_segment(demuxer_t *demuxer, int seek_stream_id, int64_t seek_timestamp) |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
288 { |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
289 int tag, len, stream_id, flags; |
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
290 unsigned int timestamp; |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
291 if (seek_timestamp != -1 && (unsigned)seek_stream_id >= MAX_STREAMS) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
292 return; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
293 while (1) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
294 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
295 demuxer->filepos = stream_tell(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
296 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
297 tag = stream_read_dword(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
298 if (tag == MKTAG('A', 'T', 'A', 'D')) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
299 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
300 stream_skip(demuxer->stream, 14); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
301 continue; /* skip to next loop */ |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
302 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
303 len = tag & 0xffff; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
304 if (tag == -256 || len < 12) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
305 break; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
306 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
307 stream_id = stream_read_word(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
308 timestamp = stream_read_dword(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
309 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
310 stream_skip(demuxer->stream, 1); /* reserved */ |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
311 flags = stream_read_char(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
312 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
313 if (flags == -256) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
314 break; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
315 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
316 if (flags & 2) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
317 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
318 add_index_item(demuxer, stream_id, timestamp, demuxer->filepos); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
319 if (stream_id == seek_stream_id && timestamp >= seek_timestamp) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
320 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
321 stream_seek(demuxer->stream, demuxer->filepos); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
322 return; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
323 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
324 } |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
325 // printf("Index: stream=%d packet=%d timestamp=%u len=%d flags=0x%x datapos=0x%x\n", stream_id, entries, timestamp, len, flags, index->offset); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
326 /* skip data */ |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
327 stream_skip(demuxer->stream, len-12); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
328 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
329 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
330 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
331 static int generate_index(demuxer_t *demuxer) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
332 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
333 real_priv_t *priv = demuxer->priv; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
334 int origpos = stream_tell(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
335 int data_pos = priv->data_chunk_offset-10; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
336 int i; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
337 int tag; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
338 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
339 stream_seek(demuxer->stream, data_pos); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
340 tag = stream_read_dword(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
341 if (tag != MKTAG('A', 'T', 'A', 'D')) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
342 { |
11870 | 343 mp_msg(MSGT_DEMUX, MSGL_WARN,"Something went wrong, no data chunk found on given address (%d)\n", data_pos); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
344 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
345 else |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
346 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
347 stream_skip(demuxer->stream, 14); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
348 add_index_segment(demuxer, -1, -1); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
349 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
350 for (i = 0; i < MAX_STREAMS; i++) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
351 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
352 if (priv->index_table_size[i] > 0) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
353 { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
354 dump_index(demuxer, i); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
355 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
356 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
357 stream_reset(demuxer->stream); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
358 stream_seek(demuxer->stream, origpos); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
359 return 0; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
360 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
361 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
362 #else |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
363 |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
364 static int generate_index(demuxer_t *demuxer) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
365 { |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
366 real_priv_t *priv = demuxer->priv; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
367 int origpos = stream_tell(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
368 int data_pos = priv->data_chunk_offset-10; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
369 int num_of_packets = 0; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
370 int i, entries = 0; |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
371 int len, stream_id = 0, flags; |
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
372 unsigned int timestamp; |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
373 int tab_pos = 0; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
374 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
375 read_index: |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
376 stream_seek(demuxer->stream, data_pos); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
377 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
378 i = stream_read_dword_le(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
379 if ((i == -256) || (i != MKTAG('D', 'A', 'T', 'A'))) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
380 { |
11870 | 381 mp_msg(MSGT_DEMUX, MSGL_WARN,"Something went wrong, no data chunk found on given address (%d)\n", |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
382 data_pos); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
383 goto end; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
384 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
385 stream_skip(demuxer->stream, 4); /* chunk size */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
386 stream_skip(demuxer->stream, 2); /* version */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
387 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
388 num_of_packets = stream_read_dword(demuxer->stream); |
11870 | 389 mp_msg(MSGT_DEMUX, MSGL_V,"Generating index table from raw data (pos: 0x%x) for %d packets\n", |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
390 data_pos, num_of_packets); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
391 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
392 data_pos = stream_read_dword_le(demuxer->stream)-10; /* next data chunk */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
393 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
394 for (i = 0; i < MAX_STREAMS; i++) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
395 { |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
396 priv->index_table_size[i] = num_of_packets; |
18505
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
397 priv->index_table[i] = calloc(priv->index_table_size[i], sizeof(real_index_table_t)); |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
398 // priv->index_table[stream_id] = realloc(priv->index_table[stream_id], |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
399 // priv->index_table_size[stream_id] * sizeof(real_index_table_t)); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
400 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
401 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
402 tab_pos = 0; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
403 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
404 // memset(priv->index_table_size, 0, sizeof(int)*MAX_STREAMS); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
405 // memset(priv->index_table, 0, sizeof(real_index_table_t)*MAX_STREAMS); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
406 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
407 while (tab_pos < num_of_packets) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
408 { |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
409 i = stream_read_char(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
410 if (i == -256) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
411 goto end; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
412 stream_skip(demuxer->stream, 1); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
413 // stream_skip(demuxer->stream, 2); /* version */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
414 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
415 len = stream_read_word(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
416 stream_id = stream_read_word(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
417 timestamp = stream_read_dword(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
418 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
419 stream_skip(demuxer->stream, 1); /* reserved */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
420 flags = stream_read_char(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
421 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
422 i = tab_pos; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
423 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
424 // priv->index_table_size[stream_id] = i; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
425 // if (priv->index_table[stream_id] == NULL) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
426 // priv->index_table[stream_id] = malloc(priv->index_table_size[stream_id] * sizeof(real_index_table_t)); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
427 // else |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
428 // priv->index_table[stream_id] = realloc(priv->index_table[stream_id], |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
429 // priv->index_table_size[stream_id] * sizeof(real_index_table_t)); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
430 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
431 priv->index_table[stream_id][i].timestamp = timestamp; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
432 priv->index_table[stream_id][i].offset = stream_tell(demuxer->stream)-12; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
433 priv->index_table[stream_id][i].len = len; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
434 priv->index_table[stream_id][i].packetno = entries; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
435 priv->index_table[stream_id][i].flags = flags; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
436 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
437 tab_pos++; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
438 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
439 /* skip data */ |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
440 stream_skip(demuxer->stream, len-12); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
441 } |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
442 dump_index(demuxer, stream_id); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
443 if (data_pos) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
444 goto read_index; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
445 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
446 end: |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
447 if (i == -256) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
448 stream_reset(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
449 stream_seek(demuxer->stream, origpos); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
450 if (i == -256) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
451 return 0; |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
452 else |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
453 return 1; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
454 } |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
455 #endif |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
456 |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
457 |
16175 | 458 static int real_check_file(demuxer_t* demuxer) |
3795 | 459 { |
3777 | 460 real_priv_t *priv; |
461 int c; | |
462 | |
463 mp_msg(MSGT_DEMUX,MSGL_V,"Checking for REAL\n"); | |
464 | |
465 c = stream_read_dword_le(demuxer->stream); | |
466 if (c == -256) | |
467 return 0; /* EOF */ | |
468 if (c != MKTAG('.', 'R', 'M', 'F')) | |
469 return 0; /* bad magic */ | |
470 | |
471 priv = malloc(sizeof(real_priv_t)); | |
472 memset(priv, 0, sizeof(real_priv_t)); | |
473 demuxer->priv = priv; | |
474 | |
16175 | 475 return DEMUXER_TYPE_REAL; |
3777 | 476 } |
477 | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
478 void hexdump(char *, unsigned long); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
479 |
9543 | 480 #define SKIP_BITS(n) buffer<<=n |
481 #define SHOW_BITS(n) ((buffer)>>(32-(n))) | |
482 | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
483 static double real_fix_timestamp(real_priv_t* priv, unsigned char* s, unsigned int timestamp, double frametime, unsigned int format){ |
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
484 double v_pts; |
9543 | 485 uint32_t buffer= (s[0]<<24) + (s[1]<<16) + (s[2]<<8) + s[3]; |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
486 unsigned int kf=timestamp; |
9543 | 487 int pict_type; |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
488 unsigned int orig_kf; |
9555 | 489 |
490 #if 1 | |
9543 | 491 if(format==mmioFOURCC('R','V','3','0') || format==mmioFOURCC('R','V','4','0')){ |
492 if(format==mmioFOURCC('R','V','3','0')){ | |
493 SKIP_BITS(3); | |
494 pict_type= SHOW_BITS(2); | |
495 SKIP_BITS(2 + 7); | |
496 }else{ | |
497 SKIP_BITS(1); | |
498 pict_type= SHOW_BITS(2); | |
9555 | 499 SKIP_BITS(2 + 7 + 3); |
9543 | 500 } |
9555 | 501 orig_kf= |
502 kf= SHOW_BITS(13); // kf= 2*SHOW_BITS(12); | |
503 // if(pict_type==0) | |
504 if(pict_type<=1){ | |
505 // I frame, sync timestamps: | |
20229
cd827d62fb71
Fix timestamps for streams where kf_base gets negative
rtogni
parents:
20198
diff
changeset
|
506 priv->kf_base=(int64_t)timestamp-kf; |
23632 | 507 mp_msg(MSGT_DEMUX, MSGL_DBG2,"\nTS: base=%08"PRIX64"\n",priv->kf_base); |
9555 | 508 kf=timestamp; |
509 } else { | |
510 // P/B frame, merge timestamps: | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
511 int64_t tmp=(int64_t)timestamp-priv->kf_base; |
9555 | 512 kf|=tmp&(~0x1fff); // combine with packet timestamp |
513 if(kf<tmp-4096) kf+=8192; else // workaround wrap-around problems | |
514 if(kf>tmp+4096) kf-=8192; | |
515 kf+=priv->kf_base; | |
516 } | |
9543 | 517 if(pict_type != 3){ // P || I frame -> swap timestamps |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
518 unsigned int tmp=kf; |
6423 | 519 kf=priv->kf_pts; |
520 priv->kf_pts=tmp; | |
521 // if(kf<=tmp) kf=0; | |
522 } | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
523 mp_msg(MSGT_DEMUX, MSGL_DBG2,"\nTS: %08X -> %08X (%04X) %d %02X %02X %02X %02X %5u\n",timestamp,kf,orig_kf,pict_type,s[0],s[1],s[2],s[3],kf-(unsigned int)(1000.0*priv->v_pts)); |
6995
8f92313a0cd5
RV20 A-V desync fixed - use timestamp hack only for RV30
arpi
parents:
6982
diff
changeset
|
524 } |
9555 | 525 #endif |
6423 | 526 v_pts=kf*0.001f; |
9555 | 527 // if(v_pts<priv->v_pts || !kf) v_pts=priv->v_pts+frametime; |
6423 | 528 priv->v_pts=v_pts; |
529 return v_pts; | |
530 } | |
531 | |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
532 typedef struct dp_hdr_s { |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
533 uint32_t chunks; // number of chunks |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
534 uint32_t timestamp; // timestamp from packet header |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
535 uint32_t len; // length of actual data |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
536 uint32_t chunktab; // offset to chunk offset array |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
537 } dp_hdr_t; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
538 |
3777 | 539 // return value: |
540 // 0 = EOF or no stream found | |
541 // 1 = successfully read a packet | |
16175 | 542 static int demux_real_fill_buffer(demuxer_t *demuxer, demux_stream_t *dsds) |
3777 | 543 { |
544 real_priv_t *priv = demuxer->priv; | |
545 demux_stream_t *ds = NULL; | |
546 int len; | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
547 unsigned int timestamp; |
3777 | 548 int stream_id; |
8254
772d6d27fd66
warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michael
parents:
8123
diff
changeset
|
549 #ifdef CRACK_MATRIX |
3777 | 550 int i; |
8254
772d6d27fd66
warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michael
parents:
8123
diff
changeset
|
551 #endif |
3795 | 552 int flags; |
6916 | 553 int version; |
554 int reserved; | |
11886 | 555 demux_packet_t *dp; |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
556 int x, sps, cfs, sph, spc, w; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
557 int audioreorder_getnextpk = 0; |
3777 | 558 |
20499 | 559 // Don't demux video if video codec init failed |
560 if (demuxer->video->id >= 0 && !demuxer->video->sh) | |
561 demuxer->video->id = -2; | |
562 | |
19960
5928bd5c7f0b
Make fill_buffer function check for stream eof, fixes hang at eof (bug #580)
reimar
parents:
19954
diff
changeset
|
563 while(!stream_eof(demuxer->stream)){ |
7710 | 564 |
14402 | 565 /* Handle audio/video demxing switch for multirate files (non-interleaved) */ |
566 if (priv->is_multirate && priv->stream_switch) { | |
567 if (priv->a_idx_ptr >= priv->index_table_size[demuxer->audio->id]) | |
568 demuxer->audio->eof = 1; | |
569 if (priv->v_idx_ptr >= priv->index_table_size[demuxer->video->id]) | |
570 demuxer->video->eof = 1; | |
571 if (demuxer->audio->eof && demuxer->video->eof) | |
572 return 0; | |
573 else if (!demuxer->audio->eof && demuxer->video->eof) | |
574 stream_seek(demuxer->stream, priv->audio_curpos); // Get audio | |
575 else if (demuxer->audio->eof && !demuxer->video->eof) | |
576 stream_seek(demuxer->stream, priv->video_curpos); // Get video | |
577 else if (priv->index_table[demuxer->audio->id][priv->a_idx_ptr].timestamp < | |
578 priv->index_table[demuxer->video->id][priv->v_idx_ptr].timestamp) | |
579 stream_seek(demuxer->stream, priv->audio_curpos); // Get audio | |
580 else | |
581 stream_seek(demuxer->stream, priv->video_curpos); // Get video | |
582 priv->stream_switch = 0; | |
583 } | |
584 | |
6916 | 585 demuxer->filepos = stream_tell(demuxer->stream); |
586 version = stream_read_word(demuxer->stream); /* version */ | |
3777 | 587 len = stream_read_word(demuxer->stream); |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
588 if ((version==0x4441) && (len==0x5441)) { // new data chunk |
10342 | 589 mp_msg(MSGT_DEMUX,MSGL_INFO,"demux_real: New data chunk is coming!!!\n"); |
14402 | 590 if (priv->is_multirate) |
591 return 0; // EOF | |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
592 stream_skip(demuxer->stream,14); |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
593 demuxer->filepos = stream_tell(demuxer->stream); |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
594 version = stream_read_word(demuxer->stream); /* version */ |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
595 len = stream_read_word(demuxer->stream); |
12076
1309695bcdf4
Stop reading the file if an INDX chunk is found instead of a data packet.
mosu
parents:
11989
diff
changeset
|
596 } else if ((version == 0x494e) && (len == 0x4458)) { |
1309695bcdf4
Stop reading the file if an INDX chunk is found instead of a data packet.
mosu
parents:
11989
diff
changeset
|
597 mp_msg(MSGT_DEMUX,MSGL_V,"demux_real: Found INDX chunk. EOF.\n"); |
14586
77e2eaf833c5
Do not read any more data at eof: if got eof in the middle of an audio
rtognimp
parents:
14585
diff
changeset
|
598 demuxer->stream->eof=1; |
12076
1309695bcdf4
Stop reading the file if an INDX chunk is found instead of a data packet.
mosu
parents:
11989
diff
changeset
|
599 return 0; |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
600 } |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
601 |
6916 | 602 |
603 if (len == -256){ /* EOF */ | |
7710 | 604 // printf("len==-256!\n"); |
3777 | 605 return 0; |
6916 | 606 } |
7710 | 607 if (len < 12){ |
11870 | 608 mp_msg(MSGT_DEMUX, MSGL_V,"%08X: packet v%d len=%d \n",(int)demuxer->filepos,(int)version,(int)len); |
609 mp_msg(MSGT_DEMUX, MSGL_WARN,"bad packet len (%d)\n", len); | |
3777 | 610 stream_skip(demuxer->stream, len); |
7710 | 611 continue; //goto loop; |
3777 | 612 } |
7710 | 613 |
3777 | 614 stream_id = stream_read_word(demuxer->stream); |
615 timestamp = stream_read_dword(demuxer->stream); | |
6916 | 616 reserved = stream_read_char(demuxer->stream); |
3795 | 617 flags = stream_read_char(demuxer->stream); |
618 /* flags: */ | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
619 /* 0x1 - reliable */ |
3795 | 620 /* 0x2 - keyframe */ |
621 | |
14402 | 622 if (version == 1) { |
623 int tmp; | |
624 tmp = stream_read_char(demuxer->stream); | |
625 mp_msg(MSGT_DEMUX, MSGL_DBG2,"Version: %d, skipped byte is %d\n", version, tmp); | |
626 len--; | |
627 } | |
628 | |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
629 if (flags & 2) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
630 add_index_item(demuxer, stream_id, timestamp, demuxer->filepos); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
631 |
6916 | 632 // printf("%08X: packet v%d len=%4d id=%d pts=%6d rvd=%d flags=%d \n", |
633 // (int)demuxer->filepos,(int)version,(int)len, stream_id, | |
634 // (int) timestamp, reserved, flags); | |
635 | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
636 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "\npacket#%d: pos: 0x%0x, len: %d, id: %d, pts: %u, flags: %x rvd:%d\n", |
6916 | 637 priv->current_packet, (int)demuxer->filepos, len, stream_id, timestamp, flags, reserved); |
3777 | 638 |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
639 priv->current_packet++; |
3777 | 640 len -= 12; |
641 | |
6344 | 642 // printf("s_id=%d aid=%d vid=%d \n",stream_id,demuxer->audio->id,demuxer->video->id); |
643 | |
7710 | 644 /* check stream_id: */ |
645 | |
646 if(demuxer->audio->id==stream_id){ | |
11441 | 647 if (priv->audio_need_keyframe == 1&& flags != 0x2) |
648 goto discard; | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
649 got_audio: |
7710 | 650 ds=demuxer->audio; |
651 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "packet is audio (id: %d)\n", stream_id); | |
652 | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
653 if (flags & 2) { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
654 priv->sub_packet_cnt = 0; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
655 audioreorder_getnextpk = 0; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
656 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
657 |
7710 | 658 // parse audio chunk: |
3777 | 659 { |
7105 | 660 #ifdef CRACK_MATRIX |
661 int spos=stream_tell(demuxer->stream); | |
662 static int cnt=0; | |
663 static int cnt2=CRACK_MATRIX; | |
664 #endif | |
11877 | 665 if (((sh_audio_t *)ds->sh)->format == mmioFOURCC('M', 'P', '4', 'A')) { |
25599
a836d1288d59
Don't dynamically allocate sub_packet_lengths[] in raac demuxing.
rtogni
parents:
25027
diff
changeset
|
666 uint16_t sub_packet_lengths[16], sub_packets, i; |
25600 | 667 int totlen = 0; |
11877 | 668 /* AAC in Real: several AAC frames in one Real packet. */ |
669 /* Second byte, upper four bits: number of AAC frames */ | |
670 /* next n * 2 bytes: length of the AAC frames in bytes, BE */ | |
25600 | 671 if (len < 2) |
672 goto discard; | |
11877 | 673 sub_packets = (stream_read_word(demuxer->stream) & 0xf0) >> 4; |
25600 | 674 if (len < 2 * sub_packets) |
675 goto discard; | |
11877 | 676 for (i = 0; i < sub_packets; i++) |
25600 | 677 totlen += sub_packet_lengths[i] = stream_read_word(demuxer->stream); |
678 if (len < totlen ) | |
679 goto discard; | |
11877 | 680 for (i = 0; i < sub_packets; i++) { |
681 demux_packet_t *dp = new_demux_packet(sub_packet_lengths[i]); | |
682 stream_read(demuxer->stream, dp->buffer, sub_packet_lengths[i]); | |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
683 if (priv->a_pts != timestamp) |
20795
047887057875
Change some constants in pts arithmetic from float to double.
uau
parents:
20794
diff
changeset
|
684 dp->pts = timestamp / 1000.0; |
11877 | 685 priv->a_pts = timestamp; |
686 dp->pos = demuxer->filepos; | |
687 ds_add_packet(ds, dp); | |
688 } | |
689 return 1; | |
690 } | |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
691 if ((priv->intl_id[stream_id] == mmioFOURCC('I', 'n', 't', '4')) || |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
692 (priv->intl_id[stream_id] == mmioFOURCC('g', 'e', 'n', 'r')) || |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
693 (priv->intl_id[stream_id] == mmioFOURCC('s', 'i', 'p', 'r'))) { |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
694 sps = priv->sub_packet_size[stream_id]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
695 sph = priv->sub_packet_h[stream_id]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
696 cfs = priv->coded_framesize[stream_id]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
697 w = priv->audiopk_size[stream_id]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
698 spc = priv->sub_packet_cnt; |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
699 switch (priv->intl_id[stream_id]) { |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
700 case mmioFOURCC('I', 'n', 't', '4'): |
25600 | 701 if (len < cfs * sph/2) |
702 goto discard; | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
703 for (x = 0; x < sph / 2; x++) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
704 stream_read(demuxer->stream, priv->audio_buf + x * 2 * w + spc * cfs, cfs); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
705 break; |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
706 case mmioFOURCC('g', 'e', 'n', 'r'): |
25600 | 707 if (len < w) |
708 goto discard; | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
709 for (x = 0; x < w / sps; x++) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
710 stream_read(demuxer->stream, priv->audio_buf + sps * (sph * x + ((sph + 1) / 2) * (spc & 1) + |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
711 (spc >> 1)), sps); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
712 break; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
713 case mmioFOURCC('s', 'i', 'p', 'r'): |
25600 | 714 if (len < w) |
715 goto discard; | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
716 stream_read(demuxer->stream, priv->audio_buf + spc * w, w); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
717 if (spc == sph - 1) { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
718 int n; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
719 int bs = sph * w * 2 / 96; // nibbles per subpacket |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
720 // Perform reordering |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
721 for(n=0; n < 38; n++) { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
722 int j; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
723 int i = bs * sipr_swaps[n][0]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
724 int o = bs * sipr_swaps[n][1]; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
725 // swap nibbles of block 'i' with 'o' TODO: optimize |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
726 for(j = 0;j < bs; j++) { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
727 int x = (i & 1) ? (priv->audio_buf[i >> 1] >> 4) : (priv->audio_buf[i >> 1] & 0x0F); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
728 int y = (o & 1) ? (priv->audio_buf[o >> 1] >> 4) : (priv->audio_buf[o >> 1] & 0x0F); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
729 if(o & 1) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
730 priv->audio_buf[o >> 1] = (priv->audio_buf[o >> 1] & 0x0F) | (x << 4); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
731 else |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
732 priv->audio_buf[o >> 1] = (priv->audio_buf[o >> 1] & 0xF0) | x; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
733 if(i & 1) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
734 priv->audio_buf[i >> 1] = (priv->audio_buf[i >> 1] & 0x0F) | (y << 4); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
735 else |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
736 priv->audio_buf[i >> 1] = (priv->audio_buf[i >> 1] & 0xF0) | y; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
737 ++i; ++o; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
738 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
739 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
740 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
741 break; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
742 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
743 priv->audio_need_keyframe = 0; |
25919
382672c7480a
Allow demuxers to choose a default value for correct_pts
reimar
parents:
25883
diff
changeset
|
744 priv->audio_timestamp[priv->sub_packet_cnt] = (priv->a_pts==timestamp) ? (user_correct_pts > 0 ? MP_NOPTS_VALUE : 0) : (timestamp/1000.0); |
17317
69fe94dded9a
Remove assumption that all audio packets in a block have the same
rtognimp
parents:
17316
diff
changeset
|
745 priv->a_pts = timestamp; |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
746 if (priv->sub_packet_cnt == 0) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
747 priv->audio_filepos = demuxer->filepos; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
748 if (++(priv->sub_packet_cnt) < sph) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
749 audioreorder_getnextpk = 1; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
750 else { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
751 int apk_usize = ((WAVEFORMATEX*)((sh_audio_t*)ds->sh)->wf)->nBlockAlign; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
752 audioreorder_getnextpk = 0; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
753 priv->sub_packet_cnt = 0; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
754 // Release all the audio packets |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
755 for (x = 0; x < sph*w/apk_usize; x++) { |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
756 dp = new_demux_packet(apk_usize); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
757 memcpy(dp->buffer, priv->audio_buf + x * apk_usize, apk_usize); |
17317
69fe94dded9a
Remove assumption that all audio packets in a block have the same
rtognimp
parents:
17316
diff
changeset
|
758 /* Put timestamp only on packets that correspond to original audio packets in file */ |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
759 if (x * apk_usize % w == 0) |
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
760 dp->pts = priv->audio_timestamp[x * apk_usize / w]; |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
761 dp->pos = priv->audio_filepos; // all equal |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
762 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
763 ds_add_packet(ds, dp); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
764 } |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
765 } |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
766 } else { // No interleaving |
11886 | 767 dp = new_demux_packet(len); |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
768 stream_read(demuxer->stream, dp->buffer, len); |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
769 |
7105 | 770 #ifdef CRACK_MATRIX |
11870 | 771 mp_msg(MSGT_DEMUX, MSGL_V,"*** audio block len=%d\n",len); |
7105 | 772 { // HACK - used for reverse engineering the descrambling matrix |
773 FILE* f=fopen("test.rm","r+"); | |
774 fseek(f,spos,SEEK_SET); | |
775 ++cnt; | |
776 // for(i=0;i<len;i++) dp->buffer[i]=i/0x12; | |
777 // for(i=0;i<len;i++) dp->buffer[i]=i; | |
778 // for(i=0;i<len;i++) dp->buffer[i]=cnt; | |
779 // for(i=0;i<len;i++) dp->buffer[i]=cnt<<4; | |
780 for(i=0;i<len;i++) dp->buffer[i]=(i==cnt2) ? (cnt+16*(8+cnt)) : 0; | |
781 if(cnt==6){ cnt=0; ++cnt2; } | |
782 fwrite(dp->buffer, len, 1, f); | |
783 fclose(f); | |
784 if(cnt2>0x150) *((int*)NULL)=1; // sig11 :) | |
785 } | |
786 #endif | |
10118 | 787 #if 0 |
7710 | 788 if( ((sh_audio_t *)ds->sh)->format == 0x2000) { |
789 // if DNET, swap bytes, as DNET is byte-swapped AC3: | |
4235 | 790 char *ptr = dp->buffer; |
7710 | 791 int i; |
4235 | 792 for (i = 0; i < len; i += 2) |
793 { | |
794 const char tmp = ptr[0]; | |
795 ptr[0] = ptr[1]; | |
796 ptr[1] = tmp; | |
797 ptr += 2; | |
798 } | |
799 } | |
10118 | 800 #endif |
11441 | 801 if (priv->audio_need_keyframe == 1) { |
802 priv->audio_need_keyframe = 0; | |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
803 } else if(priv->a_pts != timestamp) |
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
804 dp->pts = timestamp/1000.0; |
6423 | 805 priv->a_pts=timestamp; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
806 dp->pos = demuxer->filepos; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
807 dp->flags = (flags & 0x2) ? 0x10 : 0; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
808 ds_add_packet(ds, dp); |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
809 |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
810 } // codec_id check, codec default case |
7710 | 811 } |
11441 | 812 // we will not use audio index if we use -idx and have a video |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
813 if(!demuxer->video->sh && index_mode == 2 && (unsigned)demuxer->audio->id < MAX_STREAMS) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
814 while (priv->current_apacket + 1 < priv->index_table_size[demuxer->audio->id] && |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
815 timestamp > priv->index_table[demuxer->audio->id][priv->current_apacket].timestamp) |
11441 | 816 priv->current_apacket += 1; |
7710 | 817 |
14402 | 818 if(priv->is_multirate) |
819 while (priv->a_idx_ptr + 1 < priv->index_table_size[demuxer->audio->id] && | |
820 timestamp > priv->index_table[demuxer->audio->id][priv->a_idx_ptr + 1].timestamp) { | |
821 priv->a_idx_ptr++; | |
822 priv->audio_curpos = stream_tell(demuxer->stream); | |
823 priv->stream_switch = 1; | |
824 } | |
825 | |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
826 // If we're reordering audio packets and we need more data get it |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
827 if (audioreorder_getnextpk) |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
828 continue; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
829 |
7710 | 830 return 1; |
831 } | |
832 | |
833 if(demuxer->video->id==stream_id){ | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
834 got_video: |
7710 | 835 ds=demuxer->video; |
836 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "packet is video (id: %d)\n", stream_id); | |
837 | |
838 // parse video chunk: | |
839 { | |
840 // we need a more complicated, 2nd level demuxing, as the video | |
841 // frames are stored fragmented in the video chunks :( | |
842 sh_video_t *sh_video = ds->sh; | |
843 demux_packet_t *dp; | |
19952
9f95bc4b361a
int->unsigned to avoid crash to sign extension, partially fixes bug #580
reimar
parents:
18505
diff
changeset
|
844 unsigned vpkg_header, vpkg_length, vpkg_offset; |
7710 | 845 int vpkg_seqnum=-1; |
846 int vpkg_subseq=0; | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
847 |
6916 | 848 while(len>2){ |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
849 dp_hdr_t* dp_hdr; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
850 unsigned char* dp_data; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
851 uint32_t* extra; |
6916 | 852 |
853 // printf("xxx len=%d \n",len); | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
854 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
855 // read packet header |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
856 // bit 7: 1=last block in block chain |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
857 // bit 6: 1=short header (only one block?) |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
858 vpkg_header=stream_read_char(demuxer->stream); --len; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
859 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "hdr: %02X (len=%d) ",vpkg_header,len); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
860 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
861 if (0x40==(vpkg_header&0xc0)) { |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
862 // seems to be a very short header |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
863 // 2 bytes, purpose of the second byte yet unknown |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
864 int bummer; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
865 bummer=stream_read_char(demuxer->stream); --len; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
866 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "%02X",bummer); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
867 vpkg_offset=0; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
868 vpkg_length=len; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
869 } else { |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
870 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
871 if (0==(vpkg_header&0x40)) { |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
872 // sub-seqnum (bits 0-6: number of fragment. bit 7: ???) |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
873 vpkg_subseq=stream_read_char(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
874 --len; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
875 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "subseq: %02X ",vpkg_subseq); |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
876 vpkg_subseq&=0x7f; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
877 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
878 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
879 // size of the complete packet |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
880 // bit 14 is always one (same applies to the offset) |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
881 vpkg_length=stream_read_word(demuxer->stream); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
882 len-=2; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
883 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "l: %02X %02X ",vpkg_length>>8,vpkg_length&0xff); |
6916 | 884 if (!(vpkg_length&0xC000)) { |
885 vpkg_length<<=16; | |
19954
f3f751f50ccf
Missing part of previous patch to demux_real.c (revision 19958)
reimar
parents:
19952
diff
changeset
|
886 vpkg_length|=(uint16_t)stream_read_word(demuxer->stream); |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
887 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "l+: %02X %02X ",(vpkg_length>>8)&0xff,vpkg_length&0xff); |
6344 | 888 len-=2; |
889 } else | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
890 vpkg_length&=0x3fff; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
891 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
892 // offset of the following data inside the complete packet |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
893 // Note: if (hdr&0xC0)==0x80 then offset is relative to the |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
894 // _end_ of the packet, so it's equal to fragment size!!! |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
895 vpkg_offset=stream_read_word(demuxer->stream); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
896 len-=2; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
897 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "o: %02X %02X ",vpkg_offset>>8,vpkg_offset&0xff); |
6916 | 898 if (!(vpkg_offset&0xC000)) { |
899 vpkg_offset<<=16; | |
19954
f3f751f50ccf
Missing part of previous patch to demux_real.c (revision 19958)
reimar
parents:
19952
diff
changeset
|
900 vpkg_offset|=(uint16_t)stream_read_word(demuxer->stream); |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
901 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "o+: %02X %02X ",(vpkg_offset>>8)&0xff,vpkg_offset&0xff); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
902 len-=2; |
6344 | 903 } else |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
904 vpkg_offset&=0x3fff; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
905 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
906 vpkg_seqnum=stream_read_char(demuxer->stream); --len; |
10735
8a10d5d0ce86
serious bugs - 1l absinth (changed to absinth against cola inflation)
alex
parents:
10508
diff
changeset
|
907 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "seq: %02X ",vpkg_seqnum); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
908 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
909 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "\n"); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
910 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "blklen=%d\n", len); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
911 mp_msg(MSGT_DEMUX,MSGL_DBG2, "block: hdr=0x%0x, len=%d, offset=%d, seqnum=%d\n", |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
912 vpkg_header, vpkg_length, vpkg_offset, vpkg_seqnum); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
913 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
914 if(ds->asf_packet){ |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
915 dp=ds->asf_packet; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
916 dp_hdr=(dp_hdr_t*)dp->buffer; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
917 dp_data=dp->buffer+sizeof(dp_hdr_t); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
918 extra=(uint32_t*)(dp->buffer+dp_hdr->chunktab); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
919 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "we have an incomplete packet (oldseq=%d new=%d)\n",ds->asf_seq,vpkg_seqnum); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
920 // we have an incomplete packet: |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
921 if(ds->asf_seq!=vpkg_seqnum){ |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
922 // this fragment is for new packet, close the old one |
6423 | 923 mp_msg(MSGT_DEMUX,MSGL_DBG2, "closing probably incomplete packet, len: %d \n",dp->len); |
11441 | 924 if(priv->video_after_seek){ |
925 priv->kf_base = 0; | |
926 priv->kf_pts = dp_hdr->timestamp; | |
22018
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
927 dp->pts= |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
928 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
11441 | 929 priv->video_after_seek = 0; |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
930 } else if (dp_hdr->len >= 3) |
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
931 dp->pts = |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
932 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
6423 | 933 ds_add_packet(ds,dp); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
934 ds->asf_packet=NULL; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
935 } else { |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
936 // append data to it! |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
937 ++dp_hdr->chunks; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
938 mp_msg(MSGT_DEMUX,MSGL_DBG2,"[chunks=%d subseq=%d]\n",dp_hdr->chunks,vpkg_subseq); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
939 if(dp_hdr->chunktab+8*(1+dp_hdr->chunks)>dp->len){ |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
940 // increase buffer size, this should not happen! |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
941 mp_msg(MSGT_DEMUX,MSGL_WARN, "chunktab buffer too small!!!!!\n"); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
942 dp->len=dp_hdr->chunktab+8*(4+dp_hdr->chunks); |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
943 dp->buffer=realloc(dp->buffer,dp->len+FF_INPUT_BUFFER_PADDING_SIZE); |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17174
diff
changeset
|
944 memset(dp->buffer + dp->len, 0, FF_INPUT_BUFFER_PADDING_SIZE); |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
945 // re-calc pointers: |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
946 dp_hdr=(dp_hdr_t*)dp->buffer; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
947 dp_data=dp->buffer+sizeof(dp_hdr_t); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
948 extra=(uint32_t*)(dp->buffer+dp_hdr->chunktab); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
949 } |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
950 extra[2*dp_hdr->chunks+0]=1; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
951 extra[2*dp_hdr->chunks+1]=dp_hdr->len; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
952 if(0x80==(vpkg_header&0xc0)){ |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
953 // last fragment! |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
954 if(dp_hdr->len!=vpkg_length-vpkg_offset) |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
955 mp_msg(MSGT_DEMUX,MSGL_V,"warning! assembled.len=%d frag.len=%d total.len=%d \n",dp->len,vpkg_offset,vpkg_length-vpkg_offset); |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
956 stream_read(demuxer->stream, dp_data+dp_hdr->len, vpkg_offset); |
9553
6886b16ac5d1
Redundant packet ignoring is RV30-only (at least frame-header flag 0x20 is)
arpi
parents:
9543
diff
changeset
|
957 if((dp_data[dp_hdr->len]&0x20) && (sh_video->format==0x30335652)) --dp_hdr->chunks; else |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
958 dp_hdr->len+=vpkg_offset; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
959 len-=vpkg_offset; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
960 mp_dbg(MSGT_DEMUX,MSGL_DBG2, "fragment (%d bytes) appended, %d bytes left\n",vpkg_offset,len); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
961 // we know that this is the last fragment -> we can close the packet! |
11441 | 962 if(priv->video_after_seek){ |
963 priv->kf_base = 0; | |
964 priv->kf_pts = dp_hdr->timestamp; | |
22018
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
965 dp->pts= |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
966 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
11441 | 967 priv->video_after_seek = 0; |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
968 } else if (dp_hdr->len >= 3) |
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
969 dp->pts = |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
970 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
971 ds_add_packet(ds,dp); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
972 ds->asf_packet=NULL; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
973 // continue parsing |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
974 continue; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
975 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
976 // non-last fragment: |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
977 if(dp_hdr->len!=vpkg_offset) |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
978 mp_msg(MSGT_DEMUX,MSGL_V,"warning! assembled.len=%d offset=%d frag.len=%d total.len=%d \n",dp->len,vpkg_offset,len,vpkg_length); |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
979 stream_read(demuxer->stream, dp_data+dp_hdr->len, len); |
9553
6886b16ac5d1
Redundant packet ignoring is RV30-only (at least frame-header flag 0x20 is)
arpi
parents:
9543
diff
changeset
|
980 if((dp_data[dp_hdr->len]&0x20) && (sh_video->format==0x30335652)) --dp_hdr->chunks; else |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
981 dp_hdr->len+=len; |
6916 | 982 len=0; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
983 break; // no more fragments in this chunk! |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
984 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
985 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
986 // create new packet! |
7084 | 987 dp = new_demux_packet(sizeof(dp_hdr_t)+vpkg_length+8*(1+2*(vpkg_header&0x3F))); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
988 // the timestamp seems to be in milliseconds |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
989 dp->pos = demuxer->filepos; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
990 dp->flags = (flags & 0x2) ? 0x10 : 0; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
991 ds->asf_seq = vpkg_seqnum; |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
992 dp_hdr=(dp_hdr_t*)dp->buffer; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
993 dp_hdr->chunks=0; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
994 dp_hdr->timestamp=timestamp; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
995 dp_hdr->chunktab=sizeof(dp_hdr_t)+vpkg_length; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
996 dp_data=dp->buffer+sizeof(dp_hdr_t); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
997 extra=(uint32_t*)(dp->buffer+dp_hdr->chunktab); |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
998 extra[0]=1; extra[1]=0; // offset of the first chunk |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
999 if(0x00==(vpkg_header&0xc0)){ |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1000 // first fragment: |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
1001 dp_hdr->len=len; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
1002 stream_read(demuxer->stream, dp_data, len); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1003 ds->asf_packet=dp; |
6916 | 1004 len=0; |
22018
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1005 if(priv->video_after_seek){ |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1006 priv->kf_base = 0; |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1007 priv->kf_pts = dp_hdr->timestamp; |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1008 dp->pts= |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1009 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1010 priv->video_after_seek = 0; |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1011 } |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1012 break; |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1013 } |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1014 // whole packet (not fragmented): |
11870 | 1015 if (vpkg_length > len) { |
1016 mp_msg(MSGT_DEMUX, MSGL_WARN,"\n******** WARNING: vpkg_length=%i > len=%i ********\n", vpkg_length, len); | |
1017 /* | |
1018 * To keep the video stream rolling, we need to break | |
1019 * here. We shouldn't touch len to make sure rest of the | |
1020 * broken packet is skipped. | |
1021 */ | |
1022 break; | |
1023 } | |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
1024 dp_hdr->len=vpkg_length; len-=vpkg_length; |
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
1025 stream_read(demuxer->stream, dp_data, vpkg_length); |
11441 | 1026 if(priv->video_after_seek){ |
1027 priv->kf_base = 0; | |
1028 priv->kf_pts = dp_hdr->timestamp; | |
22018
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1029 dp->pts= |
89fcce32d9d0
Call real_fix_timestamp() after seeking, to avoid video freezing
rtogni
parents:
21989
diff
changeset
|
1030 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
11441 | 1031 priv->video_after_seek = 0; |
20794
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
1032 } else if (dp_hdr->len >= 3) |
cc6e090f9a75
Changed code that used pts=0 in demux packets to indicate "not known".
uau
parents:
20499
diff
changeset
|
1033 dp->pts = |
7081
66c2e2d0504f
- changed re-muxed packet structure (see struct dp_hdr_t)
arpi
parents:
6995
diff
changeset
|
1034 real_fix_timestamp(priv,dp_data,dp_hdr->timestamp,sh_video->frametime,sh_video->format); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1035 ds_add_packet(ds,dp); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1036 |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1037 } // while(len>0) |
6916 | 1038 |
1039 if(len){ | |
11870 | 1040 mp_msg(MSGT_DEMUX, MSGL_WARN,"\n******** !!!!!!!! BUG!! len=%d !!!!!!!!!!! ********\n",len); |
6916 | 1041 if(len>0) stream_skip(demuxer->stream, len); |
1042 } | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1043 } |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1044 if ((unsigned)demuxer->video->id < MAX_STREAMS) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1045 while (priv->current_vpacket + 1 < priv->index_table_size[demuxer->video->id] && |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1046 timestamp > priv->index_table[demuxer->video->id][priv->current_vpacket + 1].timestamp) |
11441 | 1047 priv->current_vpacket += 1; |
7710 | 1048 |
14402 | 1049 if(priv->is_multirate) |
1050 while (priv->v_idx_ptr + 1 < priv->index_table_size[demuxer->video->id] && | |
1051 timestamp > priv->index_table[demuxer->video->id][priv->v_idx_ptr + 1].timestamp) { | |
1052 priv->v_idx_ptr++; | |
1053 priv->video_curpos = stream_tell(demuxer->stream); | |
1054 priv->stream_switch = 1; | |
1055 } | |
1056 | |
7710 | 1057 return 1; |
4235 | 1058 } |
3777 | 1059 |
18106
3a34a728fa1b
always cast stream IDs to unsigned before comparing to MAX_STREAMS.
reimar
parents:
17977
diff
changeset
|
1060 if((unsigned)stream_id<MAX_STREAMS){ |
8927 | 1061 |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1062 if(demuxer->audio->id==-1 && demuxer->a_streams[stream_id]){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1063 sh_audio_t *sh = demuxer->a_streams[stream_id]; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1064 demuxer->audio->id=stream_id; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1065 sh->ds=demuxer->audio; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1066 demuxer->audio->sh=sh; |
18505
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1067 priv->audio_buf = calloc(priv->sub_packet_h[demuxer->audio->id], priv->audiopk_size[demuxer->audio->id]); |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
1068 priv->audio_timestamp = calloc(priv->sub_packet_h[demuxer->audio->id], sizeof(double)); |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1069 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected RM audio ID = %d\n",stream_id); |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1070 goto got_audio; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1071 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1072 |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1073 if(demuxer->video->id==-1 && demuxer->v_streams[stream_id]){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1074 sh_video_t *sh = demuxer->v_streams[stream_id]; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1075 demuxer->video->id=stream_id; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1076 sh->ds=demuxer->video; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1077 demuxer->video->sh=sh; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1078 mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected RM video ID = %d\n",stream_id); |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1079 goto got_video; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1080 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1081 |
8927 | 1082 } |
1083 | |
7710 | 1084 mp_msg(MSGT_DEMUX,MSGL_DBG2, "unknown stream id (%d)\n", stream_id); |
11441 | 1085 discard: |
7710 | 1086 stream_skip(demuxer->stream, len); |
1087 }// goto loop; | |
19960
5928bd5c7f0b
Make fill_buffer function check for stream eof, fixes hang at eof (bug #580)
reimar
parents:
19954
diff
changeset
|
1088 return 0; |
3777 | 1089 } |
1090 | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
1091 extern void print_wave_header(WAVEFORMATEX *h, int verbose_level); |
8123
9fc45fe0d444
*HUGE* set of compiler warning fixes, unused variables removal
arpi
parents:
8113
diff
changeset
|
1092 |
16175 | 1093 static demuxer_t* demux_open_real(demuxer_t* demuxer) |
3777 | 1094 { |
1095 real_priv_t* priv = demuxer->priv; | |
1096 int num_of_headers; | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1097 int a_streams=0; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1098 int v_streams=0; |
3777 | 1099 int i; |
11797
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1100 int header_size; |
3777 | 1101 |
11797
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1102 header_size = stream_read_dword(demuxer->stream); /* header size */ |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1103 mp_msg(MSGT_DEMUX,MSGL_V, "real: Header size: %d\n", header_size); |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1104 i = stream_read_word(demuxer->stream); /* version */ |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1105 mp_msg(MSGT_DEMUX,MSGL_V, "real: Header object version: %d\n", i); |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1106 if (header_size == 0x10) |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1107 i = stream_read_word(demuxer->stream); |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1108 else /* we should test header_size here too. */ |
571295c177d2
Fix for Real files with header size == 0x10 (normally is 0x12)
rtognimp
parents:
11606
diff
changeset
|
1109 i = stream_read_dword(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1110 mp_msg(MSGT_DEMUX,MSGL_V, "real: File version: %d\n", i); |
3777 | 1111 num_of_headers = stream_read_dword(demuxer->stream); |
1112 | |
1113 /* parse chunks */ | |
10508
e2a88f1d47f6
BBC .rm fix, based on patch by Balatoni Denes <pnis@coder.hu>
arpi
parents:
10368
diff
changeset
|
1114 for (i = 1; i <= num_of_headers; i++) |
e2a88f1d47f6
BBC .rm fix, based on patch by Balatoni Denes <pnis@coder.hu>
arpi
parents:
10368
diff
changeset
|
1115 // for (i = 1; ; i++) |
3777 | 1116 { |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1117 int chunk_id, chunk_pos, chunk_size; |
3777 | 1118 |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1119 chunk_pos = stream_tell(demuxer->stream); |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1120 chunk_id = stream_read_dword_le(demuxer->stream); |
3777 | 1121 chunk_size = stream_read_dword(demuxer->stream); |
1122 | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1123 stream_skip(demuxer->stream, 2); /* version */ |
7710 | 1124 |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1125 mp_msg(MSGT_DEMUX,MSGL_V, "Chunk: %.4s (%x) (size: 0x%x, offset: 0x%x)\n", |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1126 (char *)&chunk_id, chunk_id, chunk_size, chunk_pos); |
3777 | 1127 |
7710 | 1128 if (chunk_size < 10){ |
1129 mp_msg(MSGT_DEMUX,MSGL_ERR,"demux_real: invalid chunksize! (%d)\n",chunk_size); | |
8569 | 1130 break; //return; |
7710 | 1131 } |
1132 | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1133 switch(chunk_id) |
3777 | 1134 { |
1135 case MKTAG('P', 'R', 'O', 'P'): | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1136 /* Properties header */ |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1137 |
3777 | 1138 stream_skip(demuxer->stream, 4); /* max bitrate */ |
1139 stream_skip(demuxer->stream, 4); /* avg bitrate */ | |
1140 stream_skip(demuxer->stream, 4); /* max packet size */ | |
1141 stream_skip(demuxer->stream, 4); /* avg packet size */ | |
1142 stream_skip(demuxer->stream, 4); /* nb packets */ | |
11441 | 1143 priv->duration = stream_read_dword(demuxer->stream)/1000; /* duration */ |
3777 | 1144 stream_skip(demuxer->stream, 4); /* preroll */ |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1145 priv->index_chunk_offset = stream_read_dword(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1146 mp_msg(MSGT_DEMUX,MSGL_V,"First index chunk offset: 0x%x\n", priv->index_chunk_offset); |
3795 | 1147 priv->data_chunk_offset = stream_read_dword(demuxer->stream)+10; |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1148 mp_msg(MSGT_DEMUX,MSGL_V,"First data chunk offset: 0x%x\n", priv->data_chunk_offset); |
3777 | 1149 stream_skip(demuxer->stream, 2); /* nb streams */ |
3795 | 1150 #if 0 |
3777 | 1151 stream_skip(demuxer->stream, 2); /* flags */ |
3795 | 1152 #else |
1153 { | |
1154 int flags = stream_read_word(demuxer->stream); | |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1155 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1156 if (flags) |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1157 { |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1158 mp_msg(MSGT_DEMUX,MSGL_V,"Flags (%x): ", flags); |
3795 | 1159 if (flags & 0x1) |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1160 mp_msg(MSGT_DEMUX,MSGL_V,"[save allowed] "); |
3795 | 1161 if (flags & 0x2) |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1162 mp_msg(MSGT_DEMUX,MSGL_V,"[perfect play (more buffers)] "); |
3795 | 1163 if (flags & 0x4) |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1164 mp_msg(MSGT_DEMUX,MSGL_V,"[live broadcast] "); |
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1165 mp_msg(MSGT_DEMUX,MSGL_V,"\n"); |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1166 } |
3795 | 1167 } |
1168 #endif | |
3777 | 1169 break; |
1170 case MKTAG('C', 'O', 'N', 'T'): | |
3788 | 1171 { |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1172 /* Content description header */ |
3788 | 1173 char *buf; |
1174 int len; | |
1175 | |
1176 len = stream_read_word(demuxer->stream); | |
1177 if (len > 0) | |
1178 { | |
1179 buf = malloc(len+1); | |
1180 stream_read(demuxer->stream, buf, len); | |
5810 | 1181 buf[len] = 0; |
3788 | 1182 demux_info_add(demuxer, "name", buf); |
1183 free(buf); | |
1184 } | |
1185 | |
1186 len = stream_read_word(demuxer->stream); | |
1187 if (len > 0) | |
1188 { | |
1189 buf = malloc(len+1); | |
1190 stream_read(demuxer->stream, buf, len); | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1191 buf[len] = 0; |
3788 | 1192 demux_info_add(demuxer, "author", buf); |
1193 free(buf); | |
1194 } | |
1195 | |
1196 len = stream_read_word(demuxer->stream); | |
1197 if (len > 0) | |
1198 { | |
1199 buf = malloc(len+1); | |
1200 stream_read(demuxer->stream, buf, len); | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1201 buf[len] = 0; |
3788 | 1202 demux_info_add(demuxer, "copyright", buf); |
1203 free(buf); | |
1204 } | |
1205 | |
1206 len = stream_read_word(demuxer->stream); | |
1207 if (len > 0) | |
1208 { | |
1209 buf = malloc(len+1); | |
1210 stream_read(demuxer->stream, buf, len); | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1211 buf[len] = 0; |
3788 | 1212 demux_info_add(demuxer, "comment", buf); |
1213 free(buf); | |
1214 } | |
3777 | 1215 break; |
3788 | 1216 } |
3777 | 1217 case MKTAG('M', 'D', 'P', 'R'): |
1218 { | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1219 /* Media properties header */ |
3777 | 1220 int stream_id; |
1221 int bitrate; | |
1222 int codec_data_size; | |
1223 int codec_pos; | |
3795 | 1224 int tmp; |
14402 | 1225 int len; |
17788
2fe769b4b30b
Fix potential read from an unitialized pointer (CID: 236)
rtognimp
parents:
17776
diff
changeset
|
1226 char *descr, *mimet = NULL; |
3777 | 1227 |
1228 stream_id = stream_read_word(demuxer->stream); | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1229 mp_msg(MSGT_DEMUX,MSGL_V,"Found new stream (id: %d)\n", stream_id); |
3777 | 1230 |
1231 stream_skip(demuxer->stream, 4); /* max bitrate */ | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1232 bitrate = stream_read_dword(demuxer->stream); /* avg bitrate */ |
3777 | 1233 stream_skip(demuxer->stream, 4); /* max packet size */ |
1234 stream_skip(demuxer->stream, 4); /* avg packet size */ | |
1235 stream_skip(demuxer->stream, 4); /* start time */ | |
1236 stream_skip(demuxer->stream, 4); /* preroll */ | |
1237 stream_skip(demuxer->stream, 4); /* duration */ | |
1238 | |
14402 | 1239 if ((len = stream_read_char(demuxer->stream)) > 0) { |
1240 descr = malloc(len+1); | |
1241 stream_read(demuxer->stream, descr, len); | |
1242 descr[len] = 0; | |
18176
f72bc5754209
Part3 of Otvos Attila's oattila AT chello-hu mp_msg changes, with lots of modifications as usual
reynaldo
parents:
18106
diff
changeset
|
1243 mp_msg(MSGT_DEMUX, MSGL_INFO,"Stream description: %s\n", descr); |
14402 | 1244 free(descr); |
1245 } | |
1246 if ((len = stream_read_char(demuxer->stream)) > 0) { | |
1247 mimet = malloc(len+1); | |
1248 stream_read(demuxer->stream, mimet, len); | |
1249 mimet[len] = 0; | |
18176
f72bc5754209
Part3 of Otvos Attila's oattila AT chello-hu mp_msg changes, with lots of modifications as usual
reynaldo
parents:
18106
diff
changeset
|
1250 mp_msg(MSGT_DEMUX, MSGL_INFO,"Stream mimetype: %s\n", mimet); |
14402 | 1251 } |
3777 | 1252 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1253 /* Type specific header */ |
3777 | 1254 codec_data_size = stream_read_dword(demuxer->stream); |
1255 codec_pos = stream_tell(demuxer->stream); | |
1256 | |
7710 | 1257 #ifdef MP_DEBUG |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1258 #define stream_skip(st,siz) { int i; for(i=0;i<siz;i++) mp_msg(MSGT_DEMUX,MSGL_V," %02X",stream_read_char(st)); mp_msg(MSGT_DEMUX,MSGL_V,"\n");} |
7710 | 1259 #endif |
1260 | |
14402 | 1261 if (!strncmp(mimet,"audio/",6)) { |
1262 if (strstr(mimet,"x-pn-realaudio") || strstr(mimet,"x-pn-multirate-realaudio")) { | |
1263 tmp = stream_read_dword(demuxer->stream); | |
1264 if (tmp != MKTAG(0xfd, 'a', 'r', '.')) | |
3777 | 1265 { |
14402 | 1266 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: can't find .ra in codec data\n"); |
1267 } else { | |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1268 /* audio header */ |
3777 | 1269 sh_audio_t *sh = new_sh_audio(demuxer, stream_id); |
3795 | 1270 char buf[128]; /* for codec name */ |
1271 int frame_size; | |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1272 int sub_packet_size; |
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1273 int sub_packet_h; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1274 int version; |
6369 | 1275 int flavor; |
8094 | 1276 int coded_frame_size; |
1277 int codecdata_length; | |
11989
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1278 int i; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1279 char *buft; |
12327
fac1637c2c37
Fix for 28_8 in rm files and header length != 0x4e
rtognimp
parents:
12076
diff
changeset
|
1280 int hdr_size; |
23089 | 1281 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "real", stream_id); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1282 mp_msg(MSGT_DEMUX,MSGL_V,"Found audio stream!\n"); |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1283 version = stream_read_word(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1284 mp_msg(MSGT_DEMUX,MSGL_V,"version: %d\n", version); |
11989
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1285 if (version == 3) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1286 stream_skip(demuxer->stream, 2); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1287 stream_skip(demuxer->stream, 10); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1288 stream_skip(demuxer->stream, 4); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1289 // Name, author, (c) are also in CONT tag |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1290 if ((i = stream_read_char(demuxer->stream)) != 0) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1291 buft = malloc(i+1); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1292 stream_read(demuxer->stream, buft, i); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1293 buft[i] = 0; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1294 demux_info_add(demuxer, "Name", buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1295 free(buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1296 } |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1297 if ((i = stream_read_char(demuxer->stream)) != 0) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1298 buft = malloc(i+1); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1299 stream_read(demuxer->stream, buft, i); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1300 buft[i] = 0; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1301 demux_info_add(demuxer, "Author", buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1302 free(buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1303 } |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1304 if ((i = stream_read_char(demuxer->stream)) != 0) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1305 buft = malloc(i+1); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1306 stream_read(demuxer->stream, buft, i); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1307 buft[i] = 0; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1308 demux_info_add(demuxer, "Copyright", buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1309 free(buft); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1310 } |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1311 if ((i = stream_read_char(demuxer->stream)) != 0) |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1312 mp_msg(MSGT_DEMUX,MSGL_WARN,"Last header byte is not zero!\n"); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1313 stream_skip(demuxer->stream, 1); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1314 i = stream_read_char(demuxer->stream); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1315 sh->format = stream_read_dword_le(demuxer->stream); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1316 if (i != 4) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1317 mp_msg(MSGT_DEMUX,MSGL_WARN,"Audio FourCC size is not 4 (%d), please report to " |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1318 "MPlayer developers\n", i); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1319 stream_skip(demuxer->stream, i - 4); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1320 } |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1321 if (sh->format != mmioFOURCC('l','p','c','J')) { |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1322 mp_msg(MSGT_DEMUX,MSGL_WARN,"Version 3 audio with FourCC %8x, please report to " |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1323 "MPlayer developers\n", sh->format); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1324 } |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1325 sh->channels = 1; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1326 sh->samplesize = 16; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1327 sh->samplerate = 8000; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1328 frame_size = 240; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1329 strcpy(buf, "14_4"); |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1330 } else { |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1331 stream_skip(demuxer->stream, 2); // 00 00 |
3788 | 1332 stream_skip(demuxer->stream, 4); /* .ra4 or .ra5 */ |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1333 stream_skip(demuxer->stream, 4); // ??? |
3788 | 1334 stream_skip(demuxer->stream, 2); /* version (4 or 5) */ |
12327
fac1637c2c37
Fix for 28_8 in rm files and header length != 0x4e
rtognimp
parents:
12076
diff
changeset
|
1335 hdr_size = stream_read_dword(demuxer->stream); // header size |
fac1637c2c37
Fix for 28_8 in rm files and header length != 0x4e
rtognimp
parents:
12076
diff
changeset
|
1336 mp_msg(MSGT_DEMUX,MSGL_V,"header size: %d\n", hdr_size); |
6369 | 1337 flavor = stream_read_word(demuxer->stream);/* codec flavor id */ |
8094 | 1338 coded_frame_size = stream_read_dword(demuxer->stream);/* needed by codec */ |
17401
d624a0a191f3
Print some more useful data from header in verbose mode
rtognimp
parents:
17394
diff
changeset
|
1339 mp_msg(MSGT_DEMUX,MSGL_V,"coded_frame_size: %d\n", coded_frame_size); |
6369 | 1340 stream_skip(demuxer->stream, 4); // big number |
1341 stream_skip(demuxer->stream, 4); // bigger number | |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1342 stream_skip(demuxer->stream, 4); // 2 || -''- |
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1343 sub_packet_h = stream_read_word(demuxer->stream); |
17401
d624a0a191f3
Print some more useful data from header in verbose mode
rtognimp
parents:
17394
diff
changeset
|
1344 mp_msg(MSGT_DEMUX,MSGL_V,"sub_packet_h: %d\n", sub_packet_h); |
3795 | 1345 frame_size = stream_read_word(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1346 mp_msg(MSGT_DEMUX,MSGL_V,"frame_size: %d\n", frame_size); |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1347 sub_packet_size = stream_read_word(demuxer->stream); |
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1348 mp_msg(MSGT_DEMUX,MSGL_V,"sub_packet_size: %d\n", sub_packet_size); |
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1349 stream_skip(demuxer->stream, 2); // 0 |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1350 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1351 if (version == 5) |
6369 | 1352 stream_skip(demuxer->stream, 6); //0,srate,0 |
3777 | 1353 |
1354 sh->samplerate = stream_read_word(demuxer->stream); | |
6369 | 1355 stream_skip(demuxer->stream, 2); // 0 |
1356 sh->samplesize = stream_read_word(demuxer->stream)/8; | |
3777 | 1357 sh->channels = stream_read_word(demuxer->stream); |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1358 mp_msg(MSGT_DEMUX,MSGL_V,"samplerate: %d, channels: %d\n", |
3877 | 1359 sh->samplerate, sh->channels); |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1360 |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1361 if (version == 5) |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1362 { |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1363 stream_read(demuxer->stream, buf, 4); // interleaver id |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1364 priv->intl_id[stream_id] = MKTAG(buf[0], buf[1], buf[2], buf[3]); |
6369 | 1365 stream_read(demuxer->stream, buf, 4); // fourcc |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1366 buf[4] = 0; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1367 } |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1368 else |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1369 { |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1370 /* Interleaver id */ |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1371 get_str(1, demuxer, buf, sizeof(buf)); |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1372 priv->intl_id[stream_id] = MKTAG(buf[0], buf[1], buf[2], buf[3]); |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1373 /* Codec FourCC */ |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1374 get_str(1, demuxer, buf, sizeof(buf)); |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1375 } |
11989
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1376 } |
3777 | 1377 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1378 /* Emulate WAVEFORMATEX struct: */ |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1379 sh->wf = malloc(sizeof(WAVEFORMATEX)); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1380 memset(sh->wf, 0, sizeof(WAVEFORMATEX)); |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1381 sh->wf->nChannels = sh->channels; |
6369 | 1382 sh->wf->wBitsPerSample = sh->samplesize*8; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1383 sh->wf->nSamplesPerSec = sh->samplerate; |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1384 sh->wf->nAvgBytesPerSec = bitrate/8; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1385 sh->wf->nBlockAlign = frame_size; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1386 sh->wf->cbSize = 0; |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1387 sh->format = MKTAG(buf[0], buf[1], buf[2], buf[3]); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1388 |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1389 switch (sh->format) |
3795 | 1390 { |
1391 case MKTAG('d', 'n', 'e', 't'): | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1392 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: DNET -> AC3\n"); |
10118 | 1393 // sh->format = 0x2000; |
3795 | 1394 break; |
10032 | 1395 case MKTAG('1', '4', '_', '4'): |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1396 sh->wf->nBlockAlign = 0x14; |
11989
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1397 break; |
644d59147048
Support for v3 audio section (used with 14_4 codec) in real files
rtognimp
parents:
11886
diff
changeset
|
1398 |
10032 | 1399 case MKTAG('2', '8', '_', '8'): |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1400 sh->wf->nBlockAlign = coded_frame_size; |
12327
fac1637c2c37
Fix for 28_8 in rm files and header length != 0x4e
rtognimp
parents:
12076
diff
changeset
|
1401 break; |
fac1637c2c37
Fix for 28_8 in rm files and header length != 0x4e
rtognimp
parents:
12076
diff
changeset
|
1402 |
3795 | 1403 case MKTAG('s', 'i', 'p', 'r'): |
8094 | 1404 case MKTAG('a', 't', 'r', 'c'): |
3795 | 1405 case MKTAG('c', 'o', 'o', 'k'): |
8094 | 1406 // realaudio codec plugins - common: |
1407 stream_skip(demuxer->stream,3); // Skip 3 unknown bytes | |
1408 if (version==5) | |
1409 stream_skip(demuxer->stream,1); // Skip 1 additional unknown byte | |
1410 codecdata_length=stream_read_dword(demuxer->stream); | |
18505
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1411 // Check extradata len, we can't store bigger values in cbSize anyway |
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1412 if ((unsigned)codecdata_length > 0xffff) { |
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1413 mp_msg(MSGT_DEMUX,MSGL_ERR,"Extradata too big (%d)\n", codecdata_length); |
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1414 goto skip_this_chunk; |
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1415 } |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1416 sh->wf->cbSize = codecdata_length; |
6374
b2d5aeb72f95
export subpacket-size and matrix w*h to the codec (cook)
arpi
parents:
6369
diff
changeset
|
1417 sh->wf = realloc(sh->wf, sizeof(WAVEFORMATEX)+sh->wf->cbSize); |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1418 stream_read(demuxer->stream, ((char*)(sh->wf+1)), codecdata_length); // extras |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1419 if (priv->intl_id[stream_id] == MKTAG('g', 'e', 'n', 'r')) |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1420 sh->wf->nBlockAlign = sub_packet_size; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1421 else |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1422 sh->wf->nBlockAlign = coded_frame_size; |
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1423 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1424 break; |
17149
9a0a376a54b1
Move audio packets reordering from codec interface to demuxers for real
rtognimp
parents:
16877
diff
changeset
|
1425 |
11877 | 1426 case MKTAG('r', 'a', 'a', 'c'): |
1427 case MKTAG('r', 'a', 'c', 'p'): | |
1428 /* This is just AAC. The two or five bytes of */ | |
1429 /* config data needed for libfaad are stored */ | |
1430 /* after the audio headers. */ | |
1431 stream_skip(demuxer->stream,3); // Skip 3 unknown bytes | |
1432 if (version==5) | |
1433 stream_skip(demuxer->stream,1); // Skip 1 additional unknown byte | |
1434 codecdata_length=stream_read_dword(demuxer->stream); | |
1435 if (codecdata_length>=1) { | |
1436 sh->codecdata_len = codecdata_length - 1; | |
1437 sh->codecdata = calloc(sh->codecdata_len, 1); | |
1438 stream_skip(demuxer->stream, 1); | |
1439 stream_read(demuxer->stream, sh->codecdata, sh->codecdata_len); | |
1440 } | |
1441 sh->format = mmioFOURCC('M', 'P', '4', 'A'); | |
1442 break; | |
3795 | 1443 default: |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1444 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: Unknown (%s)\n", buf); |
3777 | 1445 } |
1446 | |
21989
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1447 // Interleaver setup |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1448 priv->sub_packet_size[stream_id] = sub_packet_size; |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1449 priv->sub_packet_h[stream_id] = sub_packet_h; |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1450 priv->coded_framesize[stream_id] = coded_frame_size; |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1451 priv->audiopk_size[stream_id] = frame_size; |
c3dc45e16aa3
Use interleaver id to select the correct interleaver instead of guessing
rtogni
parents:
21421
diff
changeset
|
1452 |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1453 sh->wf->wFormatTag = sh->format; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1454 |
17388
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1455 mp_msg(MSGT_DEMUX,MSGL_V,"audio fourcc: %.4s (%x)\n", (char *)&sh->format, sh->format); |
17932 | 1456 if ( mp_msg_test(MSGT_DEMUX,MSGL_V) ) |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
1457 print_wave_header(sh->wf, MSGL_V); |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1458 |
14402 | 1459 /* Select audio stream with highest bitrate if multirate file*/ |
1460 if (priv->is_multirate && ((demuxer->audio->id == -1) || | |
1461 ((demuxer->audio->id >= 0) && priv->a_bitrate && (bitrate > priv->a_bitrate)))) { | |
1462 demuxer->audio->id = stream_id; | |
1463 priv->a_bitrate = bitrate; | |
1464 mp_msg(MSGT_DEMUX,MSGL_DBG2,"Multirate autoselected audio id %d with bitrate %d\n", stream_id, bitrate); | |
1465 } | |
1466 | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1467 if(demuxer->audio->id==stream_id){ |
7710 | 1468 sh->ds=demuxer->audio; |
1469 demuxer->audio->sh=sh; | |
18505
01b9f29c2fb5
Fix some potential integer overflow in memory allocation (mot of these
rtognimp
parents:
18444
diff
changeset
|
1470 priv->audio_buf = calloc(priv->sub_packet_h[demuxer->audio->id], priv->audiopk_size[demuxer->audio->id]); |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
1471 priv->audio_timestamp = calloc(priv->sub_packet_h[demuxer->audio->id], sizeof(double)); |
3777 | 1472 } |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1473 |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1474 ++a_streams; |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1475 |
7710 | 1476 #ifdef stream_skip |
6369 | 1477 #undef stream_skip |
7710 | 1478 #endif |
3777 | 1479 } |
14498 | 1480 } else if (strstr(mimet,"X-MP3-draft-00")) { |
14402 | 1481 sh_audio_t *sh = new_sh_audio(demuxer, stream_id); |
23010
74efb0fa8a0b
with -identify show audio and video id; patch by Andrew Savchenko (Bircoph list ru)
nicodvb
parents:
22605
diff
changeset
|
1482 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "real", stream_id); |
14402 | 1483 |
1484 /* Emulate WAVEFORMATEX struct: */ | |
1485 sh->wf = malloc(sizeof(WAVEFORMATEX)); | |
1486 memset(sh->wf, 0, sizeof(WAVEFORMATEX)); | |
1487 sh->wf->nChannels = 0;//sh->channels; | |
1488 sh->wf->wBitsPerSample = 16; | |
1489 sh->wf->nSamplesPerSec = 0;//sh->samplerate; | |
1490 sh->wf->nAvgBytesPerSec = 0;//bitrate; | |
1491 sh->wf->nBlockAlign = 0;//frame_size; | |
1492 sh->wf->cbSize = 0; | |
14498 | 1493 sh->wf->wFormatTag = sh->format = mmioFOURCC('a','d','u',0x55); |
14402 | 1494 |
1495 if(demuxer->audio->id==stream_id){ | |
1496 sh->ds=demuxer->audio; | |
1497 demuxer->audio->sh=sh; | |
1498 } | |
1499 | |
1500 ++a_streams; | |
1501 } else if (strstr(mimet,"x-ralf-mpeg4")) { | |
1502 mp_msg(MSGT_DEMUX,MSGL_ERR,"Real lossless audio not supported yet\n"); | |
25027 | 1503 } else if (strstr(mimet,"x-pn-encrypted-ra")) { |
1504 mp_msg(MSGT_DEMUX,MSGL_ERR,"Encrypted audio is not supported\n"); | |
14402 | 1505 } else { |
1506 mp_msg(MSGT_DEMUX,MSGL_V,"Unknown audio stream format\n"); | |
1507 } | |
1508 } else if (!strncmp(mimet,"video/",6)) { | |
1509 if (strstr(mimet,"x-pn-realvideo") || strstr(mimet,"x-pn-multirate-realvideo")) { | |
20159
5bb2619601f2
Remove old hack to search for .ar and VIDO, we know where they are
rtogni
parents:
20144
diff
changeset
|
1510 stream_skip(demuxer->stream, 4); // VIDO length, same as codec_data_size |
14402 | 1511 tmp = stream_read_dword(demuxer->stream); |
1512 if(tmp != MKTAG('O', 'D', 'I', 'V')) | |
3777 | 1513 { |
14402 | 1514 mp_msg(MSGT_DEMUX,MSGL_V,"Video: can't find VIDO in codec data\n"); |
1515 } else { | |
3777 | 1516 /* video header */ |
1517 sh_video_t *sh = new_sh_video(demuxer, stream_id); | |
23010
74efb0fa8a0b
with -identify show audio and video id; patch by Andrew Savchenko (Bircoph list ru)
nicodvb
parents:
22605
diff
changeset
|
1518 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_VideoID, "real", stream_id); |
3777 | 1519 |
1520 sh->format = stream_read_dword_le(demuxer->stream); /* fourcc */ | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1521 mp_msg(MSGT_DEMUX,MSGL_V,"video fourcc: %.4s (%x)\n", (char *)&sh->format, sh->format); |
3777 | 1522 |
3795 | 1523 /* emulate BITMAPINFOHEADER */ |
20920 | 1524 sh->bih = malloc(sizeof(BITMAPINFOHEADER)); |
1525 memset(sh->bih, 0, sizeof(BITMAPINFOHEADER)); | |
1526 sh->bih->biSize = sizeof(BITMAPINFOHEADER); | |
3777 | 1527 sh->disp_w = sh->bih->biWidth = stream_read_word(demuxer->stream); |
1528 sh->disp_h = sh->bih->biHeight = stream_read_word(demuxer->stream); | |
1529 sh->bih->biPlanes = 1; | |
1530 sh->bih->biBitCount = 24; | |
1531 sh->bih->biCompression = sh->format; | |
1532 sh->bih->biSizeImage= sh->bih->biWidth*sh->bih->biHeight*3; | |
1533 | |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1534 sh->fps = (float) stream_read_word(demuxer->stream); |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1535 if (sh->fps<=0) sh->fps=24; // we probably won't even care about fps |
3777 | 1536 sh->frametime = 1.0f/sh->fps; |
1537 | |
6344 | 1538 #if 1 |
6414
67c1050a8718
fix fps/frametime parsing - patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
6404
diff
changeset
|
1539 stream_skip(demuxer->stream, 4); |
6344 | 1540 #else |
11870 | 1541 mp_msg(MSGT_DEMUX, MSGL_V,"unknown1: 0x%X \n",stream_read_dword(demuxer->stream)); |
1542 mp_msg(MSGT_DEMUX, MSGL_V,"unknown2: 0x%X \n",stream_read_word(demuxer->stream)); | |
1543 mp_msg(MSGT_DEMUX, MSGL_V,"unknown3: 0x%X \n",stream_read_word(demuxer->stream)); | |
6344 | 1544 #endif |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1545 // if(sh->format==0x30335652 || sh->format==0x30325652 ) |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1546 if(1) |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1547 { |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1548 int tmp=stream_read_word(demuxer->stream); |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1549 if(tmp>0){ |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1550 sh->fps=tmp; sh->frametime = 1.0f/sh->fps; |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1551 } |
6414
67c1050a8718
fix fps/frametime parsing - patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
6404
diff
changeset
|
1552 } else { |
7710 | 1553 int fps=stream_read_word(demuxer->stream); |
11870 | 1554 mp_msg(MSGT_DEMUX, MSGL_WARN,"realvid: ignoring FPS = %d\n",fps); |
6414
67c1050a8718
fix fps/frametime parsing - patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
6404
diff
changeset
|
1555 } |
67c1050a8718
fix fps/frametime parsing - patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
6404
diff
changeset
|
1556 stream_skip(demuxer->stream, 2); |
6344 | 1557 |
3777 | 1558 { |
20920 | 1559 // read and store codec extradata |
14568 | 1560 unsigned int cnt = codec_data_size - (stream_tell(demuxer->stream) - codec_pos); |
20920 | 1561 if (cnt > 0x7fffffff - sizeof(BITMAPINFOHEADER)) { |
1562 mp_msg(MSGT_DEMUX, MSGL_ERR,"Extradata too big (%u)\n", cnt); | |
14568 | 1563 } else { |
20920 | 1564 sh->bih = realloc(sh->bih, sizeof(BITMAPINFOHEADER) + cnt); |
20143 | 1565 sh->bih->biSize += cnt; |
20920 | 1566 stream_read(demuxer->stream, ((unsigned char*)(sh->bih+1)), cnt); |
14568 | 1567 } |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1568 } |
20920 | 1569 if(sh->format == 0x30315652 && ((unsigned char*)(sh->bih+1))[6] == 0x30) |
1570 sh->bih->biCompression = sh->format = mmioFOURCC('R', 'V', '1', '3'); | |
7710 | 1571 |
14402 | 1572 /* Select video stream with highest bitrate if multirate file*/ |
1573 if (priv->is_multirate && ((demuxer->video->id == -1) || | |
1574 ((demuxer->video->id >= 0) && priv->v_bitrate && (bitrate > priv->v_bitrate)))) { | |
1575 demuxer->video->id = stream_id; | |
1576 priv->v_bitrate = bitrate; | |
1577 mp_msg(MSGT_DEMUX,MSGL_DBG2,"Multirate autoselected video id %d with bitrate %d\n", stream_id, bitrate); | |
1578 } | |
1579 | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1580 if(demuxer->video->id==stream_id){ |
7710 | 1581 sh->ds=demuxer->video; |
1582 demuxer->video->sh=sh; | |
3777 | 1583 } |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1584 |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1585 ++v_streams; |
7710 | 1586 |
3777 | 1587 } |
14402 | 1588 } else { |
1589 mp_msg(MSGT_DEMUX,MSGL_V,"Unknown video stream format\n"); | |
1590 } | |
1591 } else if (strstr(mimet,"logical-")) { | |
1592 if (strstr(mimet,"fileinfo")) { | |
1593 mp_msg(MSGT_DEMUX,MSGL_V,"Got a logical-fileinfo chunk\n"); | |
1594 } else if (strstr(mimet,"-audio") || strstr(mimet,"-video")) { | |
1595 int i, stream_cnt; | |
1596 int stream_list[MAX_STREAMS]; | |
1597 | |
1598 priv->is_multirate = 1; | |
1599 stream_skip(demuxer->stream, 4); // Length of codec data (repeated) | |
1600 stream_cnt = stream_read_dword(demuxer->stream); // Get number of audio or video streams | |
18106
3a34a728fa1b
always cast stream IDs to unsigned before comparing to MAX_STREAMS.
reimar
parents:
17977
diff
changeset
|
1601 if ((unsigned)stream_cnt >= MAX_STREAMS) { |
14402 | 1602 mp_msg(MSGT_DEMUX,MSGL_ERR,"Too many streams in %s. Big troubles ahead.\n", mimet); |
1603 goto skip_this_chunk; | |
1604 } | |
1605 for (i = 0; i < stream_cnt; i++) | |
1606 stream_list[i] = stream_read_word(demuxer->stream); | |
1607 for (i = 0; i < stream_cnt; i++) | |
18106
3a34a728fa1b
always cast stream IDs to unsigned before comparing to MAX_STREAMS.
reimar
parents:
17977
diff
changeset
|
1608 if ((unsigned)stream_list[i] >= MAX_STREAMS) { |
14402 | 1609 mp_msg(MSGT_DEMUX,MSGL_ERR,"Stream id out of range: %d. Ignored.\n", stream_list[i]); |
1610 stream_skip(demuxer->stream, 4); // Skip DATA offset for broken stream | |
1611 } else { | |
1612 priv->str_data_offset[stream_list[i]] = stream_read_dword(demuxer->stream); | |
1613 mp_msg(MSGT_DEMUX,MSGL_V,"Stream %d with DATA offset 0x%08x\n", stream_list[i], priv->str_data_offset[stream_list[i]]); | |
1614 } | |
1615 // Skip the rest of this chunk | |
1616 } else | |
1617 mp_msg(MSGT_DEMUX,MSGL_V,"Unknown logical stream\n"); | |
1618 } | |
7085
02aa64b49b70
some files has some shit before teh audio/video headers...
arpi
parents:
7084
diff
changeset
|
1619 else { |
02aa64b49b70
some files has some shit before teh audio/video headers...
arpi
parents:
7084
diff
changeset
|
1620 mp_msg(MSGT_DEMUX, MSGL_ERR, "Not audio/video stream or unsupported!\n"); |
02aa64b49b70
some files has some shit before teh audio/video headers...
arpi
parents:
7084
diff
changeset
|
1621 } |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1622 // break; |
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1623 // default: |
14402 | 1624 skip_this_chunk: |
3777 | 1625 /* skip codec info */ |
3795 | 1626 tmp = stream_tell(demuxer->stream) - codec_pos; |
6344 | 1627 mp_msg(MSGT_DEMUX,MSGL_V,"### skipping %d bytes of codec info\n", codec_data_size - tmp); |
1628 #if 0 | |
1629 { int i; | |
1630 for(i=0;i<codec_data_size - tmp;i++) | |
11870 | 1631 mp_msg(MSGT_DEMUX, MSGL_V," %02X",stream_read_char(demuxer->stream)); |
1632 mp_msg(MSGT_DEMUX, MSGL_V,"\n"); | |
6344 | 1633 } |
1634 #else | |
3795 | 1635 stream_skip(demuxer->stream, codec_data_size - tmp); |
6344 | 1636 #endif |
14402 | 1637 if (mimet) |
1638 free (mimet); | |
3777 | 1639 break; |
3985
701d18898835
updated/extended some parts, based on RMFF (also initial ATRAC3 hackings and notes)
alex
parents:
3882
diff
changeset
|
1640 // } |
3777 | 1641 } |
1642 case MKTAG('D', 'A', 'T', 'A'): | |
1643 goto header_end; | |
3795 | 1644 case MKTAG('I', 'N', 'D', 'X'): |
3777 | 1645 default: |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1646 mp_msg(MSGT_DEMUX,MSGL_V,"Unknown chunk: %x\n", chunk_id); |
3777 | 1647 stream_skip(demuxer->stream, chunk_size - 10); |
1648 break; | |
1649 } | |
1650 } | |
1651 | |
1652 header_end: | |
14402 | 1653 if(priv->is_multirate) { |
1654 mp_msg(MSGT_DEMUX,MSGL_V,"Selected video id %d audio id %d\n", demuxer->video->id, demuxer->audio->id); | |
1655 /* Perform some sanity checks to avoid checking streams id all over the code*/ | |
1656 if (demuxer->audio->id >= MAX_STREAMS) { | |
1657 mp_msg(MSGT_DEMUX,MSGL_ERR,"Invalid audio stream %d. No sound will be played.\n", demuxer->audio->id); | |
1658 demuxer->audio->id = -2; | |
1659 } else if ((demuxer->audio->id >= 0) && (priv->str_data_offset[demuxer->audio->id] == 0)) { | |
1660 mp_msg(MSGT_DEMUX,MSGL_ERR,"Audio stream %d not found. No sound will be played.\n", demuxer->audio->id); | |
1661 demuxer->audio->id = -2; | |
1662 } | |
1663 if (demuxer->video->id >= MAX_STREAMS) { | |
1664 mp_msg(MSGT_DEMUX,MSGL_ERR,"Invalid video stream %d. No video will be played.\n", demuxer->video->id); | |
1665 demuxer->video->id = -2; | |
1666 } else if ((demuxer->video->id >= 0) && (priv->str_data_offset[demuxer->video->id] == 0)) { | |
1667 mp_msg(MSGT_DEMUX,MSGL_ERR,"Video stream %d not found. No video will be played.\n", demuxer->video->id); | |
1668 demuxer->video->id = -2; | |
1669 } | |
1670 } | |
1671 | |
1672 if(priv->is_multirate && ((demuxer->video->id >= 0) || (demuxer->audio->id >=0))) { | |
1673 /* If audio or video only, seek to right place and behave like standard file */ | |
1674 if (demuxer->video->id < 0) { | |
1675 // Stream is audio only, or -novideo | |
1676 stream_seek(demuxer->stream, priv->data_chunk_offset = priv->str_data_offset[demuxer->audio->id]+10); | |
1677 priv->is_multirate = 0; | |
1678 } | |
1679 if (demuxer->audio->id < 0) { | |
1680 // Stream is video only, or -nosound | |
1681 stream_seek(demuxer->stream, priv->data_chunk_offset = priv->str_data_offset[demuxer->video->id]+10); | |
1682 priv->is_multirate = 0; | |
1683 } | |
1684 } | |
1685 | |
1686 if(!priv->is_multirate) { | |
10508
e2a88f1d47f6
BBC .rm fix, based on patch by Balatoni Denes <pnis@coder.hu>
arpi
parents:
10368
diff
changeset
|
1687 // printf("i=%d num_of_headers=%d \n",i,num_of_headers); |
3777 | 1688 priv->num_of_packets = stream_read_dword(demuxer->stream); |
1689 stream_skip(demuxer->stream, 4); /* next data header */ | |
1690 | |
6340
7f612cf06ba5
sub-packet demuxer for rv20/rv30, patch by Florian Schneider <flo-mplayer-dev@gmx.net>
arpi
parents:
5918
diff
changeset
|
1691 mp_msg(MSGT_DEMUX,MSGL_V,"Packets in file: %d\n", priv->num_of_packets); |
3777 | 1692 |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1693 if (priv->num_of_packets == 0) |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1694 priv->num_of_packets = -10; |
14402 | 1695 } else { |
1696 priv->audio_curpos = priv->str_data_offset[demuxer->audio->id] + 18; | |
1697 stream_seek(demuxer->stream, priv->str_data_offset[demuxer->audio->id]+10); | |
1698 priv->a_num_of_packets=priv->a_num_of_packets = stream_read_dword(demuxer->stream); | |
1699 priv->video_curpos = priv->str_data_offset[demuxer->video->id] + 18; | |
1700 stream_seek(demuxer->stream, priv->str_data_offset[demuxer->video->id]+10); | |
1701 priv->v_num_of_packets = stream_read_dword(demuxer->stream); | |
1702 priv->stream_switch = 1; | |
1703 /* Index required for multirate playback, force building if it's not there */ | |
1704 /* but respect user request to force index regeneration */ | |
1705 if (index_mode == -1) | |
1706 index_mode = 1; | |
1707 } | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1708 |
3777 | 1709 |
11441 | 1710 priv->audio_need_keyframe = 0; |
1711 priv->video_after_seek = 0; | |
1712 | |
12665
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1713 switch (index_mode){ |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1714 case -1: // untouched |
17394
d44f30816921
Always try to parse index chunk, no reason to check for movi_end
reimar
parents:
17391
diff
changeset
|
1715 if (priv->index_chunk_offset && parse_index_chunk(demuxer)) |
12665
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1716 { |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1717 demuxer->seekable = 1; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1718 } |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1719 break; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1720 case 1: // use (generate index) |
17394
d44f30816921
Always try to parse index chunk, no reason to check for movi_end
reimar
parents:
17391
diff
changeset
|
1721 if (priv->index_chunk_offset && parse_index_chunk(demuxer)) |
12665
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1722 { |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1723 demuxer->seekable = 1; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1724 } else { |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1725 generate_index(demuxer); |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1726 demuxer->seekable = 1; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1727 } |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1728 break; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1729 case 2: // force generating index |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1730 generate_index(demuxer); |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1731 demuxer->seekable = 1; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1732 break; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1733 default: // do nothing |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1734 break; |
751a27fc8895
index creation/reading behaviour just like the avi demuxer, patch based on work by Reza Jelveh, Moritz Bunkus und myself
alex
parents:
12367
diff
changeset
|
1735 } |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1736 |
14402 | 1737 if(priv->is_multirate) |
1738 demuxer->seekable = 0; // No seeking yet for multirate streams | |
1739 | |
8109
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1740 // detect streams: |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1741 if(demuxer->video->id==-1 && v_streams>0){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1742 // find the valid video stream: |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1743 if(!ds_fill_buffer(demuxer->video)){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1744 mp_msg(MSGT_DEMUXER,MSGL_INFO,"RM: " MSGTR_MissingVideoStream); |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1745 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1746 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1747 if(demuxer->audio->id==-1 && a_streams>0){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1748 // find the valid audio stream: |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1749 if(!ds_fill_buffer(demuxer->audio)){ |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1750 mp_msg(MSGT_DEMUXER,MSGL_INFO,"RM: " MSGTR_MissingAudioStream); |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1751 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1752 } |
cb4c507c69aa
ASF-style stream auto-selection, to fix files with fake a/v streams (only
arpi
parents:
8094
diff
changeset
|
1753 |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1754 if(demuxer->video->sh){ |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1755 sh_video_t *sh=demuxer->video->sh; |
14578 | 1756 mp_msg(MSGT_DEMUX,MSGL_V,"VIDEO: %.4s [%08X,%08X] %dx%d (aspect %4.2f) %4.2f fps\n", |
17366 | 1757 (char *)&sh->format,((unsigned int*)(sh->bih+1))[1],((unsigned int*)(sh->bih+1))[0], |
9561
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1758 sh->disp_w,sh->disp_h,sh->aspect,sh->fps); |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1759 } |
05c462fd6bff
- fixed playback of files with bad WxH in header (tricky! we can always read the
arpi
parents:
9555
diff
changeset
|
1760 |
17388
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1761 if(demuxer->audio->sh){ |
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1762 sh_audio_t *sh=demuxer->audio->sh; |
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1763 mp_msg(MSGT_DEMUX,MSGL_V,"AUDIO: %.4s [%08X]\n", |
17391 | 1764 (char *)&sh->format,sh->format); |
17388
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1765 } |
002e4923d5ab
Print audio 4cc for every stream, print 4cc of selected audio track
rtognimp
parents:
17366
diff
changeset
|
1766 |
16175 | 1767 return demuxer; |
3777 | 1768 } |
1769 | |
16175 | 1770 static void demux_close_real(demuxer_t *demuxer) |
3777 | 1771 { |
13837 | 1772 int i; |
3777 | 1773 real_priv_t* priv = demuxer->priv; |
1774 | |
13837 | 1775 if (priv){ |
1776 for(i=0; i<MAX_STREAMS; i++) | |
1777 if(priv->index_table[i]) | |
1778 free(priv->index_table[i]); | |
17318
184a3683834a
Don't leak memory (free audio reordering buffers)
rtognimp
parents:
17317
diff
changeset
|
1779 if (priv->audio_buf) |
184a3683834a
Don't leak memory (free audio reordering buffers)
rtognimp
parents:
17317
diff
changeset
|
1780 free(priv->audio_buf); |
184a3683834a
Don't leak memory (free audio reordering buffers)
rtognimp
parents:
17317
diff
changeset
|
1781 if (priv->audio_timestamp) |
184a3683834a
Don't leak memory (free audio reordering buffers)
rtognimp
parents:
17317
diff
changeset
|
1782 free(priv->audio_timestamp); |
3777 | 1783 free(priv); |
13837 | 1784 } |
3777 | 1785 |
1786 return; | |
1787 } | |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1788 |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1789 /* please upload RV10 samples WITH INDEX CHUNK */ |
17636 | 1790 static void demux_seek_real(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags) |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1791 { |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1792 real_priv_t *priv = demuxer->priv; |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1793 demux_stream_t *d_audio = demuxer->audio; |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1794 demux_stream_t *d_video = demuxer->video; |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1795 sh_audio_t *sh_audio = d_audio->sh; |
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1796 sh_video_t *sh_video = d_video->sh; |
6344 | 1797 int vid = d_video->id, aid = d_audio->id; |
6404
83b3315c679b
Implement Nilmoni's and Bernd Ernesti's patches for:
atmos4
parents:
6374
diff
changeset
|
1798 int next_offset = 0; |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
1799 int64_t cur_timestamp = 0; |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1800 int streams = 0; |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1801 int retried = 0; |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1802 |
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1803 |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1804 if (sh_video && (unsigned)vid < MAX_STREAMS && priv->index_table_size[vid]) |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1805 streams |= 1; |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1806 if (sh_audio && (unsigned)aid < MAX_STREAMS && priv->index_table_size[aid]) |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1807 streams |= 2; |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1808 |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1809 // printf("streams: %d\n", streams); |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1810 |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1811 if (!streams) |
17174
83a8c738be89
make demuxer seek and close functions return void, patch by Dominik Mierzejewski
wanderer
parents:
17149
diff
changeset
|
1812 return; |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1813 |
25883
baf32110d3fc
Use defines to give names to the different seek flags.
reimar
parents:
25707
diff
changeset
|
1814 if (flags & SEEK_ABSOLUTE) |
5083
ce6952225939
added PRE-ALPHA seeking ability and index table generator (like avi's one)
alex
parents:
4328
diff
changeset
|
1815 priv->current_apacket = priv->current_vpacket = 0; |
25883
baf32110d3fc
Use defines to give names to the different seek flags.
reimar
parents:
25707
diff
changeset
|
1816 if (flags & SEEK_FACTOR) |
20492
0b563edd9b3a
Quick hack to implement percent-based seeking, also fixes seeking with gmplayer
reimar
parents:
20229
diff
changeset
|
1817 rel_seek_secs *= priv->duration; |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1818 |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1819 if ((streams & 1) && priv->current_vpacket >= priv->index_table_size[vid]) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1820 priv->current_vpacket = priv->index_table_size[vid] - 1; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1821 if ((streams & 2) && priv->current_apacket >= priv->index_table_size[aid]) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1822 priv->current_apacket = priv->index_table_size[aid] - 1; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1823 |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1824 // if (index_mode == 1 || index_mode == 2) { |
11441 | 1825 if (streams & 1) {// use the video index if we have one |
1826 cur_timestamp = priv->index_table[vid][priv->current_vpacket].timestamp; | |
1827 if (rel_seek_secs > 0) | |
1828 while ((priv->index_table[vid][priv->current_vpacket].timestamp - cur_timestamp) < rel_seek_secs * 1000){ | |
1829 priv->current_vpacket += 1; | |
1830 if (priv->current_vpacket >= priv->index_table_size[vid]) { | |
1831 priv->current_vpacket = priv->index_table_size[vid] - 1; | |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1832 if (!retried) { |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1833 stream_seek(demuxer->stream, priv->index_table[vid][priv->current_vpacket].offset); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1834 add_index_segment(demuxer, vid, cur_timestamp + rel_seek_secs * 1000); |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1835 retried = 1; |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1836 } |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1837 else |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1838 break; |
11441 | 1839 } |
1840 } | |
1841 else if (rel_seek_secs < 0) | |
1842 while ((cur_timestamp - priv->index_table[vid][priv->current_vpacket].timestamp) < - rel_seek_secs * 1000){ | |
1843 priv->current_vpacket -= 1; | |
1844 if (priv->current_vpacket < 0) { | |
1845 priv->current_vpacket = 0; | |
1846 break; | |
1847 } | |
1848 } | |
1849 next_offset = priv->index_table[vid][priv->current_vpacket].offset; | |
1850 priv->audio_need_keyframe = 1; | |
1851 priv->video_after_seek = 1; | |
1852 } | |
1853 else if (streams & 2) { | |
1854 cur_timestamp = priv->index_table[aid][priv->current_apacket].timestamp; | |
1855 if (rel_seek_secs > 0) | |
1856 while ((priv->index_table[aid][priv->current_apacket].timestamp - cur_timestamp) < rel_seek_secs * 1000){ | |
1857 priv->current_apacket += 1; | |
1858 if (priv->current_apacket >= priv->index_table_size[aid]) { | |
1859 priv->current_apacket = priv->index_table_size[aid] - 1; | |
1860 break; | |
1861 } | |
1862 } | |
1863 else if (rel_seek_secs < 0) | |
1864 while ((cur_timestamp - priv->index_table[aid][priv->current_apacket].timestamp) < - rel_seek_secs * 1000){ | |
1865 priv->current_apacket -= 1; | |
1866 if (priv->current_apacket < 0) { | |
1867 priv->current_apacket = 0; | |
1868 break; | |
1869 } | |
1870 } | |
1871 next_offset = priv->index_table[aid][priv->current_apacket].offset; | |
1872 } | |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1873 // } |
5918
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1874 // printf("seek: pos: %d, current packets: a: %d, v: %d\n", |
dca3016882cf
completed real seeking - working very well with audio only files
alex
parents:
5810
diff
changeset
|
1875 // next_offset, priv->current_apacket, priv->current_vpacket); |
11596
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1876 if (next_offset) |
6d377637ea60
Proper runtime index generation with support for growing files. Patch by rgselk <rgselknospam@yahoo.com>
alex
parents:
11441
diff
changeset
|
1877 stream_seek(demuxer->stream, next_offset); |
11441 | 1878 |
16175 | 1879 demux_real_fill_buffer(demuxer, NULL); |
3882
c5cefeb78c40
added read_index_chunk, fixed audio_header parser for version5
alex
parents:
3877
diff
changeset
|
1880 } |
11441 | 1881 |
16175 | 1882 static int demux_real_control(demuxer_t *demuxer, int cmd, void *arg) |
11441 | 1883 { |
1884 real_priv_t *priv = demuxer->priv; | |
20139
1ef90de62efa
Fix problems on live streams with huge timestamps, causing overflows and
rtogni
parents:
19960
diff
changeset
|
1885 unsigned int lastpts = priv->v_pts ? priv->v_pts : priv->a_pts; |
11441 | 1886 |
1887 switch (cmd) { | |
1888 case DEMUXER_CTRL_GET_TIME_LENGTH: | |
1889 if (priv->duration == 0) | |
1890 return DEMUXER_CTRL_DONTKNOW; | |
1891 | |
16346
6ff303d2876b
Make -identify's 'ID_LENGTH=' print a float and not an integer.. The
ods15
parents:
16175
diff
changeset
|
1892 *((double *)arg) = (double)priv->duration; |
11441 | 1893 return DEMUXER_CTRL_OK; |
1894 | |
1895 case DEMUXER_CTRL_GET_PERCENT_POS: | |
1896 if (priv->duration == 0) | |
1897 return DEMUXER_CTRL_DONTKNOW; | |
1898 | |
1899 *((int *)arg) = (int)(100 * lastpts / priv->duration); | |
1900 return DEMUXER_CTRL_OK; | |
1901 | |
1902 default: | |
1903 return DEMUXER_CTRL_NOTIMPL; | |
1904 } | |
1905 } | |
16175 | 1906 |
1907 | |
25707
d4fe6e23283e
Make all demuxer_desc_t const, thus moving them to .rodata
reimar
parents:
25600
diff
changeset
|
1908 const demuxer_desc_t demuxer_desc_real = { |
16175 | 1909 "Realmedia demuxer", |
1910 "real", | |
1911 "REAL", | |
1912 "Alex Beregszasi, Florian Schneider, A'rpi, Roberto Togni", | |
1913 "handles new .RMF files", | |
1914 DEMUXER_TYPE_REAL, | |
1915 1, // safe autodetect | |
1916 real_check_file, | |
1917 demux_real_fill_buffer, | |
1918 demux_open_real, | |
1919 demux_close_real, | |
1920 demux_seek_real, | |
1921 demux_real_control | |
1922 }; |