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