Mercurial > mplayer.hg
annotate libmpdemux/aviheader.c @ 32676:db882cd69776
Do not #define _WIN32 on the command line for Cygwin.
Newer Cygwin versions no longer do this and hopefully we should be able
to survive without this hack as well. This change necessitates adapting
two #ifdefs in the MPlayer codebase. It is committed untested as I do
not have access to a Cygwin system.
author | diego |
---|---|
date | Thu, 06 Jan 2011 12:42:59 +0000 |
parents | 231764e0b755 |
children | 15f527594411 |
rev | line source |
---|---|
29238
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
1 /* |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
2 * This file is part of MPlayer. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
3 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
4 * MPlayer is free software; you can redistribute it and/or modify |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
5 * 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:
25201
diff
changeset
|
6 * the Free Software Foundation; either version 2 of the License, or |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
7 * (at your option) any later version. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
8 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
9 * MPlayer is distributed in the hope that it will be useful, |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
12 * GNU General Public License for more details. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
13 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
14 * 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:
25201
diff
changeset
|
15 * with MPlayer; if not, write to the Free Software Foundation, Inc., |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
25201
diff
changeset
|
17 */ |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
18 |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
19 #include <stdio.h> |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
20 #include <stdlib.h> |
1430 | 21 #include <unistd.h> |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
22 #include <errno.h> |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
23 |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
24 #include "config.h" |
1567 | 25 #include "mp_msg.h" |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
26 #include "help_mp.h" |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
27 |
22605
4d81dbdf46b9
Add explicit location for headers from the stream/ directory.
diego
parents:
21967
diff
changeset
|
28 #include "stream/stream.h" |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
29 #include "demuxer.h" |
2338 | 30 #include "stheader.h" |
30589
df6c41f16b40
Add header for AVI print functions; avoids many forward declarations.
diego
parents:
30570
diff
changeset
|
31 #include "aviprint.h" |
1342 | 32 #include "aviheader.h" |
21532 | 33 #include "libavutil/common.h" |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
34 |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
35 static MainAVIHeader avih; |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
36 |
12036 | 37 static int odml_get_vstream_id(int id, unsigned char res[]) |
38 { | |
31615 | 39 if ((char)(id >> 16) == 'd') { |
12036 | 40 if (res) { |
31615 | 41 res[0] = id; |
42 res[1] = id >> 8; | |
12036 | 43 } |
44 return 1; | |
45 } | |
46 return 0; | |
47 } | |
48 | |
30570
98dc6ae7ede2
libmpdemux: Mark functions not used outside of their files as static.
diego
parents:
30088
diff
changeset
|
49 static int avi_idx_cmp(const void *elem1, const void *elem2) |
98dc6ae7ede2
libmpdemux: Mark functions not used outside of their files as static.
diego
parents:
30088
diff
changeset
|
50 { |
14297 | 51 register off_t a = AVI_IDX_OFFSET((AVIINDEXENTRY *)elem1); |
52 register off_t b = AVI_IDX_OFFSET((AVIINDEXENTRY *)elem2); | |
53 return (a > b) - (b > a); | |
12036 | 54 } |
601 | 55 |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
56 void read_avi_header(demuxer_t *demuxer,int index_mode){ |
426 | 57 sh_audio_t *sh_audio=NULL; |
58 sh_video_t *sh_video=NULL; | |
1 | 59 int stream_id=-1; |
568 | 60 int idxfix_videostream=0; |
61 int idxfix_divx=0; | |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
62 avi_priv_t* priv=demuxer->priv; |
4664 | 63 off_t list_end=0; |
1 | 64 |
65 //---- AVI header: | |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
66 priv->idx_size=0; |
2330 | 67 priv->audio_streams=0; |
1 | 68 while(1){ |
69 int id=stream_read_dword_le(demuxer->stream); | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
70 unsigned chunksize,size2; |
1 | 71 static int last_fccType=0; |
23965
8d4b1bda30f1
Fix detection of xan audio. -noidx or -forceidx still is necessary
reimar
parents:
23841
diff
changeset
|
72 static int last_fccHandler=0; |
1671
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
73 char* hdr=NULL; |
1 | 74 // |
75 if(stream_eof(demuxer->stream)) break; | |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
76 // Imply -forceidx if -saveidx is specified |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
77 if (index_file_save) |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
78 index_mode = 2; |
1 | 79 // |
80 if(id==mmioFOURCC('L','I','S','T')){ | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
81 unsigned len=stream_read_dword_le(demuxer->stream); // list size |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
82 id=stream_read_dword_le(demuxer->stream); // list type |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
83 mp_msg(MSGT_HEADER,MSGL_DBG2,"LIST %.4s len=%u\n",(char *) &id,len); |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
84 if(len >= 4) { |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
85 len -= 4; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
86 list_end=stream_tell(demuxer->stream)+((len+1)&(~1)); |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
87 } else { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
88 mp_msg(MSGT_HEADER,MSGL_WARN,MSGTR_MPDEMUX_AVIHDR_EmptyList); |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
89 list_end = 0; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
90 } |
5933 | 91 mp_msg(MSGT_HEADER,MSGL_V,"list_end=0x%X\n",(int)list_end); |
1 | 92 if(id==listtypeAVIMOVIE){ |
93 // found MOVI header | |
4154 | 94 if(!demuxer->movi_start) demuxer->movi_start=stream_tell(demuxer->stream); |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
95 demuxer->movi_end=stream_tell(demuxer->stream)+len; |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
96 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundMovieAt,(int)demuxer->movi_start,(int)demuxer->movi_end); |
6274 | 97 if(demuxer->stream->end_pos>demuxer->movi_end) demuxer->movi_end=demuxer->stream->end_pos; |
4621
16cbaff638ac
Don't read index for -forceidx and -nodix (speedup with bad media and not needed anyway)
atmos4
parents:
4225
diff
changeset
|
98 if(index_mode==-2 || index_mode==2 || index_mode==0) |
16cbaff638ac
Don't read index for -forceidx and -nodix (speedup with bad media and not needed anyway)
atmos4
parents:
4225
diff
changeset
|
99 break; // reading from non-seekable source (stdin) or forced index or no index forced |
7762 | 100 if(list_end>0) stream_seek(demuxer->stream,list_end); // skip movi |
101 list_end=0; | |
1 | 102 } |
103 continue; | |
104 } | |
105 size2=stream_read_dword_le(demuxer->stream); | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
106 mp_msg(MSGT_HEADER,MSGL_DBG2,"CHUNK %.4s len=%u\n",(char *) &id,size2); |
1 | 107 chunksize=(size2+1)&(~1); |
108 switch(id){ | |
4664 | 109 |
110 // Indicates where the subject of the file is archived | |
111 case mmioFOURCC('I','A','R','L'): hdr="Archival Location";break; | |
112 // Lists the artist of the original subject of the file; | |
113 // for example, "Michaelangelo." | |
114 case mmioFOURCC('I','A','R','T'): hdr="Artist";break; | |
115 // Lists the name of the person or organization that commissioned | |
116 // the subject of the file; for example "Pope Julian II." | |
117 case mmioFOURCC('I','C','M','S'): hdr="Commissioned";break; | |
118 // Provides general comments about the file or the subject | |
119 // of the file. If the comment is several sentences long, end each | |
120 // sentence with a period. Do not include new-line characters. | |
121 case mmioFOURCC('I','C','M','T'): hdr="Comments";break; | |
122 // Records the copyright information for the file; for example, | |
123 // "Copyright Encyclopedia International 1991." If there are multiple | |
124 // copyrights, separate them by semicolon followed by a space. | |
125 case mmioFOURCC('I','C','O','P'): hdr="Copyright";break; | |
126 // Describes whether an image has been cropped and, if so, how it | |
127 // was cropped; for example, "lower-right corner." | |
128 case mmioFOURCC('I','C','R','D'): hdr="Creation Date";break; | |
129 // Describes whether an image has been cropped and, if so, how it | |
130 // was cropped; for example, "lower-right corner." | |
131 case mmioFOURCC('I','C','R','P'): hdr="Cropped";break; | |
132 // Specifies the size of the original subject of the file; for | |
133 // example, "8.5 in h, 11 in w." | |
134 case mmioFOURCC('I','D','I','M'): hdr="Dimensions";break; | |
135 // Stores dots per inch setting of the digitizer used to | |
136 // produce the file, such as "300." | |
137 case mmioFOURCC('I','D','P','I'): hdr="Dots Per Inch";break; | |
138 // Stores the of the engineer who worked on the file. If there are | |
139 // multiple engineers, separate the names by a semicolon and a blank; | |
140 // for example, "Smith, John; Adams, Joe." | |
141 case mmioFOURCC('I','E','N','G'): hdr="Engineer";break; | |
142 // Describes the original work, such as "landscape,", "portrait," | |
143 // "still liefe," etc. | |
144 case mmioFOURCC('I','G','N','R'): hdr="Genre";break; | |
145 // Provides a list of keywords that refer to the file or subject of the | |
146 // file. Separate multiple keywords with a semicolon and a blank; | |
147 // for example, "Seattle, aerial view; scenery." | |
148 case mmioFOURCC('I','K','E','Y'): hdr="Keywords";break; | |
149 // ILGT - Describes the changes in the lightness settings on the digitizer | |
150 // required to produce the file. Note that the format of this information | |
151 // depends on the hardware used. | |
152 case mmioFOURCC('I','L','G','T'): hdr="Lightness";break; | |
153 // IMED - Decribes the original subject of the file, such as | |
154 // "computer image," "drawing," "lithograph," and so on. | |
155 case mmioFOURCC('I','M','E','D'): hdr="Medium";break; | |
156 // INAM - Stores the title of the subject of the file, such as | |
157 // "Seattle from Above." | |
29288
4a1c217a844b
In all demux_info_add calls change "name" to "title".
reimar
parents:
29263
diff
changeset
|
158 case mmioFOURCC('I','N','A','M'): hdr="Title";break; |
4664 | 159 // IPLT - Specifies the number of colors requested when digitizing |
160 // an image, such as "256." | |
161 case mmioFOURCC('I','P','L','T'): hdr="Palette Setting";break; | |
162 // IPRD - Specifies the name of title the file was originally intended | |
163 // for, such as "Encyclopedia of Pacific Northwest Geography." | |
164 case mmioFOURCC('I','P','R','D'): hdr="Product";break; | |
165 // ISBJ - Decsribes the contents of the file, such as | |
166 // "Aerial view of Seattle." | |
167 case mmioFOURCC('I','S','B','J'): hdr="Subject";break; | |
168 // ISFT - Identifies the name of the software packages used to create the | |
169 // file, such as "Microsoft WaveEdit" | |
170 case mmioFOURCC('I','S','F','T'): hdr="Software";break; | |
171 // ISHP - Identifies the change in sharpness for the digitizer | |
172 // required to produce the file (the format depends on the hardware used). | |
173 case mmioFOURCC('I','S','H','P'): hdr="Sharpness";break; | |
174 // ISRC - Identifies the name of the person or organization who | |
31834
64ba1daa147a
various spelling fixes, found by the Debian QA tool 'lintian'
siretart
parents:
31615
diff
changeset
|
175 // supplied the original subject of the file; for example, "Try Research." |
4664 | 176 case mmioFOURCC('I','S','R','C'): hdr="Source";break; |
177 // ISRF - Identifies the original form of the material that was digitized, | |
178 // such as "slide," "paper," "map," and so on. This is not necessarily | |
179 // the same as IMED | |
180 case mmioFOURCC('I','S','R','F'): hdr="Source Form";break; | |
181 // ITCH - Identifies the technician who digitized the subject file; | |
182 // for example, "Smith, John." | |
183 case mmioFOURCC('I','T','C','H'): hdr="Technician";break; | |
184 case mmioFOURCC('I','S','M','P'): hdr="Time Code";break; | |
185 case mmioFOURCC('I','D','I','T'): hdr="Digitization Time";break; | |
186 | |
1 | 187 case ckidAVIMAINHDR: // read 'avih' |
21532 | 188 stream_read(demuxer->stream,(char*) &avih,FFMIN(size2,sizeof(avih))); |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
189 le2me_MainAVIHeader(&avih); // swap to machine endian |
21532 | 190 chunksize-=FFMIN(size2,sizeof(avih)); |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
191 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_avih(&avih,MSGL_V); // else print_avih_flags(&avih,MSGL_V); |
1 | 192 break; |
193 case ckidSTREAMHEADER: { // read 'strh' | |
194 AVIStreamHeader h; | |
21532 | 195 stream_read(demuxer->stream,(char*) &h,FFMIN(size2,sizeof(h))); |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
196 le2me_AVIStreamHeader(&h); // swap to machine endian |
21532 | 197 chunksize-=FFMIN(size2,sizeof(h)); |
426 | 198 ++stream_id; |
199 if(h.fccType==streamtypeVIDEO){ | |
1289 | 200 sh_video=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
|
201 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_VideoID, "aviheader", stream_id); |
426 | 202 memcpy(&sh_video->video,&h,sizeof(h)); |
21387
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
203 sh_video->stream_delay = (float)sh_video->video.dwStart * sh_video->video.dwScale/sh_video->video.dwRate; |
426 | 204 } else |
205 if(h.fccType==streamtypeAUDIO){ | |
31609
cd81fce1f010
Make the stream language an argument to the stream creation function
reimar
parents:
30633
diff
changeset
|
206 sh_audio=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
|
207 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "aviheader", stream_id); |
426 | 208 memcpy(&sh_audio->audio,&h,sizeof(h)); |
21387
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
209 sh_audio->stream_delay = (float)sh_audio->audio.dwStart * sh_audio->audio.dwScale/sh_audio->audio.dwRate; |
30088
4977e04f3a18
Add support for parsing audio streams (though should be easy to extend to video)
reimar
parents:
30010
diff
changeset
|
210 sh_audio->needs_parsing = 1; |
426 | 211 } |
1 | 212 last_fccType=h.fccType; |
23965
8d4b1bda30f1
Fix detection of xan audio. -noidx or -forceidx still is necessary
reimar
parents:
23841
diff
changeset
|
213 last_fccHandler=h.fccHandler; |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
214 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_strh(&h,MSGL_V); |
1 | 215 break; } |
12036 | 216 case mmioFOURCC('i', 'n', 'd', 'x'): { |
12342 | 217 uint32_t i; |
12036 | 218 avisuperindex_chunk *s; |
21772 | 219 |
220 if(!index_mode) break; | |
221 | |
18052
be163e9c9bca
make sure the indx chunk is big enough to hold the basic structure.
iive
parents:
18051
diff
changeset
|
222 if(chunksize<=24){ |
be163e9c9bca
make sure the indx chunk is big enough to hold the basic structure.
iive
parents:
18051
diff
changeset
|
223 break; |
be163e9c9bca
make sure the indx chunk is big enough to hold the basic structure.
iive
parents:
18051
diff
changeset
|
224 } |
12036 | 225 priv->suidx_size++; |
18558
4928dd61f136
Fix potential integer overflows in memory allocation.
rtogni
parents:
18052
diff
changeset
|
226 priv->suidx = realloc_struct(priv->suidx, priv->suidx_size, sizeof (avisuperindex_chunk)); |
12036 | 227 s = &priv->suidx[priv->suidx_size-1]; |
228 | |
229 chunksize-=24; | |
230 memcpy(s->fcc, "indx", 4); | |
231 s->dwSize = size2; | |
232 s->wLongsPerEntry = stream_read_word_le(demuxer->stream); | |
233 s->bIndexSubType = stream_read_char(demuxer->stream); | |
234 s->bIndexType = stream_read_char(demuxer->stream); | |
235 s->nEntriesInUse = stream_read_dword_le(demuxer->stream); | |
236 *(uint32_t *)s->dwChunkId = stream_read_dword_le(demuxer->stream); | |
237 stream_read(demuxer->stream, (char *)s->dwReserved, 3*4); | |
238 memset(s->dwReserved, 0, 3*4); | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
239 |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
240 print_avisuperindex_chunk(s,MSGL_V); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
241 |
24427 | 242 // Check and fix this useless crap |
243 if(s->wLongsPerEntry != sizeof (avisuperindex_entry)/4) { | |
244 mp_msg (MSGT_HEADER, MSGL_WARN, "Broken super index chunk size: %u\n",s->wLongsPerEntry); | |
245 s->wLongsPerEntry = sizeof(avisuperindex_entry)/4; | |
246 } | |
18049
77a3b0d11ca5
Limit the number of entires to the amount that does fit into the chunk.
iive
parents:
17990
diff
changeset
|
247 if( ((chunksize/4)/s->wLongsPerEntry) < s->nEntriesInUse){ |
77a3b0d11ca5
Limit the number of entires to the amount that does fit into the chunk.
iive
parents:
17990
diff
changeset
|
248 mp_msg (MSGT_HEADER, MSGL_WARN, "Broken super index chunk\n"); |
77a3b0d11ca5
Limit the number of entires to the amount that does fit into the chunk.
iive
parents:
17990
diff
changeset
|
249 s->nEntriesInUse = (chunksize/4)/s->wLongsPerEntry; |
77a3b0d11ca5
Limit the number of entires to the amount that does fit into the chunk.
iive
parents:
17990
diff
changeset
|
250 } |
12036 | 251 |
18051
110105412f8f
use calloc instead of malloc - simplifies code and fixes overflow problems.
reimar
parents:
18050
diff
changeset
|
252 s->aIndex = calloc(s->nEntriesInUse, sizeof (avisuperindex_entry)); |
110105412f8f
use calloc instead of malloc - simplifies code and fixes overflow problems.
reimar
parents:
18050
diff
changeset
|
253 s->stdidx = calloc(s->nEntriesInUse, sizeof (avistdindex_chunk)); |
12036 | 254 |
255 // now the real index of indices | |
256 for (i=0; i<s->nEntriesInUse; i++) { | |
257 chunksize-=16; | |
23759 | 258 s->aIndex[i].qwOffset = stream_read_qword_le(demuxer->stream); |
12036 | 259 s->aIndex[i].dwSize = stream_read_dword_le(demuxer->stream); |
260 s->aIndex[i].dwDuration = stream_read_dword_le(demuxer->stream); | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
261 mp_msg (MSGT_HEADER, MSGL_V, "ODML (%.4s): [%d] 0x%016"PRIx64" 0x%04x %u\n", |
12036 | 262 (s->dwChunkId), i, |
263 (uint64_t)s->aIndex[i].qwOffset, s->aIndex[i].dwSize, s->aIndex[i].dwDuration); | |
264 } | |
265 | |
266 break; } | |
1 | 267 case ckidSTREAMFORMAT: { // read 'strf' |
268 if(last_fccType==streamtypeVIDEO){ | |
32105 | 269 sh_video->bih=calloc(FFMAX(chunksize, sizeof(*sh_video->bih)), 1); |
433 | 270 // sh_video->bih=malloc(chunksize); memset(sh_video->bih,0,chunksize); |
32105 | 271 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundBitmapInfoHeader,chunksize,sizeof(*sh_video->bih)); |
432
5251b0c57e39
sh_audio->wf and sh_video->bih changed to dynamic (thanx to Jens Hoffmann)
arpi_esp
parents:
426
diff
changeset
|
272 stream_read(demuxer->stream,(char*) sh_video->bih,chunksize); |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
273 le2me_BITMAPINFOHEADER(sh_video->bih); // swap to machine endian |
32105 | 274 if (sh_video->bih->biSize > chunksize && sh_video->bih->biSize > sizeof(*sh_video->bih)) |
21967 | 275 sh_video->bih->biSize = chunksize; |
5418
5b852c08473f
I hate M$. it seems that MSRLE biSize is always 40 when number of colors < 256 instead of 40+colors*4
arpi
parents:
4664
diff
changeset
|
276 // fixup MS-RLE header (seems to be broken for <256 color files) |
7784 | 277 if(sh_video->bih->biCompression<=1 && sh_video->bih->biSize==40) |
5418
5b852c08473f
I hate M$. it seems that MSRLE biSize is always 40 when number of colors < 256 instead of 40+colors*4
arpi
parents:
4664
diff
changeset
|
278 sh_video->bih->biSize=chunksize; |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
279 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih,MSGL_V); |
432
5251b0c57e39
sh_audio->wf and sh_video->bih changed to dynamic (thanx to Jens Hoffmann)
arpi_esp
parents:
426
diff
changeset
|
280 chunksize=0; |
21387
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
281 sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale; |
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
282 sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate; |
25201
f2036002cac3
Set sh_video->format when parsing aviheader, otherwise it might never
reimar
parents:
24427
diff
changeset
|
283 sh_video->format = sh_video->bih->biCompression; |
426 | 284 // if(demuxer->video->id==-1) demuxer->video->id=stream_id; |
568 | 285 // IdxFix: |
286 idxfix_videostream=stream_id; | |
287 switch(sh_video->bih->biCompression){ | |
6275 | 288 case mmioFOURCC('M', 'P', 'G', '4'): |
289 case mmioFOURCC('m', 'p', 'g', '4'): | |
290 case mmioFOURCC('D', 'I', 'V', '1'): | |
13700 | 291 idxfix_divx=3; // set index recovery mpeg4 flavour: msmpeg4v1 |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
292 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForMPG4V1); |
6275 | 293 break; |
294 case mmioFOURCC('D', 'I', 'V', '3'): | |
568 | 295 case mmioFOURCC('d', 'i', 'v', '3'): |
296 case mmioFOURCC('D', 'I', 'V', '4'): | |
297 case mmioFOURCC('d', 'i', 'v', '4'): | |
298 case mmioFOURCC('D', 'I', 'V', '5'): | |
299 case mmioFOURCC('d', 'i', 'v', '5'): | |
300 case mmioFOURCC('D', 'I', 'V', '6'): | |
301 case mmioFOURCC('d', 'i', 'v', '6'): | |
302 case mmioFOURCC('M', 'P', '4', '3'): | |
303 case mmioFOURCC('m', 'p', '4', '3'): | |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
304 case mmioFOURCC('M', 'P', '4', '2'): |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
305 case mmioFOURCC('m', 'p', '4', '2'): |
773 | 306 case mmioFOURCC('D', 'I', 'V', '2'): |
568 | 307 case mmioFOURCC('A', 'P', '4', '1'): |
13700 | 308 idxfix_divx=1; // set index recovery mpeg4 flavour: msmpeg4v3 |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
309 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForDIVX3); |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
310 break; |
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
311 case mmioFOURCC('D', 'I', 'V', 'X'): |
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
312 case mmioFOURCC('d', 'i', 'v', 'x'): |
6274 | 313 case mmioFOURCC('D', 'X', '5', '0'): |
13671 | 314 case mmioFOURCC('X', 'V', 'I', 'D'): |
315 case mmioFOURCC('x', 'v', 'i', 'd'): | |
14766 | 316 case mmioFOURCC('F', 'M', 'P', '4'): |
317 case mmioFOURCC('f', 'm', 'p', '4'): | |
13700 | 318 idxfix_divx=2; // set index recovery mpeg4 flavour: generic mpeg4 |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
319 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForMPEG4); |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
320 break; |
568 | 321 } |
1 | 322 } else |
323 if(last_fccType==streamtypeAUDIO){ | |
32105 | 324 unsigned wf_size = chunksize<sizeof(*sh_audio->wf)?sizeof(*sh_audio->wf):chunksize; |
1038
b36fb1ae4b53
applied solaris8/netbsd/other fixes patch by J«ärgen Keil <jk@tools.de>
arpi_esp
parents:
773
diff
changeset
|
325 sh_audio->wf=calloc(wf_size,1); |
433 | 326 // sh_audio->wf=malloc(chunksize); memset(sh_audio->wf,0,chunksize); |
32105 | 327 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundWaveFmt,chunksize,sizeof(*sh_audio->wf)); |
432
5251b0c57e39
sh_audio->wf and sh_video->bih changed to dynamic (thanx to Jens Hoffmann)
arpi_esp
parents:
426
diff
changeset
|
328 stream_read(demuxer->stream,(char*) sh_audio->wf,chunksize); |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
329 le2me_WAVEFORMATEX(sh_audio->wf); |
1038
b36fb1ae4b53
applied solaris8/netbsd/other fixes patch by J«ärgen Keil <jk@tools.de>
arpi_esp
parents:
773
diff
changeset
|
330 if (sh_audio->wf->cbSize != 0 && |
32105 | 331 wf_size < sizeof(*sh_audio->wf)+sh_audio->wf->cbSize) { |
332 sh_audio->wf=realloc(sh_audio->wf, sizeof(*sh_audio->wf)+sh_audio->wf->cbSize); | |
1038
b36fb1ae4b53
applied solaris8/netbsd/other fixes patch by J«ärgen Keil <jk@tools.de>
arpi_esp
parents:
773
diff
changeset
|
333 } |
21387
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
334 sh_audio->format=sh_audio->wf->wFormatTag; |
32552 | 335 if (sh_audio->wf->wFormatTag == 0xfffe && sh_audio->wf->cbSize >= 22) |
336 sh_audio->format = av_le2ne16(((WAVEFORMATEXTENSIBLE *)sh_audio->wf)->SubFormat); | |
23965
8d4b1bda30f1
Fix detection of xan audio. -noidx or -forceidx still is necessary
reimar
parents:
23841
diff
changeset
|
337 if (sh_audio->format == 1 && |
8d4b1bda30f1
Fix detection of xan audio. -noidx or -forceidx still is necessary
reimar
parents:
23841
diff
changeset
|
338 last_fccHandler == mmioFOURCC('A', 'x', 'a', 'n')) |
8d4b1bda30f1
Fix detection of xan audio. -noidx or -forceidx still is necessary
reimar
parents:
23841
diff
changeset
|
339 sh_audio->format = last_fccHandler; |
21387
8621736097f8
Move initialization of sh_audio/sh_video members to aviheader
reimar
parents:
21372
diff
changeset
|
340 sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec; |
432
5251b0c57e39
sh_audio->wf and sh_video->bih changed to dynamic (thanx to Jens Hoffmann)
arpi_esp
parents:
426
diff
changeset
|
341 chunksize=0; |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
342 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf,MSGL_V); |
2330 | 343 ++priv->audio_streams; |
426 | 344 // if(demuxer->audio->id==-1) demuxer->audio->id=stream_id; |
1 | 345 } |
346 break; | |
347 } | |
12036 | 348 case mmioFOURCC('v', 'p', 'r', 'p'): { |
349 VideoPropHeader *vprp = malloc(chunksize); | |
12342 | 350 unsigned int i; |
12036 | 351 stream_read(demuxer->stream, (void*)vprp, chunksize); |
352 le2me_VideoPropHeader(vprp); | |
353 chunksize -= sizeof(*vprp)-sizeof(vprp->FieldInfo); | |
354 chunksize /= sizeof(VIDEO_FIELD_DESC); | |
355 if (vprp->nbFieldPerFrame > chunksize) { | |
356 vprp->nbFieldPerFrame = chunksize; | |
357 } | |
358 chunksize = 0; | |
359 for (i=0; i<vprp->nbFieldPerFrame; i++) { | |
360 le2me_VIDEO_FIELD_DESC(&vprp->FieldInfo[i]); | |
361 } | |
12061 | 362 if (sh_video) { |
12036 | 363 sh_video->aspect = GET_AVI_ASPECT(vprp->dwFrameAspectRatio); |
364 } | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
365 if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_vprp(vprp,MSGL_V); |
15738
a0b807d489bc
memleak fix by bryanwilkerson WHIRLPOOL yahoo SPOT com
henry
parents:
14766
diff
changeset
|
366 free(vprp); |
12036 | 367 break; |
368 } | |
369 case mmioFOURCC('d', 'm', 'l', 'h'): { | |
370 // dmlh 00 00 00 04 frms | |
371 unsigned int total_frames = stream_read_dword_le(demuxer->stream); | |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
372 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundAVIV2Header, chunksize, total_frames); |
12036 | 373 stream_skip(demuxer->stream, chunksize-4); |
374 chunksize = 0; | |
375 } | |
376 break; | |
4225 | 377 case ckidAVINEWINDEX: |
378 if(demuxer->movi_end>stream_tell(demuxer->stream)) | |
379 demuxer->movi_end=stream_tell(demuxer->stream); // fixup movi-end | |
12036 | 380 if(index_mode && !priv->isodml){ |
32620
231764e0b755
Avoid using uninitialized data if index read does not return enough data.
reimar
parents:
32552
diff
changeset
|
381 int read; |
1309
598e3047ce13
Add some preliminary support for non-x86 architectures to mplayer
jkeil
parents:
1289
diff
changeset
|
382 int i; |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
383 priv->idx_size=size2>>4; |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
384 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_ReadingIndexBlockChunksForFrames, |
17366 | 385 priv->idx_size,avih.dwTotalFrames, (int64_t)stream_tell(demuxer->stream)); |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
386 priv->idx=malloc(priv->idx_size<<4); |
7762 | 387 // printf("\nindex to %p !!!!! (priv=%p)\n",priv->idx,priv); |
32620
231764e0b755
Avoid using uninitialized data if index read does not return enough data.
reimar
parents:
32552
diff
changeset
|
388 read = stream_read(demuxer->stream,(char*)priv->idx,priv->idx_size<<4); |
231764e0b755
Avoid using uninitialized data if index read does not return enough data.
reimar
parents:
32552
diff
changeset
|
389 priv->idx_size = FFMAX(read, 0) >> 4; |
12737
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
390 for (i = 0; i < priv->idx_size; i++) { // swap index to machine endian |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
391 AVIINDEXENTRY *entry=(AVIINDEXENTRY*)priv->idx + i; |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
392 le2me_AVIINDEXENTRY(entry); |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
393 /* |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
394 * We (ab)use the upper word for bits 32-47 of the offset, so |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
395 * we'll clear them here. |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
396 * FIXME: AFAIK no codec uses them, but if one does it will break |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
397 */ |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
398 entry->dwFlags&=0xffff; |
ac56419ba6db
We still need to make sure the upper 16 bits of dwFlags are cleared
ranma
parents:
12736
diff
changeset
|
399 } |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
400 chunksize-=priv->idx_size<<4; |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
401 if( mp_msg_test(MSGT_HEADER,MSGL_DBG2) ) print_index(priv->idx,priv->idx_size,MSGL_DBG2); |
1 | 402 } |
12036 | 403 break; |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
404 /* added May 2002 */ |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
405 case mmioFOURCC('R','I','F','F'): { |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
406 char riff_type[4]; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
407 |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
408 mp_msg(MSGT_HEADER, MSGL_V, MSGTR_MPDEMUX_AVIHDR_AdditionalRIFFHdr); |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
409 stream_read(demuxer->stream, riff_type, sizeof riff_type); |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
410 if (strncmp(riff_type, "AVIX", sizeof riff_type)) |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
411 mp_msg(MSGT_HEADER, MSGL_WARN, MSGTR_MPDEMUX_AVIHDR_WarnNotExtendedAVIHdr); |
12362 | 412 else { |
413 /* | |
414 * We got an extended AVI header, so we need to switch to | |
415 * ODML to get seeking to work, provided we got indx chunks | |
416 * in the header (suidx_size > 0). | |
417 */ | |
418 if (priv->suidx_size > 0) | |
419 priv->isodml = 1; | |
420 } | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
421 chunksize = 0; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
422 list_end = 0; /* a new list will follow */ |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
423 break; } |
12036 | 424 case ckidAVIPADDING: |
425 stream_skip(demuxer->stream, chunksize); | |
426 chunksize = 0; | |
427 break; | |
1 | 428 } |
1671
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
429 if(hdr){ |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
430 mp_msg(MSGT_HEADER,MSGL_V,"hdr=%s size=%u\n",hdr,size2); |
4664 | 431 if(size2==3) |
432 chunksize=1; // empty | |
433 else { | |
1671
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
434 char buf[256]; |
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
435 int len=(size2<250)?size2:250; |
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
436 stream_read(demuxer->stream,buf,len); |
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
437 chunksize-=len; |
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
438 buf[len]=0; |
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
439 mp_msg(MSGT_HEADER,MSGL_V,"%-10s: %s\n",hdr,buf); |
3071 | 440 demux_info_add(demuxer, hdr, buf); |
4664 | 441 } |
1671
e6804fef9061
print AVI info block (copyright,artist etc) (-v only)
arpi
parents:
1567
diff
changeset
|
442 } |
17366 | 443 mp_msg(MSGT_HEADER,MSGL_DBG2,"list_end=0x%"PRIX64" pos=0x%"PRIX64" chunksize=0x%"PRIX64" next=0x%"PRIX64"\n", |
444 (int64_t)list_end, (int64_t)stream_tell(demuxer->stream), | |
445 (int64_t)chunksize, (int64_t)chunksize+(int64_t)stream_tell(demuxer->stream)); | |
12036 | 446 if(list_end>0 && |
447 chunksize+stream_tell(demuxer->stream) == list_end) list_end=0; | |
4664 | 448 if(list_end>0 && chunksize+stream_tell(demuxer->stream)>list_end){ |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
449 mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_BrokenChunk,chunksize,(char *) &id); |
4664 | 450 stream_seek(demuxer->stream,list_end); |
451 list_end=0; | |
452 } else | |
1 | 453 if(chunksize>0) stream_skip(demuxer->stream,chunksize); else |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
454 if((int)chunksize<0) mp_msg(MSGT_HEADER,MSGL_WARN,"chunksize=%u (id=%.4s)\n",chunksize,(char *) &id); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
455 |
1 | 456 } |
457 | |
12728
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
458 if (priv->suidx_size > 0 && priv->idx_size == 0) { |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
459 /* |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
460 * No NEWAVIINDEX, but we got an OpenDML index. |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
461 */ |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
462 priv->isodml = 1; |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
463 } |
5369a905c5a5
If we don't have a NEWAVIINDEX chunk, but have an OpenDML index,
ranma
parents:
12362
diff
changeset
|
464 |
17564
8762ebad064f
fix -idx with ODML files (patch by Benjamin Zores < ben _at_ tutuxclan.org >)
aurel
parents:
17366
diff
changeset
|
465 if (priv->isodml && (index_mode==-1 || index_mode==0 || index_mode==1)) { |
12036 | 466 int i, j, k; |
467 | |
468 avisuperindex_chunk *cx; | |
469 AVIINDEXENTRY *idx; | |
470 | |
471 | |
472 if (priv->idx_size) free(priv->idx); | |
473 priv->idx_size = 0; | |
474 priv->idx_offset = 0; | |
475 priv->idx = NULL; | |
476 | |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
477 mp_msg(MSGT_HEADER, MSGL_INFO, MSGTR_MPDEMUX_AVIHDR_BuildingODMLidx, priv->suidx_size); |
12036 | 478 |
479 // read the standard indices | |
480 for (cx = &priv->suidx[0], i=0; i<priv->suidx_size; cx++, i++) { | |
481 stream_reset(demuxer->stream); | |
482 for (j=0; j<cx->nEntriesInUse; j++) { | |
483 int ret1, ret2; | |
484 memset(&cx->stdidx[j], 0, 32); | |
485 ret1 = stream_seek(demuxer->stream, (off_t)cx->aIndex[j].qwOffset); | |
486 ret2 = stream_read(demuxer->stream, (char *)&cx->stdidx[j], 32); | |
487 if (ret1 != 1 || ret2 != 32 || cx->stdidx[j].nEntriesInUse==0) { | |
488 // this is a broken file (probably incomplete) let the standard | |
489 // gen_index routine handle this | |
490 priv->isodml = 0; | |
491 priv->idx_size = 0; | |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
492 mp_msg(MSGT_HEADER, MSGL_WARN, MSGTR_MPDEMUX_AVIHDR_BrokenODMLfile); |
12036 | 493 goto freeout; |
494 } | |
495 | |
496 le2me_AVISTDIDXCHUNK(&cx->stdidx[j]); | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
497 print_avistdindex_chunk(&cx->stdidx[j],MSGL_V); |
12036 | 498 priv->idx_size += cx->stdidx[j].nEntriesInUse; |
499 cx->stdidx[j].aIndex = malloc(cx->stdidx[j].nEntriesInUse*sizeof(avistdindex_entry)); | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
500 stream_read(demuxer->stream, (char *)cx->stdidx[j].aIndex, |
12036 | 501 cx->stdidx[j].nEntriesInUse*sizeof(avistdindex_entry)); |
502 for (k=0;k<cx->stdidx[j].nEntriesInUse; k++) | |
503 le2me_AVISTDIDXENTRY(&cx->stdidx[j].aIndex[k]); | |
504 | |
505 cx->stdidx[j].dwReserved3 = 0; | |
506 | |
507 } | |
508 } | |
509 | |
510 /* | |
511 * We convert the index by translating all entries into AVIINDEXENTRYs | |
512 * and sorting them by offset. The result should be the same index | |
513 * we would get with -forceidx. | |
514 */ | |
515 | |
516 idx = priv->idx = malloc(priv->idx_size * sizeof (AVIINDEXENTRY)); | |
517 | |
518 for (cx = priv->suidx; cx != &priv->suidx[priv->suidx_size]; cx++) { | |
519 avistdindex_chunk *sic; | |
520 for (sic = cx->stdidx; sic != &cx->stdidx[cx->nEntriesInUse]; sic++) { | |
521 avistdindex_entry *sie; | |
522 for (sie = sic->aIndex; sie != &sic->aIndex[sic->nEntriesInUse]; sie++) { | |
523 uint64_t off = sic->qwBaseOffset + sie->dwOffset - 8; | |
524 memcpy(&idx->ckid, sic->dwChunkId, 4); | |
525 idx->dwChunkOffset = off; | |
526 idx->dwFlags = (off >> 32) << 16; | |
527 idx->dwChunkLength = sie->dwSize & 0x7fffffff; | |
528 idx->dwFlags |= (sie->dwSize&0x80000000)?0x0:AVIIF_KEYFRAME; // bit 31 denotes !keyframe | |
529 idx++; | |
530 } | |
531 } | |
532 } | |
14297 | 533 qsort(priv->idx, priv->idx_size, sizeof(AVIINDEXENTRY), avi_idx_cmp); |
12036 | 534 |
535 /* | |
536 Hack to work around a "wrong" index in some divx odml files | |
537 (processor_burning.avi as an example) | |
538 They have ##dc on non keyframes but the ix00 tells us they are ##db. | |
539 Read the fcc of a non-keyframe vid frame and check it. | |
540 */ | |
541 | |
542 { | |
543 uint32_t id; | |
544 uint32_t db = 0; | |
545 stream_reset (demuxer->stream); | |
546 | |
547 // find out the video stream id. I have seen files with 01db. | |
548 for (idx = &((AVIINDEXENTRY *)priv->idx)[0], i=0; i<priv->idx_size; i++, idx++){ | |
549 unsigned char res[2]; | |
550 if (odml_get_vstream_id(idx->ckid, res)) { | |
551 db = mmioFOURCC(res[0], res[1], 'd', 'b'); | |
552 break; | |
553 } | |
554 } | |
555 | |
556 // find first non keyframe | |
557 for (idx = &((AVIINDEXENTRY *)priv->idx)[0], i=0; i<priv->idx_size; i++, idx++){ | |
558 if (!(idx->dwFlags & AVIIF_KEYFRAME) && idx->ckid == db) break; | |
559 } | |
560 if (i<priv->idx_size && db) { | |
561 stream_seek(demuxer->stream, AVI_IDX_OFFSET(idx)); | |
562 id = stream_read_dword_le(demuxer->stream); | |
563 if (id && id != db) // index fcc and real fcc differ? fix it. | |
564 for (idx = &((AVIINDEXENTRY *)priv->idx)[0], i=0; i<priv->idx_size; i++, idx++){ | |
565 if (!(idx->dwFlags & AVIIF_KEYFRAME) && idx->ckid == db) | |
566 idx->ckid = id; | |
567 } | |
568 } | |
569 } | |
570 | |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
571 if ( mp_msg_test(MSGT_HEADER,MSGL_DBG2) ) print_index(priv->idx, priv->idx_size,MSGL_DBG2); |
12036 | 572 |
573 demuxer->movi_end=demuxer->stream->end_pos; | |
574 | |
575 freeout: | |
576 | |
577 // free unneeded stuff | |
578 cx = &priv->suidx[0]; | |
579 do { | |
580 for (j=0;j<cx->nEntriesInUse;j++) | |
581 if (cx->stdidx[j].nEntriesInUse) free(cx->stdidx[j].aIndex); | |
582 free(cx->stdidx); | |
583 | |
584 } while (cx++ != &priv->suidx[priv->suidx_size-1]); | |
585 free(priv->suidx); | |
586 | |
587 } | |
588 | |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
589 /* Read a saved index file */ |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
590 if (index_file_load) { |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
591 FILE *fp; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
592 char magic[7]; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
593 unsigned int i; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
594 |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
595 if ((fp = fopen(index_file_load, "r")) == NULL) { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
596 mp_msg(MSGT_HEADER,MSGL_ERR, MSGTR_MPDEMUX_AVIHDR_CantReadIdxFile, index_file_load, strerror(errno)); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
597 goto gen_index; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
598 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
599 fread(&magic, 6, 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
600 if (strncmp(magic, "MPIDX1", 6)) { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
601 mp_msg(MSGT_HEADER,MSGL_ERR, MSGTR_MPDEMUX_AVIHDR_NotValidMPidxFile, index_file_load); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
602 goto gen_index; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
603 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
604 fread(&priv->idx_size, sizeof(priv->idx_size), 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
605 priv->idx=malloc(priv->idx_size*sizeof(AVIINDEXENTRY)); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
606 if (!priv->idx) { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
607 mp_msg(MSGT_HEADER,MSGL_ERR, MSGTR_MPDEMUX_AVIHDR_FailedMallocForIdxFile, index_file_load); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
608 priv->idx_size = 0; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
609 goto gen_index; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
610 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
611 |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
612 for (i=0; i<priv->idx_size;i++) { |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
613 AVIINDEXENTRY *idx; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
614 idx=&((AVIINDEXENTRY *)priv->idx)[i]; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
615 fread(idx, sizeof(AVIINDEXENTRY), 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
616 if (feof(fp)) { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
617 mp_msg(MSGT_HEADER,MSGL_ERR, MSGTR_MPDEMUX_AVIHDR_PrematureEOF, index_file_load); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
618 free(priv->idx); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
619 priv->idx_size = 0; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
620 goto gen_index; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
621 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
622 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
623 fclose(fp); |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
624 mp_msg(MSGT_HEADER,MSGL_INFO, MSGTR_MPDEMUX_AVIHDR_IdxFileLoaded, index_file_load); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
625 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
626 gen_index: |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
627 if(index_mode>=2 || (priv->idx_size==0 && index_mode==1)){ |
30010
5babc40c26de
Do not modify priv->idx_pos when regenerating the index, use a local
reimar
parents:
29288
diff
changeset
|
628 int idx_pos = 0; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
629 // build index for file: |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
630 stream_reset(demuxer->stream); |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
569
diff
changeset
|
631 stream_seek(demuxer->stream,demuxer->movi_start); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
632 |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
633 priv->idx_size=0; |
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
634 priv->idx=NULL; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
635 |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
636 while(1){ |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
637 int id; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
638 unsigned len; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
639 off_t skip; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
640 AVIINDEXENTRY* idx; |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
641 unsigned int c; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
642 demuxer->filepos=stream_tell(demuxer->stream); |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
643 if(demuxer->filepos>=demuxer->movi_end && demuxer->movi_start<demuxer->movi_end) break; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
644 id=stream_read_dword_le(demuxer->stream); |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
645 len=stream_read_dword_le(demuxer->stream); |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
646 if(id==mmioFOURCC('L','I','S','T') || id==mmioFOURCC('R', 'I', 'F', 'F')){ |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
647 id=stream_read_dword_le(demuxer->stream); // list or RIFF type |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
648 continue; |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
649 } |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
650 if(stream_eof(demuxer->stream)) break; |
1392 | 651 if(!id || avi_stream_id(id)==100) goto skip_chunk; // bad ID (or padding?) |
652 | |
30010
5babc40c26de
Do not modify priv->idx_pos when regenerating the index, use a local
reimar
parents:
29288
diff
changeset
|
653 if(idx_pos>=priv->idx_size){ |
1485
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
654 // priv->idx_size+=32; |
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
655 priv->idx_size+=1024; // +16kB |
b895f95e7657
AVI demuxer cleanups, fileformat-dependent stuff moved to priv_t
arpi
parents:
1456
diff
changeset
|
656 priv->idx=realloc(priv->idx,priv->idx_size*sizeof(AVIINDEXENTRY)); |
30010
5babc40c26de
Do not modify priv->idx_pos when regenerating the index, use a local
reimar
parents:
29288
diff
changeset
|
657 if(!priv->idx){idx_pos=0; break;} // error! |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
658 } |
30010
5babc40c26de
Do not modify priv->idx_pos when regenerating the index, use a local
reimar
parents:
29288
diff
changeset
|
659 idx=&((AVIINDEXENTRY *)priv->idx)[idx_pos++]; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
660 idx->ckid=id; |
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
661 idx->dwFlags=AVIIF_KEYFRAME; // FIXME |
12036 | 662 idx->dwFlags|=(demuxer->filepos>>16)&0xffff0000U; |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
663 idx->dwChunkOffset=(unsigned long)demuxer->filepos; |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
664 idx->dwChunkLength=len; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
665 |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
666 c=stream_read_dword(demuxer->stream); |
568 | 667 |
18050 | 668 if(!len) idx->dwFlags&=~AVIIF_KEYFRAME; |
669 | |
568 | 670 // Fix keyframes for DivX files: |
671 if(idxfix_divx) | |
672 if(avi_stream_id(id)==idxfix_videostream){ | |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
673 switch(idxfix_divx){ |
6275 | 674 case 3: c=stream_read_dword(demuxer->stream)<<5; //skip 32+5 bits for m$mpeg4v1 |
12036 | 675 case 1: if(c&0x40000000) idx->dwFlags&=~AVIIF_KEYFRAME;break; // divx 3 |
676 case 2: if(c==0x1B6) idx->dwFlags&=~AVIIF_KEYFRAME;break; // divx 4 | |
2598
a937f0024514
-idx fixes: support for divx4 and ignoring bad movi_end
arpi
parents:
2338
diff
changeset
|
677 } |
568 | 678 } |
3781 | 679 |
680 // update status line: | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
681 { static off_t lastpos; |
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
682 off_t pos; |
3781 | 683 off_t len=demuxer->movi_end-demuxer->movi_start; |
684 if(len){ | |
685 pos=100*(demuxer->filepos-demuxer->movi_start)/len; // % | |
686 } else { | |
687 pos=(demuxer->filepos-demuxer->movi_start)>>20; // MB | |
688 } | |
689 if(pos!=lastpos){ | |
690 lastpos=pos; | |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
691 mp_msg(MSGT_HEADER,MSGL_STATUS,MSGTR_MPDEMUX_AVIHDR_GeneratingIdx, |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
692 (unsigned long)pos, len?"%":"MB"); |
3781 | 693 } |
694 } | |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
695 mp_dbg(MSGT_HEADER,MSGL_DBG2,"%08X %08X %.4s %08X %X\n",(unsigned int)demuxer->filepos,id,(char *) &id,(int)c,(unsigned int) idx->dwFlags); |
568 | 696 #if 0 |
697 { unsigned char tmp[64]; | |
698 int i; | |
699 stream_read(demuxer->stream,tmp,64); | |
700 printf("%.4s",&id); | |
701 for(i=0;i<64;i++) printf(" %02X",tmp[i]); | |
702 printf("\n"); | |
703 } | |
704 #endif | |
1392 | 705 skip_chunk: |
6056
f980563afdbc
big (>2GB) AVI files support - patch by Wolfram Gloger <wg@malloc.de>
arpi
parents:
5933
diff
changeset
|
706 skip=(len+1)&(~1UL); // total bytes in this chunk |
568 | 707 stream_seek(demuxer->stream,8+demuxer->filepos+skip); |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
708 } |
30010
5babc40c26de
Do not modify priv->idx_pos when regenerating the index, use a local
reimar
parents:
29288
diff
changeset
|
709 priv->idx_size=idx_pos; |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
710 mp_msg(MSGT_HEADER,MSGL_INFO,MSGTR_MPDEMUX_AVIHDR_IdxGeneratedForHowManyChunks,priv->idx_size); |
17977
f70772d02eaa
Convert printfs in aviprint.c to mp_msg and give the information printing
diego
parents:
17932
diff
changeset
|
711 if( mp_msg_test(MSGT_HEADER,MSGL_DBG2) ) print_index(priv->idx,priv->idx_size,MSGL_DBG2); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
712 |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
713 /* Write generated index to a file */ |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
714 if (index_file_save) { |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
715 FILE *fp; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
716 unsigned int i; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
717 |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
718 if ((fp=fopen(index_file_save, "w")) == NULL) { |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
719 mp_msg(MSGT_HEADER,MSGL_ERR, MSGTR_MPDEMUX_AVIHDR_Failed2WriteIdxFile, index_file_save, strerror(errno)); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
720 return; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
721 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
722 fwrite("MPIDX1", 6, 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
723 fwrite(&priv->idx_size, sizeof(priv->idx_size), 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
724 for (i=0; i<priv->idx_size; i++) { |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
725 AVIINDEXENTRY *idx = &((AVIINDEXENTRY *)priv->idx)[i]; |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
726 fwrite(idx, sizeof(AVIINDEXENTRY), 1, fp); |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
727 } |
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
728 fclose(fp); |
16882
dfbe8cd0e081
libmpdemux translatables to help_mp part 1 / mp_msg calls / try 2
reynaldo
parents:
15738
diff
changeset
|
729 mp_msg(MSGT_HEADER,MSGL_INFO, MSGTR_MPDEMUX_AVIHDR_IdxFileSaved, index_file_save); |
11234
9767665d49e0
Saving and loading external index file. Patch by Jason Tackaberry <tack@auc.ca>
alex
parents:
8027
diff
changeset
|
730 } |
564
747759a4a28f
seeking in raw/broken avi files (rebuilding index chunk)
arpi_esp
parents:
433
diff
changeset
|
731 } |
1 | 732 } |