Mercurial > mplayer.hg
annotate libmpdemux/muxer_avi.c @ 12051:78884d076dd4
explicit option for AVI PRP header
author | henry |
---|---|
date | Sun, 21 Mar 2004 21:32:54 +0000 |
parents | d2d18129f8e1 |
children | cdf62dc6d6a0 |
rev | line source |
---|---|
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
1 #include <stdio.h> |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
2 #include <stdlib.h> |
2529 | 3 #include <string.h> |
8585 | 4 #include <inttypes.h> |
8591 | 5 #include <unistd.h> |
12036 | 6 #include <limits.h> |
2529 | 7 |
2555
66837325b929
config.h cleanup, few things added to steram/demuxer headers
arpi
parents:
2529
diff
changeset
|
8 #include "config.h" |
7149 | 9 #include "../version.h" |
2555
66837325b929
config.h cleanup, few things added to steram/demuxer headers
arpi
parents:
2529
diff
changeset
|
10 |
12036 | 11 #include "stream.h" |
12 #include "demuxer.h" | |
13 #include "stheader.h" | |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
14 |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
15 #include "wine/mmreg.h" |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
16 #include "wine/avifmt.h" |
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
17 #include "wine/vfw.h" |
6918 | 18 #include "bswap.h" |
587
8511095c5283
stage#1 completed: c files no more included from mplayer.c
arpi_esp
parents:
1
diff
changeset
|
19 |
8585 | 20 #include "muxer.h" |
6918 | 21 #include "aviheader.h" |
12036 | 22 #include "mp_msg.h" |
1 | 23 |
7145
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
24 extern char *info_name; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
25 extern char *info_artist; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
26 extern char *info_genre; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
27 extern char *info_subject; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
28 extern char *info_copyright; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
29 extern char *info_sourceform; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
30 extern char *info_comment; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
31 |
12036 | 32 /* #define ODML_CHUNKLEN 0x02000000 */ /* for testing purposes */ |
33 #define ODML_CHUNKLEN 0x40000000 | |
34 #define ODML_NOTKEYFRAME 0x80000000U | |
35 #define MOVIALIGN 0x00001000 | |
36 | |
12051 | 37 float avi_prp_aspect = -1.0; |
38 | |
12036 | 39 struct avi_odmlidx_entry { |
40 uint64_t ofs; | |
41 uint32_t len; | |
42 uint32_t flags; | |
43 }; | |
44 | |
45 struct avi_odmlsuperidx_entry { | |
46 uint64_t ofs; | |
47 uint32_t len; | |
48 uint32_t duration; | |
49 }; | |
50 | |
51 struct avi_stream_info { | |
52 int idxsize; | |
53 int idxpos; | |
54 int superidxpos; | |
55 int superidxsize; | |
56 struct avi_odmlidx_entry *idx; | |
57 struct avi_odmlsuperidx_entry *superidx; | |
58 }; | |
59 | |
8585 | 60 static muxer_stream_t* avifile_new_stream(muxer_t *muxer,int type){ |
12036 | 61 struct avi_stream_info *si; |
8585 | 62 muxer_stream_t* s; |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
63 if (!muxer) return NULL; |
8585 | 64 if(muxer->avih.dwStreams>=MUXER_MAX_STREAMS){ |
12036 | 65 mp_msg(MSGT_MUXER, MSGL_ERR, "Too many streams! increase MUXER_MAX_STREAMS !\n"); |
2529 | 66 return NULL; |
67 } | |
8585 | 68 s=malloc(sizeof(muxer_stream_t)); |
69 memset(s,0,sizeof(muxer_stream_t)); | |
2529 | 70 if(!s) return NULL; // no mem!? |
71 muxer->streams[muxer->avih.dwStreams]=s; | |
72 s->type=type; | |
73 s->id=muxer->avih.dwStreams; | |
74 s->timer=0.0; | |
2652 | 75 s->size=0; |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
76 s->muxer=muxer; |
12036 | 77 s->priv=si=malloc(sizeof(struct avi_stream_info)); |
78 memset(si,0,sizeof(struct avi_stream_info)); | |
79 si->idxsize=256; | |
80 si->idx=malloc(sizeof(struct avi_odmlidx_entry)*si->idxsize); | |
81 | |
2529 | 82 switch(type){ |
8585 | 83 case MUXER_TYPE_VIDEO: |
2529 | 84 s->ckid=mmioFOURCC(('0'+s->id/10),('0'+(s->id%10)),'d','c'); |
85 s->h.fccType=streamtypeVIDEO; | |
86 if(!muxer->def_v) muxer->def_v=s; | |
87 break; | |
8585 | 88 case MUXER_TYPE_AUDIO: |
2529 | 89 s->ckid=mmioFOURCC(('0'+s->id/10),('0'+(s->id%10)),'w','b'); |
90 s->h.fccType=streamtypeAUDIO; | |
91 break; | |
92 default: | |
12036 | 93 mp_msg(MSGT_MUXER, MSGL_WARN, "Warning! unknown stream type: %d\n",type); |
2529 | 94 return NULL; |
95 } | |
96 muxer->avih.dwStreams++; | |
97 return s; | |
98 } | |
1 | 99 |
2529 | 100 static void write_avi_chunk(FILE *f,unsigned int id,int len,void* data){ |
6918 | 101 int le_len = le2me_32(len); |
102 int le_id = le2me_32(id); | |
103 fwrite(&le_id,4,1,f); | |
104 fwrite(&le_len,4,1,f); | |
105 | |
1 | 106 if(len>0){ |
107 if(data){ | |
108 // DATA | |
109 fwrite(data,len,1,f); | |
110 if(len&1){ // padding | |
111 unsigned char zerobyte=0; | |
112 fwrite(&zerobyte,1,1,f); | |
113 } | |
114 } else { | |
115 // JUNK | |
116 char *avi_junk_data="[= MPlayer junk data! =]"; | |
117 if(len&1) ++len; // padding | |
118 while(len>0){ | |
119 int l=strlen(avi_junk_data); | |
120 if(l>len) l=len; | |
121 fwrite(avi_junk_data,l,1,f); | |
122 len-=l; | |
123 } | |
124 } | |
125 } | |
2529 | 126 } |
127 | |
12036 | 128 static void write_avi_list(FILE *f,unsigned int id,int len); |
129 static void avifile_write_index(muxer_t *muxer); | |
130 | |
131 static void avifile_odml_new_riff(muxer_t *muxer) | |
132 { | |
133 FILE *f = muxer->file; | |
134 uint32_t riff[3]; | |
135 | |
136 /* Pad to ODML_CHUNKLEN */ | |
137 write_avi_chunk(f,ckidAVIPADDING,ODML_CHUNKLEN - (ftello(f)%ODML_CHUNKLEN) - 8,NULL); | |
138 | |
139 /* RIFF/AVIX chunk */ | |
140 riff[0]=le2me_32(mmioFOURCC('R','I','F','F')); | |
141 riff[1]=0; | |
142 riff[2]=le2me_32(mmioFOURCC('A','V','I','X')); | |
143 fwrite(riff,12,1,f); | |
144 | |
145 write_avi_list(f,listtypeAVIMOVIE,0); | |
146 } | |
147 | |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
148 static void avifile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags){ |
12036 | 149 off_t pos; |
150 struct avi_stream_info *si = s->priv; | |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
151 muxer_t *muxer=s->muxer; |
12036 | 152 int isodml = muxer->file_end > ODML_CHUNKLEN ? 1 : 0; |
2529 | 153 |
12036 | 154 if (!isodml) { |
155 // add to the traditional index: | |
156 if(muxer->idx_pos>=muxer->idx_size){ | |
157 muxer->idx_size+=256; // 4kB | |
158 muxer->idx=realloc(muxer->idx,16*muxer->idx_size); | |
159 } | |
160 muxer->idx[muxer->idx_pos].ckid=s->ckid; | |
161 muxer->idx[muxer->idx_pos].dwFlags=flags; // keyframe? | |
162 muxer->idx[muxer->idx_pos].dwChunkOffset=ftello(muxer->file)-(muxer->movi_start-4); | |
163 muxer->idx[muxer->idx_pos].dwChunkLength=len; | |
164 ++muxer->idx_pos; | |
165 } | |
166 | |
167 // add to odml index | |
168 if(si->idxpos>=si->idxsize){ | |
169 si->idxsize+=256; | |
170 si->idx=realloc(si->idx,sizeof(*si->idx)*si->idxsize); | |
2529 | 171 } |
12036 | 172 si->idx[si->idxpos].flags=(flags&AVIIF_KEYFRAME)?0:ODML_NOTKEYFRAME; |
173 si->idx[si->idxpos].ofs=ftello(muxer->file); | |
174 si->idx[si->idxpos].len=len; | |
175 ++si->idxpos; | |
176 | |
177 pos = muxer->file_end; | |
178 if (pos < ODML_CHUNKLEN && | |
179 pos + 16*muxer->idx_pos + len + 8 > ODML_CHUNKLEN) { | |
180 | |
181 avifile_write_index(muxer); | |
182 avifile_odml_new_riff(muxer); | |
183 | |
184 pos = muxer->file_end = ftello(muxer->file); | |
185 } | |
186 if (pos % ODML_CHUNKLEN + len + 8 > ODML_CHUNKLEN) { | |
187 avifile_odml_new_riff(muxer); | |
188 muxer->file_end = ftello(muxer->file); | |
189 } | |
2529 | 190 |
191 // write out the chunk: | |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
192 write_avi_chunk(muxer->file,s->ckid,len,s->buffer); /* unsigned char */ |
6918 | 193 |
2529 | 194 // alter counters: |
12036 | 195 if (len > s->h.dwSuggestedBufferSize){ |
196 s->h.dwSuggestedBufferSize = len; | |
197 } | |
2529 | 198 if(s->h.dwSampleSize){ |
199 // CBR | |
200 s->h.dwLength+=len/s->h.dwSampleSize; | |
12036 | 201 if(len%s->h.dwSampleSize) mp_msg(MSGT_MUXER, MSGL_WARN, "Warning! len isn't divisable by samplesize!\n"); |
2529 | 202 } else { |
203 // VBR | |
204 s->h.dwLength++; | |
205 } | |
206 s->timer=(double)s->h.dwLength*s->h.dwScale/s->h.dwRate; | |
2652 | 207 s->size+=len; |
8585 | 208 if((unsigned int)len>s->h.dwSuggestedBufferSize) s->h.dwSuggestedBufferSize=len; |
1 | 209 |
12036 | 210 muxer->file_end += len + 8; |
1 | 211 } |
212 | |
2529 | 213 static void write_avi_list(FILE *f,unsigned int id,int len){ |
1 | 214 unsigned int list_id=FOURCC_LIST; |
6918 | 215 int le_len; |
216 int le_id; | |
1 | 217 len+=4; // list fix |
6918 | 218 list_id = le2me_32(list_id); |
219 le_len = le2me_32(len); | |
220 le_id = le2me_32(id); | |
1 | 221 fwrite(&list_id,4,1,f); |
6918 | 222 fwrite(&le_len,4,1,f); |
223 fwrite(&le_id,4,1,f); | |
1 | 224 } |
225 | |
11374 | 226 #define WFSIZE(wf) (sizeof(WAVEFORMATEX)+(wf)->cbSize) |
2635
c1e24e01601b
fixed AVI header creation - now should be compatible with NaNdub
arpi
parents:
2555
diff
changeset
|
227 |
12051 | 228 static unsigned int avi_aspect(float aspect) |
12036 | 229 { |
230 if (aspect >= 3.99/3.0 && | |
231 aspect <= 4.01/3.0) return MAKE_AVI_ASPECT(4,3); | |
232 if (aspect >= 15.99/9.0 && | |
233 aspect <= 16.01/9.0) return MAKE_AVI_ASPECT(16,9); | |
234 if (aspect >= 0.99 && | |
235 aspect <= 1.01) return MAKE_AVI_ASPECT(1,1); | |
236 if (aspect<1.0) return MAKE_AVI_ASPECT((int)(aspect*8192),8192); | |
237 return MAKE_AVI_ASPECT(8192,(int)(8192/aspect)); | |
238 } | |
239 | |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
240 static void avifile_write_header(muxer_t *muxer){ |
8585 | 241 uint32_t riff[3]; |
12036 | 242 unsigned int dmlh[1]; |
8585 | 243 unsigned int i; |
2529 | 244 unsigned int hdrsize; |
8585 | 245 muxer_info_t info[16]; |
12036 | 246 FILE *f = muxer->file; |
247 VideoPropHeader vprp; | |
12051 | 248 |
12036 | 249 off_t pos; |
250 int isodml = muxer->file_end > ODML_CHUNKLEN ? 1 : 0; | |
251 | |
252 if (isodml) { | |
253 for (pos = 0; pos < muxer->file_end; pos += ODML_CHUNKLEN) { | |
254 unsigned int rifflen, movilen; | |
255 | |
256 /* fixup RIFF length */ | |
257 if (muxer->file_end - pos > ODML_CHUNKLEN) { | |
258 rifflen = le2me_32(ODML_CHUNKLEN - 8); | |
259 movilen = le2me_32(ODML_CHUNKLEN - 20); | |
260 } else { | |
261 rifflen = le2me_32(muxer->file_end - pos - 8); | |
262 movilen = le2me_32(muxer->file_end - pos - 20); | |
263 } | |
264 fseeko(f, pos + 4, SEEK_SET); | |
265 fwrite(&rifflen,4,1,f); | |
7145
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
266 |
12036 | 267 /* fixup movi length */ |
268 if (pos > 0) { | |
269 fseeko(f, pos + 16, SEEK_SET); | |
270 fwrite(&movilen,4,1,f); | |
271 } | |
272 } | |
273 | |
274 fseeko(f, 12, SEEK_SET); | |
275 } else { | |
276 // RIFF header: | |
277 riff[0]=mmioFOURCC('R','I','F','F'); | |
278 riff[1]=muxer->file_end-2*sizeof(unsigned int); // filesize | |
279 riff[2]=formtypeAVI; // 'AVI ' | |
280 riff[0]=le2me_32(riff[0]); | |
281 riff[1]=le2me_32(riff[1]); | |
282 riff[2]=le2me_32(riff[2]); | |
283 fwrite(&riff,12,1,f); | |
284 } | |
285 | |
2529 | 286 // update AVI header: |
287 if(muxer->def_v){ | |
12036 | 288 int i; |
2529 | 289 muxer->avih.dwMicroSecPerFrame=1000000.0*muxer->def_v->h.dwScale/muxer->def_v->h.dwRate; |
2635
c1e24e01601b
fixed AVI header creation - now should be compatible with NaNdub
arpi
parents:
2555
diff
changeset
|
290 // muxer->avih.dwMaxBytesPerSec=1000000; // dummy!!!!! FIXME |
c1e24e01601b
fixed AVI header creation - now should be compatible with NaNdub
arpi
parents:
2555
diff
changeset
|
291 // muxer->avih.dwPaddingGranularity=2; // ??? |
2529 | 292 muxer->avih.dwFlags|=AVIF_ISINTERLEAVED|AVIF_TRUSTCKTYPE; |
12036 | 293 muxer->avih.dwTotalFrames=0; |
294 for (i=0; i<muxer->idx_pos; i++) { | |
295 if (muxer->idx[i].ckid == muxer->def_v->ckid) | |
296 muxer->avih.dwTotalFrames++; | |
297 } | |
2635
c1e24e01601b
fixed AVI header creation - now should be compatible with NaNdub
arpi
parents:
2555
diff
changeset
|
298 // muxer->avih.dwSuggestedBufferSize=muxer->def_v->h.dwSuggestedBufferSize; |
2529 | 299 muxer->avih.dwWidth=muxer->def_v->bih->biWidth; |
300 muxer->avih.dwHeight=muxer->def_v->bih->biHeight; | |
301 } | |
302 | |
1 | 303 // AVI header: |
2529 | 304 hdrsize=sizeof(muxer->avih)+8; |
12036 | 305 if (isodml) hdrsize+=sizeof(dmlh)+20; // dmlh |
2529 | 306 // calc total header size: |
307 for(i=0;i<muxer->avih.dwStreams;i++){ | |
12036 | 308 muxer_stream_t *s = muxer->streams[i]; |
309 struct avi_stream_info *si = s->priv; | |
310 | |
2529 | 311 hdrsize+=12; // LIST |
312 hdrsize+=sizeof(muxer->streams[i]->h)+8; // strh | |
313 switch(muxer->streams[i]->type){ | |
8585 | 314 case MUXER_TYPE_VIDEO: |
2529 | 315 hdrsize+=muxer->streams[i]->bih->biSize+8; // strf |
12051 | 316 if (avi_prp_aspect > 0) { |
317 hdrsize+=8+4*(9+8*1); // vprp | |
318 } | |
2529 | 319 break; |
8585 | 320 case MUXER_TYPE_AUDIO: |
2635
c1e24e01601b
fixed AVI header creation - now should be compatible with NaNdub
arpi
parents:
2555
diff
changeset
|
321 hdrsize+=WFSIZE(muxer->streams[i]->wf)+8; // strf |
2529 | 322 break; |
323 } | |
12036 | 324 if (isodml && si && si->superidx && si->superidxsize) { |
325 hdrsize += 32 + 16*si->superidxsize; //indx | |
326 } | |
2529 | 327 } |
328 write_avi_list(f,listtypeAVIHEADER,hdrsize); | |
6918 | 329 |
330 le2me_MainAVIHeader(&muxer->avih); | |
331 write_avi_chunk(f,ckidAVIMAINHDR,sizeof(muxer->avih),&muxer->avih); /* MainAVIHeader */ | |
332 le2me_MainAVIHeader(&muxer->avih); | |
2529 | 333 |
334 // stream headers: | |
335 for(i=0;i<muxer->avih.dwStreams;i++){ | |
12036 | 336 muxer_stream_t *s = muxer->streams[i]; |
337 struct avi_stream_info *si = s->priv; | |
338 unsigned int idxhdr[8]; | |
339 int j,n; | |
340 | |
341 hdrsize=sizeof(s->h)+8; // strh | |
342 if (si && si->superidx && si->superidxsize) { | |
343 hdrsize += 32 + 16*si->superidxsize; //indx | |
344 } | |
345 switch(s->type){ | |
8585 | 346 case MUXER_TYPE_VIDEO: |
12036 | 347 hdrsize+=s->bih->biSize+8; // strf |
348 s->h.fccHandler = s->bih->biCompression; | |
349 s->h.rcFrame.right = s->bih->biWidth; | |
350 s->h.rcFrame.bottom = s->bih->biHeight; | |
12051 | 351 if (avi_prp_aspect > 0) { |
352 // fill out vprp info | |
353 memset(&vprp, 0, sizeof(vprp)); | |
354 vprp.dwVerticalRefreshRate = (s->h.dwRate+s->h.dwScale-1)/s->h.dwScale; | |
355 vprp.dwHTotalInT = muxer->avih.dwWidth; | |
356 vprp.dwVTotalInLines = muxer->avih.dwHeight; | |
357 vprp.dwFrameAspectRatio = avi_aspect(avi_prp_aspect); | |
358 vprp.dwFrameWidthInPixels = muxer->avih.dwWidth; | |
359 vprp.dwFrameHeightInLines = muxer->avih.dwHeight; | |
360 vprp.nbFieldPerFrame = 1; | |
361 vprp.FieldInfo[0].CompressedBMHeight = muxer->avih.dwHeight; | |
362 vprp.FieldInfo[0].CompressedBMWidth = muxer->avih.dwWidth; | |
363 vprp.FieldInfo[0].ValidBMHeight = muxer->avih.dwHeight; | |
364 vprp.FieldInfo[0].ValidBMWidth = muxer->avih.dwWidth; | |
365 hdrsize+=8+4*(9+8*1); // vprp | |
366 } | |
2529 | 367 break; |
8585 | 368 case MUXER_TYPE_AUDIO: |
12036 | 369 hdrsize+=WFSIZE(s->wf)+8; // strf |
370 s->h.fccHandler = s->wf->wFormatTag; | |
2529 | 371 break; |
372 } | |
12036 | 373 |
2529 | 374 write_avi_list(f,listtypeSTREAMHEADER,hdrsize); |
12036 | 375 le2me_AVIStreamHeader(&s->h); |
376 write_avi_chunk(f,ckidSTREAMHEADER,sizeof(s->h),&s->h); /* AVISTreamHeader */ // strh | |
377 le2me_AVIStreamHeader(&s->h); | |
6918 | 378 |
12036 | 379 switch(s->type){ |
8585 | 380 case MUXER_TYPE_VIDEO: |
6918 | 381 { |
12036 | 382 int biSize=s->bih->biSize; |
383 le2me_BITMAPINFOHEADER(s->bih); | |
384 write_avi_chunk(f,ckidSTREAMFORMAT,biSize,s->bih); /* BITMAPINFOHEADER */ | |
12051 | 385 if (avi_prp_aspect > 0) { |
386 le2me_BITMAPINFOHEADER(s->bih); | |
387 le2me_VideoPropHeader(&vprp); | |
388 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[0]); | |
389 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[1]); | |
390 write_avi_chunk(f,mmioFOURCC('v','p','r','p'), | |
391 sizeof(VideoPropHeader) - | |
392 sizeof(VIDEO_FIELD_DESC)*(2-vprp.nbFieldPerFrame), | |
393 &vprp); /* Video Properties Header */ | |
394 } | |
6918 | 395 } |
2529 | 396 break; |
8585 | 397 case MUXER_TYPE_AUDIO: |
6918 | 398 { |
12036 | 399 int wfsize = WFSIZE(s->wf); |
400 le2me_WAVEFORMATEX(s->wf); | |
401 write_avi_chunk(f,ckidSTREAMFORMAT,wfsize,s->wf); /* WAVEFORMATEX */ | |
402 le2me_WAVEFORMATEX(s->wf); | |
6918 | 403 } |
2529 | 404 break; |
405 } | |
12036 | 406 if (isodml && si && si->superidx && si->superidxsize) { |
407 n = si->superidxsize; | |
408 | |
409 idxhdr[0] = le2me_32(mmioFOURCC('i', 'n', 'd', 'x')); | |
410 idxhdr[1] = le2me_32(24 + 16*n); | |
411 idxhdr[2] = le2me_32(0x00000004); | |
412 idxhdr[3] = le2me_32(si->superidxpos); | |
413 idxhdr[4] = le2me_32(s->ckid); | |
414 idxhdr[5] = 0; | |
415 idxhdr[6] = 0; | |
416 idxhdr[7] = 0; | |
417 | |
418 fwrite(idxhdr,sizeof(idxhdr),1,f); | |
419 for (j=0; j<n; j++) { | |
420 struct avi_odmlsuperidx_entry *entry = &si->superidx[j]; | |
421 unsigned int data[4]; | |
422 data[0] = le2me_32(entry->ofs); | |
423 data[1] = le2me_32(entry->ofs >> 32); | |
424 data[2] = le2me_32(entry->len); | |
425 data[3] = le2me_32(entry->duration); | |
426 fwrite(data,sizeof(data),1,f); | |
427 } | |
428 } | |
429 } | |
430 | |
431 // ODML | |
432 if (isodml) { | |
433 memset(dmlh, 0, sizeof(dmlh)); | |
434 dmlh[0] = le2me_32(muxer->avih.dwTotalFrames); | |
435 write_avi_list(f,mmioFOURCC('o','d','m','l'),sizeof(dmlh)+8); | |
436 write_avi_chunk(f,mmioFOURCC('d','m','l','h'),sizeof(dmlh),dmlh); | |
2529 | 437 } |
438 | |
7145
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
439 // ============= INFO =============== |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
440 // always include software info |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
441 info[0].id=mmioFOURCC('I','S','F','T'); // Software: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
442 info[0].text="MEncoder " VERSION; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
443 // include any optional strings |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
444 i=1; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
445 if(info_name!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
446 info[i].id=mmioFOURCC('I','N','A','M'); // Name: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
447 info[i++].text=info_name; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
448 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
449 if(info_artist!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
450 info[i].id=mmioFOURCC('I','A','R','T'); // Artist: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
451 info[i++].text=info_artist; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
452 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
453 if(info_genre!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
454 info[i].id=mmioFOURCC('I','G','N','R'); // Genre: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
455 info[i++].text=info_genre; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
456 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
457 if(info_subject!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
458 info[i].id=mmioFOURCC('I','S','B','J'); // Subject: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
459 info[i++].text=info_subject; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
460 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
461 if(info_copyright!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
462 info[i].id=mmioFOURCC('I','C','O','P'); // Copyright: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
463 info[i++].text=info_copyright; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
464 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
465 if(info_sourceform!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
466 info[i].id=mmioFOURCC('I','S','R','F'); // Source Form: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
467 info[i++].text=info_sourceform; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
468 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
469 if(info_comment!=NULL){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
470 info[i].id=mmioFOURCC('I','C','M','T'); // Comment: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
471 info[i++].text=info_comment; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
472 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
473 info[i].id=0; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
474 |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
475 hdrsize=0; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
476 // calc info size: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
477 for(i=0;info[i].id!=0;i++) if(info[i].text){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
478 size_t sz=strlen(info[i].text)+1; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
479 hdrsize+=sz+8+sz%2; |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
480 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
481 // write infos: |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
482 if (hdrsize!=0){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
483 write_avi_list(f,mmioFOURCC('I','N','F','O'),hdrsize); |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
484 for(i=0;info[i].id!=0;i++) if(info[i].text){ |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
485 write_avi_chunk(f,info[i].id,strlen(info[i].text)+1,info[i].text); |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
486 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
487 } |
3854945aefbb
new mencoder option -info, to store copyright, title, encoder version etc in AVI
arpi
parents:
7144
diff
changeset
|
488 |
2529 | 489 // JUNK: |
12036 | 490 write_avi_chunk(f,ckidAVIPADDING,MOVIALIGN-(ftello(f)%MOVIALIGN)-8,NULL); /* junk */ |
491 if (!isodml) { | |
492 // 'movi' header: | |
493 write_avi_list(f,listtypeAVIMOVIE,muxer->movi_end-ftello(f)-12); | |
494 } else { | |
495 if (ftello(f) != MOVIALIGN) { | |
496 mp_msg(MSGT_MUXER, MSGL_ERR, "Opendml superindex is too big for reserved space!\n"); | |
497 mp_msg(MSGT_MUXER, MSGL_ERR, "Expected filepos %d, real filepos %d, missing space %d\n", MOVIALIGN, ftell(muxer->file), ftell(muxer->file)-MOVIALIGN); | |
12037 | 498 mp_msg(MSGT_MUXER, MSGL_ERR, "Try increasing MOVIALIGN in libmpdemux/muxer_avi.c\n"); |
12036 | 499 } |
500 write_avi_list(f,listtypeAVIMOVIE,muxer->movi_end-ftello(f)-12); | |
501 } | |
502 muxer->movi_start=ftello(muxer->file); | |
503 } | |
504 | |
505 static void avifile_odml_write_index(muxer_t *muxer){ | |
506 muxer_stream_t* s; | |
507 struct avi_stream_info *si; | |
508 int i; | |
509 | |
510 for (i=0; i<muxer->avih.dwStreams; i++) { | |
511 int j,k,n,idxpos,len,last,entries_per_subidx; | |
512 unsigned int idxhdr[8]; | |
513 s = muxer->streams[i]; | |
514 si = s->priv; | |
515 | |
516 /* | |
517 * According to Avery Lee MSMP wants the subidx chunks to have the same size. | |
518 * | |
519 * So this code figures out how many entries we can put into | |
520 * an ix?? chunk, so that each ix?? chunk has the same size and the offsets | |
521 * don't overflow (Using ODML_CHUNKLEN for that is a bit more restrictive | |
522 * than it has to be though). | |
523 */ | |
524 | |
525 len = 0; | |
526 n = 0; | |
527 entries_per_subidx = INT_MAX; | |
528 do { | |
529 off_t start = si->idx[0].ofs; | |
530 last = entries_per_subidx; | |
531 for (j=0; j<si->idxpos; j++) { | |
532 len = si->idx[j].ofs - start; | |
533 if(len >= ODML_CHUNKLEN || n >= entries_per_subidx) { | |
534 if (entries_per_subidx > n) { | |
535 entries_per_subidx = n; | |
536 } | |
537 start = si->idx[j].ofs; | |
538 len = 0; | |
539 n = 0; | |
540 } | |
541 n++; | |
542 } | |
543 } while (last != entries_per_subidx); | |
544 | |
545 si->superidxpos = (si->idxpos+entries_per_subidx-1) / entries_per_subidx; | |
546 | |
547 mp_msg(MSGT_MUXER, MSGL_V, "ODML: Stream %d: Using %d entries per subidx, %d entries in superidx\n", | |
548 i, entries_per_subidx, si->superidxpos); | |
549 | |
550 si->superidxsize = si->superidxpos; | |
551 si->superidx = malloc(sizeof(*si->superidx) * si->superidxsize); | |
552 memset(si->superidx, 0, sizeof(*si->superidx) * si->superidxsize); | |
553 | |
554 idxpos = 0; | |
555 for (j=0; j<si->superidxpos; j++) { | |
556 off_t start = si->idx[idxpos].ofs; | |
557 int duration; | |
558 | |
559 duration = 0; | |
560 for (k=0; k<entries_per_subidx && idxpos+k<si->idxpos; k++) { | |
561 duration += s->h.dwSampleSize ? si->idx[idxpos+k].len/s->h.dwSampleSize : 1; | |
562 } | |
563 | |
564 idxhdr[0] = le2me_32((s->ckid << 16) | mmioFOURCC('i', 'x', 0, 0)); | |
565 idxhdr[1] = le2me_32(24 + 8*k); | |
566 idxhdr[2] = le2me_32(0x01000002); | |
567 idxhdr[3] = le2me_32(k); | |
568 idxhdr[4] = le2me_32(s->ckid); | |
569 idxhdr[5] = le2me_32(start + 8); | |
570 idxhdr[6] = le2me_32((start + 8)>> 32); | |
571 idxhdr[7] = 0; /* unused */ | |
572 | |
573 si->superidx[j].len = 32 + 8*k; | |
574 si->superidx[j].ofs = ftello(muxer->file); | |
575 si->superidx[j].duration = duration; | |
576 | |
577 fwrite(idxhdr,sizeof(idxhdr),1,muxer->file); | |
578 for (k=0; k<entries_per_subidx && idxpos<si->idxpos; k++) { | |
579 unsigned int entry[2]; | |
580 entry[0] = le2me_32(si->idx[idxpos].ofs - start); | |
581 entry[1] = le2me_32(si->idx[idxpos].len | si->idx[idxpos].flags); | |
582 idxpos++; | |
583 fwrite(entry,sizeof(entry),1,muxer->file); | |
584 } | |
585 } | |
586 } | |
587 muxer->file_end=ftello(muxer->file); | |
1 | 588 } |
589 | |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
590 static void avifile_write_index(muxer_t *muxer){ |
12036 | 591 |
592 if(muxer->file_end > ODML_CHUNKLEN && | |
593 muxer->idx && muxer->idx_pos>0) { | |
594 avifile_odml_write_index(muxer); | |
595 return; | |
596 } | |
597 | |
598 muxer->movi_end=ftello(muxer->file); | |
2529 | 599 if(muxer->idx && muxer->idx_pos>0){ |
6918 | 600 int i; |
2529 | 601 // fixup index entries: |
602 // for(i=0;i<muxer->idx_pos;i++) muxer->idx[i].dwChunkOffset-=muxer->movi_start-4; | |
603 // write index chunk: | |
6918 | 604 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i])); |
9007
12fc55eb3373
Cleanup of the muxer API, func parameters muxer & muxer_f eliminated.
arpi
parents:
8591
diff
changeset
|
605 write_avi_chunk(muxer->file,ckidAVINEWINDEX,16*muxer->idx_pos,muxer->idx); /* AVIINDEXENTRY */ |
6918 | 606 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i])); |
2529 | 607 muxer->avih.dwFlags|=AVIF_HASINDEX; |
608 } | |
12036 | 609 muxer->file_end=ftello(muxer->file); |
1 | 610 } |
611 | |
8585 | 612 void muxer_init_muxer_avi(muxer_t *muxer){ |
613 muxer->cont_new_stream = &avifile_new_stream; | |
614 muxer->cont_write_chunk = &avifile_write_chunk; | |
615 muxer->cont_write_header = &avifile_write_header; | |
616 muxer->cont_write_index = &avifile_write_index; | |
617 } |