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