1 /*
2 * This file is part of MPlayer.
3 *
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <inttypes.h>
23 #include <unistd.h>
24 #include <limits.h>
25
26 #include "config.h"
27 #include "mencoder.h"
28 #include "mpcommon.h"
29 #include "stream/stream.h"
30 #include "demuxer.h"
31 #include "stheader.h"
32 #include "muxer_avi.h"
33 #include "muxer.h"
34 #include "aviheader.h"
35 #include "ms_hdr.h"
36 #include "mp_msg.h"
37 #include "help_mp.h"
38
39 /* #define ODML_CHUNKLEN 0x02000000 */ /* for testing purposes */
40 #define ODML_CHUNKLEN 0x40000000
41 #define ODML_NOTKEYFRAME 0x80000000U
42 #define MOVIALIGN 0x00001000
43
44 float avi_aspect_override = -1.0;
45 int write_odml = 1;
46
47 struct avi_odmlidx_entry {
48 uint64_t ofs;
49 uint32_t len;
50 uint32_t flags;
51 };
52
53 struct avi_odmlsuperidx_entry {
54 uint64_t ofs;
55 uint32_t len;
56 uint32_t duration;
57 };
58
59 struct avi_stream_info {
60 int idxsize;
61 int idxpos;
62 int superidxpos;
63 int superidxsize;
64 int riffofspos;
65 int riffofssize;
66 off_t *riffofs;
67 struct avi_odmlidx_entry *idx;
68 struct avi_odmlsuperidx_entry *superidx;
69 };
70
avi_aspect(muxer_stream_t * vstream)71 static unsigned int avi_aspect(muxer_stream_t *vstream)
72 {
73 int x,y;
74 float aspect = vstream->aspect;
75
76 if (avi_aspect_override > 0.0) {
77 aspect = avi_aspect_override;
78 }
79
80 if (aspect <= 0.0) return 0;
81
82 if (aspect > 15.99/9.0 && aspect < 16.01/9.0) {
83 return MAKE_AVI_ASPECT(16, 9);
84 }
85 if (aspect > 3.99/3.0 && aspect < 4.01/3.0) {
86 return MAKE_AVI_ASPECT(4, 3);
87 }
88
89 if (aspect >= 1.0) {
90 x = 16384;
91 y = (float)x / aspect;
92 } else {
93 y = 16384;
94 x = (float)y * aspect;
95 }
96
97 return MAKE_AVI_ASPECT(x, y);
98 }
99
avifile_new_stream(muxer_t * muxer,int type)100 static muxer_stream_t* avifile_new_stream(muxer_t *muxer,int type){
101 struct avi_stream_info *si;
102 muxer_stream_t* s;
103 if (!muxer) return NULL;
104 if(muxer->avih.dwStreams>=MUXER_MAX_STREAMS){
105 mp_msg(MSGT_MUXER, MSGL_ERR, "Too many streams! increase MUXER_MAX_STREAMS !\n");
106 return NULL;
107 }
108 s=malloc(sizeof(muxer_stream_t));
109 memset(s,0,sizeof(muxer_stream_t));
110 if(!s) return NULL; // no mem!?
111 muxer->streams[muxer->avih.dwStreams]=s;
112 s->type=type;
113 s->id=muxer->avih.dwStreams;
114 s->timer=0.0;
115 s->size=0;
116 s->muxer=muxer;
117 s->priv=si=malloc(sizeof(struct avi_stream_info));
118 memset(si,0,sizeof(struct avi_stream_info));
119 si->idxsize=256;
120 si->idx=calloc(si->idxsize, sizeof(struct avi_odmlidx_entry));
121 si->riffofssize=16;
122 si->riffofs=calloc((si->riffofssize+1), sizeof(off_t));
123
124 switch(type){
125 case MUXER_TYPE_VIDEO:
126 s->ckid=mmioFOURCC(('0'+s->id/10),('0'+(s->id%10)),'d','c');
127 s->h.fccType=streamtypeVIDEO;
128 if(!muxer->def_v) muxer->def_v=s;
129 break;
130 case MUXER_TYPE_AUDIO:
131 s->ckid=mmioFOURCC(('0'+s->id/10),('0'+(s->id%10)),'w','b');
132 s->h.fccType=streamtypeAUDIO;
133 break;
134 default:
135 mp_msg(MSGT_MUXER, MSGL_WARN, "Warning! unknown stream type: %d\n",type);
136 return NULL;
137 }
138 muxer->avih.dwStreams++;
139 return s;
140 }
141
write_avi_chunk(stream_t * stream,unsigned int id,int len,void * data)142 static void write_avi_chunk(stream_t *stream,unsigned int id,int len,void* data){
143 int le_len = le2me_32(len);
144 int le_id = le2me_32(id);
145 stream_write_buffer(stream, &le_id, 4);
146 stream_write_buffer(stream, &le_len, 4);
147
148 if(len>0){
149 if(data){
150 // DATA
151 stream_write_buffer(stream, data, len);
152 if(len&1){ // padding
153 unsigned char zerobyte=0;
154 stream_write_buffer(stream, &zerobyte, 1);
155 }
156 } else {
157 // JUNK
158 char *avi_junk_data="[= MPlayer junk data! =]";
159 if(len&1) ++len; // padding
160 while(len>0){
161 int l=strlen(avi_junk_data);
162 if(l>len) l=len;
163 stream_write_buffer(stream, avi_junk_data, l);
164 len-=l;
165 }
166 }
167 }
168 }
169
write_avi_list(stream_t * stream,unsigned int id,int len)170 static void write_avi_list(stream_t *stream, unsigned int id, int len)
171 {
172 unsigned int list_id = mmioFOURCC('L', 'I', 'S', 'T');
173 int le_len;
174 int le_id;
175 len += 4; // list fix
176 list_id = le2me_32(list_id);
177 le_len = le2me_32(len);
178 le_id = le2me_32(id);
179 stream_write_buffer(stream, &list_id, 4);
180 stream_write_buffer(stream, &le_len, 4);
181 stream_write_buffer(stream, &le_id, 4);
182 }
183
avifile_odml_new_riff(muxer_t * muxer)184 static void avifile_odml_new_riff(muxer_t *muxer)
185 {
186 struct avi_stream_info *vsi = muxer->def_v->priv;
187 uint32_t riff[3];
188
189 mp_msg(MSGT_MUXER, MSGL_INFO, "ODML: Starting new RIFF chunk at %dMB.\n", (int)(muxer->file_end/1024/1024));
190
191 vsi->riffofspos++;
192 if (vsi->riffofspos>=vsi->riffofssize) {
193 vsi->riffofssize+=16;
194 vsi->riffofs=realloc_struct(vsi->riffofs,(vsi->riffofssize+1),sizeof(off_t));
195 }
196 vsi->riffofs[vsi->riffofspos] = stream_tell(muxer->stream);
197
198 /* RIFF/AVIX chunk */
199 riff[0]=le2me_32(mmioFOURCC('R','I','F','F'));
200 riff[1]=0;
201 riff[2]=le2me_32(mmioFOURCC('A','V','I','X'));
202 stream_write_buffer(muxer->stream, riff, 12);
203
204 write_avi_list(muxer->stream,listtypeAVIMOVIE,0);
205
206 muxer->file_end = stream_tell(muxer->stream);
207 }
208
209 #define WFSIZE(wf) (sizeof(*wf)+(wf)->cbSize)
210
avifile_write_header(muxer_t * muxer)211 static void avifile_write_header(muxer_t *muxer){
212 uint32_t riff[3];
213 unsigned int dmlh[1];
214 unsigned int i;
215 unsigned int hdrsize;
216 muxer_info_t info[16];
217 VideoPropHeader vprp;
218 uint32_t aspect = avi_aspect(muxer->def_v);
219 struct avi_stream_info *vsi = muxer->def_v->priv;
220 int isodml = vsi->riffofspos > 0;
221
222 mp_msg(MSGT_MUXER, MSGL_INFO, MSGTR_WritingHeader);
223 if (aspect == 0) {
224 mp_msg(MSGT_MUXER, MSGL_INFO, "ODML: Aspect information not (yet?) available or unspecified, not writing vprp header.\n");
225 } else {
226 mp_msg(MSGT_MUXER, MSGL_INFO, "ODML: vprp aspect is %d:%d.\n", aspect >> 16, aspect & 0xffff);
227 }
228
229 /* deal with stream delays */
230 for (i = 0; i < MUXER_MAX_STREAMS && muxer->streams[i]; ++i) {
231 muxer_stream_t *s = muxer->streams[i];
232 if (s->type == MUXER_TYPE_AUDIO && muxer->audio_delay_fix > 0.0) {
233 s->h.dwStart = muxer->audio_delay_fix * s->h.dwRate/s->h.dwScale + 0.5;
234 mp_msg(MSGT_MUXER, MSGL_INFO, MSGTR_SettingAudioDelay, (float)s->h.dwStart * s->h.dwScale/s->h.dwRate);
235 }
236 if (s->type == MUXER_TYPE_VIDEO && muxer->audio_delay_fix < 0.0) {
237 s->h.dwStart = -muxer->audio_delay_fix * s->h.dwRate/s->h.dwScale + 0.5;
238 mp_msg(MSGT_MUXER, MSGL_INFO, MSGTR_SettingVideoDelay, (float)s->h.dwStart * s->h.dwScale/s->h.dwRate);
239 }
240 }
241
242 if (isodml) {
243 unsigned int rifflen, movilen;
244 int i;
245
246 vsi->riffofs[vsi->riffofspos+1] = muxer->file_end;
247
248 /* fixup RIFF lengths */
249 for (i=0; i<=vsi->riffofspos; i++) {
250 rifflen = vsi->riffofs[i+1] - vsi->riffofs[i] - 8;
251 movilen = le2me_32(rifflen - 12);
252 rifflen = le2me_32(rifflen);
253 stream_seek(muxer->stream, vsi->riffofs[i]+4);
254 stream_write_buffer(muxer->stream,&rifflen,4);
255
256 /* fixup movi length */
257 if (i > 0) {
258 stream_seek(muxer->stream, vsi->riffofs[i]+16);
259 stream_write_buffer(muxer->stream,&movilen,4);
260 }
261 }
262
263 stream_seek(muxer->stream, 12);
264 } else {
265 // RIFF header:
266 riff[0]=mmioFOURCC('R','I','F','F');
267 riff[1]=muxer->file_end-2*sizeof(unsigned int); // filesize
268 riff[2]=formtypeAVI; // 'AVI '
269 riff[0]=le2me_32(riff[0]);
270 riff[1]=le2me_32(riff[1]);
271 riff[2]=le2me_32(riff[2]);
272 stream_write_buffer(muxer->stream,&riff,12);
273 }
274
275 // update AVI header:
276 {
277 int i;
278 muxer->avih.dwMicroSecPerFrame=1000000.0*muxer->def_v->h.dwScale/muxer->def_v->h.dwRate;
279 // muxer->avih.dwMaxBytesPerSec=1000000; // dummy!!!!! FIXME
280 // muxer->avih.dwPaddingGranularity=2; // ???
281 muxer->avih.dwFlags|=AVIF_ISINTERLEAVED|AVIF_TRUSTCKTYPE;
282 muxer->avih.dwTotalFrames=0;
283 for (i=0; i<muxer->idx_pos; i++) {
284 if (muxer->idx[i].ckid == muxer->def_v->ckid)
285 muxer->avih.dwTotalFrames++;
286 }
287 // muxer->avih.dwSuggestedBufferSize=muxer->def_v->h.dwSuggestedBufferSize;
288 muxer->avih.dwWidth=muxer->def_v->bih->biWidth;
289 muxer->avih.dwHeight=muxer->def_v->bih->biHeight;
290 }
291
292 // AVI header:
293 hdrsize=sizeof(muxer->avih)+8;
294 if (isodml) hdrsize+=sizeof(dmlh)+20; // dmlh
295 // calc total header size:
296 for(i=0;i<muxer->avih.dwStreams;i++){
297 muxer_stream_t *s = muxer->streams[i];
298 struct avi_stream_info *si = s->priv;
299
300 hdrsize+=12; // LIST
301 hdrsize+=sizeof(muxer->streams[i]->h)+8; // strh
302 switch(muxer->streams[i]->type){
303 case MUXER_TYPE_VIDEO:
304 hdrsize+=muxer->streams[i]->bih->biSize+8; // strf
305 if (aspect != 0) {
306 hdrsize+=8+4*(9+8*1); // vprp
307 }
308 break;
309 case MUXER_TYPE_AUDIO:
310 hdrsize+=WFSIZE(muxer->streams[i]->wf)+8; // strf
311 break;
312 }
313 if (isodml && si && si->superidx && si->superidxsize) {
314 hdrsize += 32 + 16*si->superidxsize; //indx
315 }
316 }
317 write_avi_list(muxer->stream,listtypeAVIHEADER,hdrsize);
318
319 le2me_MainAVIHeader(&muxer->avih);
320 write_avi_chunk(muxer->stream,ckidAVIMAINHDR,sizeof(muxer->avih),&muxer->avih); /* MainAVIHeader */
321 le2me_MainAVIHeader(&muxer->avih);
322
323 // stream headers:
324 for(i=0;i<muxer->avih.dwStreams;i++){
325 muxer_stream_t *s = muxer->streams[i];
326 struct avi_stream_info *si = s->priv;
327 unsigned int idxhdr[8];
328 int j,n;
329
330 hdrsize=sizeof(s->h)+8; // strh
331 if (si && si->superidx && si->superidxsize) {
332 hdrsize += 32 + 16*si->superidxsize; //indx
333 }
334 switch(s->type){
335 case MUXER_TYPE_VIDEO:
336 hdrsize+=s->bih->biSize+8; // strf
337 s->h.fccHandler = s->bih->biCompression;
338 s->h.rcFrame.right = s->bih->biWidth;
339 s->h.rcFrame.bottom = s->bih->biHeight;
340 if (aspect != 0) {
341 // fill out vprp info
342 memset(&vprp, 0, sizeof(vprp));
343 vprp.dwVerticalRefreshRate = (s->h.dwRate+s->h.dwScale-1)/s->h.dwScale;
344 vprp.dwHTotalInT = muxer->avih.dwWidth;
345 vprp.dwVTotalInLines = muxer->avih.dwHeight;
346 vprp.dwFrameAspectRatio = aspect;
347 vprp.dwFrameWidthInPixels = muxer->avih.dwWidth;
348 vprp.dwFrameHeightInLines = muxer->avih.dwHeight;
349 vprp.nbFieldPerFrame = 1;
350 vprp.FieldInfo[0].CompressedBMHeight = muxer->avih.dwHeight;
351 vprp.FieldInfo[0].CompressedBMWidth = muxer->avih.dwWidth;
352 vprp.FieldInfo[0].ValidBMHeight = muxer->avih.dwHeight;
353 vprp.FieldInfo[0].ValidBMWidth = muxer->avih.dwWidth;
354 hdrsize+=8+4*(9+8*1); // vprp
355 }
356 break;
357 case MUXER_TYPE_AUDIO:
358 hdrsize+=WFSIZE(s->wf)+8; // strf
359 s->h.fccHandler = s->wf->wFormatTag;
360 break;
361 }
362
363 write_avi_list(muxer->stream,listtypeSTREAMHEADER,hdrsize);
364 le2me_AVIStreamHeader(&s->h);
365 write_avi_chunk(muxer->stream,ckidSTREAMHEADER,sizeof(s->h),&s->h); /* AVISTreamHeader */ // strh
366 le2me_AVIStreamHeader(&s->h);
367
368 switch(s->type){
369 case MUXER_TYPE_VIDEO:
370 {
371 int biSize=s->bih->biSize;
372 le2me_BITMAPINFOHEADER(s->bih);
373 write_avi_chunk(muxer->stream,ckidSTREAMFORMAT,biSize,s->bih); /* BITMAPINFOHEADER */
374 le2me_BITMAPINFOHEADER(s->bih);
375
376 if (aspect != 0) {
377 int fields = vprp.nbFieldPerFrame;
378 le2me_VideoPropHeader(&vprp);
379 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[0]);
380 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[1]);
381 write_avi_chunk(muxer->stream,mmioFOURCC('v','p','r','p'),
382 sizeof(VideoPropHeader) -
383 sizeof(VIDEO_FIELD_DESC)*(2-fields),
384 &vprp); /* Video Properties Header */
385 }
386 }
387 break;
388 case MUXER_TYPE_AUDIO:
389 {
390 int wfsize = WFSIZE(s->wf);
391 le2me_WAVEFORMATEX(s->wf);
392 write_avi_chunk(muxer->stream,ckidSTREAMFORMAT,wfsize,s->wf); /* WAVEFORMATEX */
393 le2me_WAVEFORMATEX(s->wf);
394 }
395 break;
396 }
397 if (isodml && si && si->superidx && si->superidxsize) {
398 n = si->superidxsize;
399
400 idxhdr[0] = le2me_32(mmioFOURCC('i', 'n', 'd', 'x'));
401 idxhdr[1] = le2me_32(24 + 16*n);
402 idxhdr[2] = le2me_32(0x00000004);
403 idxhdr[3] = le2me_32(si->superidxpos);
404 idxhdr[4] = le2me_32(s->ckid);
405 idxhdr[5] = 0;
406 idxhdr[6] = 0;
407 idxhdr[7] = 0;
408
409 stream_write_buffer(muxer->stream,idxhdr,sizeof(idxhdr));
410 for (j=0; j<n; j++) {
411 struct avi_odmlsuperidx_entry *entry = &si->superidx[j];
412 unsigned int data[4];
413 data[0] = le2me_32(entry->ofs);
414 data[1] = le2me_32(entry->ofs >> 32);
415 data[2] = le2me_32(entry->len);
416 data[3] = le2me_32(entry->duration);
417 stream_write_buffer(muxer->stream,data,sizeof(data));
418 }
419 }
420 }
421
422 // ODML
423 if (isodml) {
424 memset(dmlh, 0, sizeof(dmlh));
425 dmlh[0] = le2me_32(muxer->avih.dwTotalFrames);
426 write_avi_list(muxer->stream,mmioFOURCC('o','d','m','l'),sizeof(dmlh)+8);
427 write_avi_chunk(muxer->stream,mmioFOURCC('d','m','l','h'),sizeof(dmlh),dmlh);
428 }
429
430 // ============= INFO ===============
431 // always include software info
432 info[0].id=mmioFOURCC('I','S','F','T'); // Software:
433 info[0].text=mencoder_version;
434 // include any optional strings
435 i=1;
436 if(info_name!=NULL){
437 info[i].id=mmioFOURCC('I','N','A','M'); // Name:
438 info[i++].text=info_name;
439 }
440 if(info_artist!=NULL){
441 info[i].id=mmioFOURCC('I','A','R','T'); // Artist:
442 info[i++].text=info_artist;
443 }
444 if(info_genre!=NULL){
445 info[i].id=mmioFOURCC('I','G','N','R'); // Genre:
446 info[i++].text=info_genre;
447 }
448 if(info_subject!=NULL){
449 info[i].id=mmioFOURCC('I','S','B','J'); // Subject:
450 info[i++].text=info_subject;
451 }
452 if(info_copyright!=NULL){
453 info[i].id=mmioFOURCC('I','C','O','P'); // Copyright:
454 info[i++].text=info_copyright;
455 }
456 if(info_sourceform!=NULL){
457 info[i].id=mmioFOURCC('I','S','R','F'); // Source Form:
458 info[i++].text=info_sourceform;
459 }
460 if(info_comment!=NULL){
461 info[i].id=mmioFOURCC('I','C','M','T'); // Comment:
462 info[i++].text=info_comment;
463 }
464 info[i].id=0;
465
466 hdrsize=0;
467 // calc info size:
468 for(i=0;info[i].id!=0;i++) if(info[i].text){
469 size_t sz=strlen(info[i].text)+1;
470 hdrsize+=sz+8+sz%2;
471 }
472 // write infos:
473 if (hdrsize!=0){
474 write_avi_list(muxer->stream,mmioFOURCC('I','N','F','O'),hdrsize);
475 for(i=0;info[i].id!=0;i++) if(info[i].text){
476 write_avi_chunk(muxer->stream,info[i].id,strlen(info[i].text)+1,info[i].text);
477 }
478 }
479
480 // JUNK:
481 write_avi_chunk(muxer->stream,ckidAVIPADDING,MOVIALIGN-(stream_tell(muxer->stream)%MOVIALIGN)-8,NULL); /* junk */
482 if (!isodml) {
483 // 'movi' header:
484 write_avi_list(muxer->stream,listtypeAVIMOVIE,muxer->movi_end-stream_tell(muxer->stream)-12);
485 } else {
486 if (stream_tell(muxer->stream) != MOVIALIGN) {
487 mp_msg(MSGT_MUXER, MSGL_ERR, "Opendml superindex is too big for reserved space!\n");
488 mp_msg(MSGT_MUXER, MSGL_ERR,
489 "Expected filepos %d, real filepos %"PRIu64", missing space %"PRIu64"\n",
490 MOVIALIGN, stream_tell(muxer->stream), stream_tell(muxer->stream) - MOVIALIGN);
491 mp_msg(MSGT_MUXER, MSGL_ERR, "Try increasing MOVIALIGN in libmpdemux/muxer_avi.c\n");
492 }
493 write_avi_list(muxer->stream,listtypeAVIMOVIE,muxer->movi_end-stream_tell(muxer->stream)-12);
494 }
495 muxer->movi_start=stream_tell(muxer->stream);
496 if (muxer->file_end == 0) muxer->file_end = stream_tell(muxer->stream);
497 }
498
avifile_write_standard_index(muxer_t * muxer)499 static void avifile_write_standard_index(muxer_t *muxer)
500 {
501 muxer->movi_end = stream_tell(muxer->stream);
502 if (muxer->idx && muxer->idx_pos>0) {
503 int i;
504 // fixup index entries:
505 // for (i = 0; i < muxer->idx_pos; i++) muxer->idx[i].dwChunkOffset -= muxer->movi_start - 4;
506 // write index chunk:
507 for (i = 0; i < muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i]));
508 write_avi_chunk(muxer->stream, ckidAVINEWINDEX, 16 * muxer->idx_pos, muxer->idx); /* AVIINDEXENTRY */
509 for (i = 0; i < muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i]));
510 muxer->avih.dwFlags |= AVIF_HASINDEX;
511 }
512 muxer->file_end=stream_tell(muxer->stream);
513 }
514
avifile_write_chunk(muxer_stream_t * s,size_t len,unsigned int flags,double dts,double pts)515 static void avifile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts, double pts){
516 off_t rifflen;
517 muxer_t *muxer=s->muxer;
518 struct avi_stream_info *si = s->priv;
519 struct avi_stream_info *vsi = muxer->def_v->priv;
520 int paddedlen = len + (len&1);
521
522 if (s->type == MUXER_TYPE_VIDEO && !s->h.dwSuggestedBufferSize) {
523 off_t pos=stream_tell(muxer->stream);
524 stream_seek(muxer->stream, 0);
525 avifile_write_header(muxer);
526 stream_seek(muxer->stream, pos);
527 }
528 if(index_mode){
529 rifflen = muxer->file_end - vsi->riffofs[vsi->riffofspos] - 8;
530 if (vsi->riffofspos == 0) {
531 rifflen += 8+muxer->idx_pos*sizeof(AVIINDEXENTRY);
532 }
533 if (rifflen + paddedlen > ODML_CHUNKLEN && write_odml == 1) {
534 if (vsi->riffofspos == 0) {
535 avifile_write_standard_index(muxer);
536 }
537 avifile_odml_new_riff(muxer);
538 }
539
540 if (vsi->riffofspos == 0) {
541 // add to the traditional index:
542 if(muxer->idx_pos>=muxer->idx_size){
543 muxer->idx_size+=256; // 4kB
544 muxer->idx=realloc_struct(muxer->idx,muxer->idx_size,16);
545 }
546 muxer->idx[muxer->idx_pos].ckid=s->ckid;
547 muxer->idx[muxer->idx_pos].dwFlags=flags; // keyframe?
548 muxer->idx[muxer->idx_pos].dwChunkOffset=muxer->file_end-(muxer->movi_start-4);
549 muxer->idx[muxer->idx_pos].dwChunkLength=len;
550 ++muxer->idx_pos;
551 }
552
553 // add to odml index
554 if(si->idxpos>=si->idxsize){
555 si->idxsize+=256;
556 si->idx=realloc_struct(si->idx,si->idxsize,sizeof(*si->idx));
557 }
558 si->idx[si->idxpos].flags=(flags&AVIIF_KEYFRAME)?0:ODML_NOTKEYFRAME;
559 si->idx[si->idxpos].ofs=muxer->file_end;
560 si->idx[si->idxpos].len=len;
561 ++si->idxpos;
562 }
563 // write out the chunk:
564 write_avi_chunk(muxer->stream,s->ckid,len,s->buffer); /* unsigned char */
565
566 if (len > s->h.dwSuggestedBufferSize){
567 s->h.dwSuggestedBufferSize = len;
568 }
569 if((unsigned int)len>s->h.dwSuggestedBufferSize) s->h.dwSuggestedBufferSize=len;
570
571 muxer->file_end += 8 + paddedlen;
572 }
573
avifile_odml_write_index(muxer_t * muxer)574 static void avifile_odml_write_index(muxer_t *muxer){
575 muxer_stream_t* s;
576 struct avi_stream_info *si;
577 int i;
578
579 for (i=0; i<muxer->avih.dwStreams; i++) {
580 int j,k,n,idxpos,len,last,entries_per_subidx;
581 unsigned int idxhdr[8];
582 s = muxer->streams[i];
583 si = s->priv;
584
585 /*
586 * According to Avery Lee MSMP wants the subidx chunks to have the same size.
587 *
588 * So this code figures out how many entries we can put into
589 * an ix?? chunk, so that each ix?? chunk has the same size and the offsets
590 * don't overflow (Using ODML_CHUNKLEN for that is a bit more restrictive
591 * than it has to be though).
592 */
593
594 len = 0;
595 n = 0;
596 entries_per_subidx = INT_MAX;
597 do {
598 off_t start = si->idx[0].ofs;
599 last = entries_per_subidx;
600 for (j=0; j<si->idxpos; j++) {
601 len = si->idx[j].ofs - start;
602 if(len >= ODML_CHUNKLEN || n >= entries_per_subidx) {
603 if (entries_per_subidx > n) {
604 entries_per_subidx = n;
605 }
606 start = si->idx[j].ofs;
607 len = 0;
608 n = 0;
609 }
610 n++;
611 }
612 } while (last != entries_per_subidx);
613
614 si->superidxpos = (si->idxpos+entries_per_subidx-1) / entries_per_subidx;
615
616 mp_msg(MSGT_MUXER, MSGL_V, "ODML: Stream %d: Using %d entries per subidx, %d entries in superidx\n",
617 i, entries_per_subidx, si->superidxpos);
618
619 si->superidxsize = si->superidxpos;
620 si->superidx = calloc(si->superidxsize, sizeof(*si->superidx));
621
622 idxpos = 0;
623 for (j=0; j<si->superidxpos; j++) {
624 off_t start = si->idx[idxpos].ofs;
625 int duration;
626
627 duration = 0;
628 for (k=0; k<entries_per_subidx && idxpos+k<si->idxpos; k++) {
629 duration += s->h.dwSampleSize ? si->idx[idxpos+k].len/s->h.dwSampleSize : 1;
630 }
631
632 idxhdr[0] = le2me_32((s->ckid << 16) | mmioFOURCC('i', 'x', 0, 0));
633 idxhdr[1] = le2me_32(24 + 8*k);
634 idxhdr[2] = le2me_32(0x01000002);
635 idxhdr[3] = le2me_32(k);
636 idxhdr[4] = le2me_32(s->ckid);
637 idxhdr[5] = le2me_32(start + 8);
638 idxhdr[6] = le2me_32((start + 8)>> 32);
639 idxhdr[7] = 0; /* unused */
640
641 si->superidx[j].len = 32 + 8*k;
642 si->superidx[j].ofs = stream_tell(muxer->stream);
643 si->superidx[j].duration = duration;
644
645 stream_write_buffer(muxer->stream, idxhdr,sizeof(idxhdr));
646 for (k=0; k<entries_per_subidx && idxpos<si->idxpos; k++) {
647 unsigned int entry[2];
648 entry[0] = le2me_32(si->idx[idxpos].ofs - start);
649 entry[1] = le2me_32(si->idx[idxpos].len | si->idx[idxpos].flags);
650 idxpos++;
651 stream_write_buffer(muxer->stream, entry, sizeof(entry));
652 }
653 }
654 }
655 muxer->file_end=stream_tell(muxer->stream);
656 }
657
avifile_write_index(muxer_t * muxer)658 static void avifile_write_index(muxer_t *muxer){
659 struct avi_stream_info *vsi = muxer->def_v->priv;
660
661 mp_msg(MSGT_MUXER, MSGL_INFO, MSGTR_WritingTrailer);
662 if (vsi->riffofspos > 0){
663 avifile_odml_write_index(muxer);
664 } else {
665 avifile_write_standard_index(muxer);
666 }
667 }
668
avifile_fix_parameters(muxer_stream_t * s)669 static void avifile_fix_parameters(muxer_stream_t *s){
670 /* adjust audio_delay_fix according to individual stream delay */
671 if (s->type == MUXER_TYPE_AUDIO)
672 s->muxer->audio_delay_fix -= (float)s->decoder_delay * s->h.dwScale/s->h.dwRate;
673 if (s->type == MUXER_TYPE_VIDEO)
674 s->muxer->audio_delay_fix += (float)s->decoder_delay * s->h.dwScale/s->h.dwRate;
675 }
676
muxer_init_muxer_avi(muxer_t * muxer)677 int muxer_init_muxer_avi(muxer_t *muxer){
678 muxer->cont_new_stream = &avifile_new_stream;
679 muxer->cont_write_chunk = &avifile_write_chunk;
680 muxer->cont_write_header = &avifile_write_header;
681 muxer->cont_write_index = &avifile_write_index;
682 muxer->fix_stream_parameters = &avifile_fix_parameters;
683 return 1;
684 }
685