Mercurial > mplayer.hg

comparison libmpdemux/muxer_avi.c @ 21660:ca9da45d13e9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
muxers now write to output muxer->stream rather than to muxer->file
author nicodvb
date Mon, 18 Dec 2006 21:03:59 +0000
parents d7b2fa4c39da
children 06b71b6fdde7
comparison
equal deleted inserted replaced
21659:da09e69a0f01 21660:ca9da45d13e9
128 } 128 }
129 muxer->avih.dwStreams++; 129 muxer->avih.dwStreams++;
130 return s; 130 return s;
131 } 131 }
132 132
133 static void write_avi_chunk(FILE *f,unsigned int id,int len,void* data){ 133 static void write_avi_chunk(stream_t *stream,unsigned int id,int len,void* data){
134 int le_len = le2me_32(len); 134 int le_len = le2me_32(len);
135 int le_id = le2me_32(id); 135 int le_id = le2me_32(id);
136 fwrite(&le_id,4,1,f); 136 stream_write_buffer(stream, &le_id, 4);
137 fwrite(&le_len,4,1,f); 137 stream_write_buffer(stream, &le_len, 4);
138 138
139 if(len>0){ 139 if(len>0){
140 if(data){ 140 if(data){
141 // DATA 141 // DATA
142 fwrite(data,len,1,f); 142 stream_write_buffer(stream, data, len);
143 if(len&1){ // padding 143 if(len&1){ // padding
144 unsigned char zerobyte=0; 144 unsigned char zerobyte=0;
145 fwrite(&zerobyte,1,1,f); 145 stream_write_buffer(stream, &zerobyte, 1);
146 } 146 }
147 } else { 147 } else {
148 // JUNK 148 // JUNK
149 char *avi_junk_data="[= MPlayer junk data! =]"; 149 char *avi_junk_data="[= MPlayer junk data! =]";
150 if(len&1) ++len; // padding 150 if(len&1) ++len; // padding
151 while(len>0){ 151 while(len>0){
152 int l=strlen(avi_junk_data); 152 int l=strlen(avi_junk_data);
153 if(l>len) l=len; 153 if(l>len) l=len;
154 fwrite(avi_junk_data,l,1,f); 154 stream_write_buffer(stream, avi_junk_data, l);
155 len-=l; 155 len-=l;
156 } 156 }
157 } 157 }
158 } 158 }
159 } 159 }
160 160
161 static void write_avi_list(FILE *f,unsigned int id,int len); 161 static void write_avi_list(stream_t *s,unsigned int id,int len);
162 static void avifile_write_standard_index(muxer_t *muxer); 162 static void avifile_write_standard_index(muxer_t *muxer);
163 163
164 static void avifile_odml_new_riff(muxer_t *muxer) 164 static void avifile_odml_new_riff(muxer_t *muxer)
165 { 165 {
166 struct avi_stream_info *vsi = muxer->def_v->priv; 166 struct avi_stream_info *vsi = muxer->def_v->priv;
167 FILE *f = muxer->file;
168 uint32_t riff[3]; 167 uint32_t riff[3];
169 168
170 mp_msg(MSGT_MUXER, MSGL_INFO, "ODML: Starting new RIFF chunk at %dMB.\n", (int)(muxer->file_end/1024/1024)); 169 mp_msg(MSGT_MUXER, MSGL_INFO, "ODML: Starting new RIFF chunk at %dMB.\n", (int)(muxer->file_end/1024/1024));
171 170
172 vsi->riffofspos++; 171 vsi->riffofspos++;
173 if (vsi->riffofspos>=vsi->riffofssize) { 172 if (vsi->riffofspos>=vsi->riffofssize) {
174 vsi->riffofssize+=16; 173 vsi->riffofssize+=16;
175 vsi->riffofs=realloc_struct(vsi->riffofs,(vsi->riffofssize+1),sizeof(off_t)); 174 vsi->riffofs=realloc_struct(vsi->riffofs,(vsi->riffofssize+1),sizeof(off_t));
176 } 175 }
177 vsi->riffofs[vsi->riffofspos] = ftello(f); 176 vsi->riffofs[vsi->riffofspos] = stream_tell(muxer->stream);
178 177
179 /* RIFF/AVIX chunk */ 178 /* RIFF/AVIX chunk */
180 riff[0]=le2me_32(mmioFOURCC('R','I','F','F')); 179 riff[0]=le2me_32(mmioFOURCC('R','I','F','F'));
181 riff[1]=0; 180 riff[1]=0;
182 riff[2]=le2me_32(mmioFOURCC('A','V','I','X')); 181 riff[2]=le2me_32(mmioFOURCC('A','V','I','X'));
183 fwrite(riff,12,1,f); 182 stream_write_buffer(muxer->stream, riff, 12);
184 183
185 write_avi_list(f,listtypeAVIMOVIE,0); 184 write_avi_list(muxer->stream,listtypeAVIMOVIE,0);
186 185
187 muxer->file_end = ftello(f); 186 muxer->file_end = stream_tell(muxer->stream);
188 } 187 }
189 188
190 static void avifile_write_header(muxer_t *muxer); 189 static void avifile_write_header(muxer_t *muxer);
191 190
192 static void avifile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts, double pts){ 191 static void avifile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts, double pts){
195 struct avi_stream_info *si = s->priv; 194 struct avi_stream_info *si = s->priv;
196 struct avi_stream_info *vsi = muxer->def_v->priv; 195 struct avi_stream_info *vsi = muxer->def_v->priv;
197 int paddedlen = len + (len&1); 196 int paddedlen = len + (len&1);
198 197
199 if (s->type == MUXER_TYPE_VIDEO && !s->h.dwSuggestedBufferSize) { 198 if (s->type == MUXER_TYPE_VIDEO && !s->h.dwSuggestedBufferSize) {
200 off_t pos=ftell(muxer->file); 199 off_t pos=stream_tell(muxer->stream);
201 fseek(muxer->file, 0, SEEK_SET); 200 stream_seek(muxer->stream, 0);
202 avifile_write_header(muxer); 201 avifile_write_header(muxer);
203 fseek(muxer->file, pos, SEEK_SET); 202 stream_seek(muxer->stream, pos);
204 } 203 }
205 204
206 rifflen = muxer->file_end - vsi->riffofs[vsi->riffofspos] - 8; 205 rifflen = muxer->file_end - vsi->riffofs[vsi->riffofspos] - 8;
207 if (vsi->riffofspos == 0) { 206 if (vsi->riffofspos == 0) {
208 rifflen += 8+muxer->idx_pos*sizeof(AVIINDEXENTRY); 207 rifflen += 8+muxer->idx_pos*sizeof(AVIINDEXENTRY);
236 si->idx[si->idxpos].ofs=muxer->file_end; 235 si->idx[si->idxpos].ofs=muxer->file_end;
237 si->idx[si->idxpos].len=len; 236 si->idx[si->idxpos].len=len;
238 ++si->idxpos; 237 ++si->idxpos;
239 238
240 // write out the chunk: 239 // write out the chunk:
241 write_avi_chunk(muxer->file,s->ckid,len,s->buffer); /* unsigned char */ 240 write_avi_chunk(muxer->stream,s->ckid,len,s->buffer); /* unsigned char */
242 241
243 if (len > s->h.dwSuggestedBufferSize){ 242 if (len > s->h.dwSuggestedBufferSize){
244 s->h.dwSuggestedBufferSize = len; 243 s->h.dwSuggestedBufferSize = len;
245 } 244 }
246 if((unsigned int)len>s->h.dwSuggestedBufferSize) s->h.dwSuggestedBufferSize=len; 245 if((unsigned int)len>s->h.dwSuggestedBufferSize) s->h.dwSuggestedBufferSize=len;
247 246
248 muxer->file_end += 8 + paddedlen; 247 muxer->file_end += 8 + paddedlen;
249 } 248 }
250 249
251 static void write_avi_list(FILE *f,unsigned int id,int len){ 250 static void write_avi_list(stream_t *stream,unsigned int id,int len){
252 unsigned int list_id=FOURCC_LIST; 251 unsigned int list_id=FOURCC_LIST;
253 int le_len; 252 int le_len;
254 int le_id; 253 int le_id;
255 len+=4; // list fix 254 len+=4; // list fix
256 list_id = le2me_32(list_id); 255 list_id = le2me_32(list_id);
257 le_len = le2me_32(len); 256 le_len = le2me_32(len);
258 le_id = le2me_32(id); 257 le_id = le2me_32(id);
259 fwrite(&list_id,4,1,f); 258 stream_write_buffer(stream, &list_id, 4);
260 fwrite(&le_len,4,1,f); 259 stream_write_buffer(stream, &le_len, 4);
261 fwrite(&le_id,4,1,f); 260 stream_write_buffer(stream, &le_id, 4);
262 } 261 }
263 262
264 #define WFSIZE(wf) (sizeof(WAVEFORMATEX)+(wf)->cbSize) 263 #define WFSIZE(wf) (sizeof(WAVEFORMATEX)+(wf)->cbSize)
265 264
266 static void avifile_write_header(muxer_t *muxer){ 265 static void avifile_write_header(muxer_t *muxer){
267 uint32_t riff[3]; 266 uint32_t riff[3];
268 unsigned int dmlh[1]; 267 unsigned int dmlh[1];
269 unsigned int i; 268 unsigned int i;
270 unsigned int hdrsize; 269 unsigned int hdrsize;
271 muxer_info_t info[16]; 270 muxer_info_t info[16];
272 FILE *f = muxer->file;
273 VideoPropHeader vprp; 271 VideoPropHeader vprp;
274 uint32_t aspect = avi_aspect(muxer->def_v); 272 uint32_t aspect = avi_aspect(muxer->def_v);
275 struct avi_stream_info *vsi = muxer->def_v->priv; 273 struct avi_stream_info *vsi = muxer->def_v->priv;
276 int isodml = vsi->riffofspos > 0; 274 int isodml = vsi->riffofspos > 0;
277 275
304 /* fixup RIFF lengths */ 302 /* fixup RIFF lengths */
305 for (i=0; i<=vsi->riffofspos; i++) { 303 for (i=0; i<=vsi->riffofspos; i++) {
306 rifflen = vsi->riffofs[i+1] - vsi->riffofs[i] - 8; 304 rifflen = vsi->riffofs[i+1] - vsi->riffofs[i] - 8;
307 movilen = le2me_32(rifflen - 12); 305 movilen = le2me_32(rifflen - 12);
308 rifflen = le2me_32(rifflen); 306 rifflen = le2me_32(rifflen);
309 fseeko(f, vsi->riffofs[i]+4, SEEK_SET); 307 stream_seek(muxer->stream, vsi->riffofs[i]+4);
310 fwrite(&rifflen,4,1,f); 308 stream_write_buffer(muxer->stream,&rifflen,4);
311 309
312 /* fixup movi length */ 310 /* fixup movi length */
313 if (i > 0) { 311 if (i > 0) {
314 fseeko(f, vsi->riffofs[i]+16, SEEK_SET); 312 stream_seek(muxer->stream, vsi->riffofs[i]+16);
315 fwrite(&movilen,4,1,f); 313 stream_write_buffer(muxer->stream,&movilen,4);
316 } 314 }
317 } 315 }
318 316
319 fseeko(f, 12, SEEK_SET); 317 stream_seek(muxer->stream, 12);
320 } else { 318 } else {
321 // RIFF header: 319 // RIFF header:
322 riff[0]=mmioFOURCC('R','I','F','F'); 320 riff[0]=mmioFOURCC('R','I','F','F');
323 riff[1]=muxer->file_end-2*sizeof(unsigned int); // filesize 321 riff[1]=muxer->file_end-2*sizeof(unsigned int); // filesize
324 riff[2]=formtypeAVI; // 'AVI ' 322 riff[2]=formtypeAVI; // 'AVI '
325 riff[0]=le2me_32(riff[0]); 323 riff[0]=le2me_32(riff[0]);
326 riff[1]=le2me_32(riff[1]); 324 riff[1]=le2me_32(riff[1]);
327 riff[2]=le2me_32(riff[2]); 325 riff[2]=le2me_32(riff[2]);
328 fwrite(&riff,12,1,f); 326 stream_write_buffer(muxer->stream,&riff,12);
329 } 327 }
330 328
331 // update AVI header: 329 // update AVI header:
332 if(muxer->def_v){ 330 if(muxer->def_v){
333 int i; 331 int i;
368 } 366 }
369 if (isodml && si && si->superidx && si->superidxsize) { 367 if (isodml && si && si->superidx && si->superidxsize) {
370 hdrsize += 32 + 16*si->superidxsize; //indx 368 hdrsize += 32 + 16*si->superidxsize; //indx
371 } 369 }
372 } 370 }
373 write_avi_list(f,listtypeAVIHEADER,hdrsize); 371 write_avi_list(muxer->stream,listtypeAVIHEADER,hdrsize);
374 372
375 le2me_MainAVIHeader(&muxer->avih); 373 le2me_MainAVIHeader(&muxer->avih);
376 write_avi_chunk(f,ckidAVIMAINHDR,sizeof(muxer->avih),&muxer->avih); /* MainAVIHeader */ 374 write_avi_chunk(muxer->stream,ckidAVIMAINHDR,sizeof(muxer->avih),&muxer->avih); /* MainAVIHeader */
377 le2me_MainAVIHeader(&muxer->avih); 375 le2me_MainAVIHeader(&muxer->avih);
378 376
379 // stream headers: 377 // stream headers:
380 for(i=0;i<muxer->avih.dwStreams;i++){ 378 for(i=0;i<muxer->avih.dwStreams;i++){
381 muxer_stream_t *s = muxer->streams[i]; 379 muxer_stream_t *s = muxer->streams[i];
414 hdrsize+=WFSIZE(s->wf)+8; // strf 412 hdrsize+=WFSIZE(s->wf)+8; // strf
415 s->h.fccHandler = s->wf->wFormatTag; 413 s->h.fccHandler = s->wf->wFormatTag;
416 break; 414 break;
417 } 415 }
418 416
419 write_avi_list(f,listtypeSTREAMHEADER,hdrsize); 417 write_avi_list(muxer->stream,listtypeSTREAMHEADER,hdrsize);
420 le2me_AVIStreamHeader(&s->h); 418 le2me_AVIStreamHeader(&s->h);
421 write_avi_chunk(f,ckidSTREAMHEADER,sizeof(s->h),&s->h); /* AVISTreamHeader */ // strh 419 write_avi_chunk(muxer->stream,ckidSTREAMHEADER,sizeof(s->h),&s->h); /* AVISTreamHeader */ // strh
422 le2me_AVIStreamHeader(&s->h); 420 le2me_AVIStreamHeader(&s->h);
423 421
424 switch(s->type){ 422 switch(s->type){
425 case MUXER_TYPE_VIDEO: 423 case MUXER_TYPE_VIDEO:
426 { 424 {
427 int biSize=s->bih->biSize; 425 int biSize=s->bih->biSize;
428 le2me_BITMAPINFOHEADER(s->bih); 426 le2me_BITMAPINFOHEADER(s->bih);
429 write_avi_chunk(f,ckidSTREAMFORMAT,biSize,s->bih); /* BITMAPINFOHEADER */ 427 write_avi_chunk(muxer->stream,ckidSTREAMFORMAT,biSize,s->bih); /* BITMAPINFOHEADER */
430 le2me_BITMAPINFOHEADER(s->bih); 428 le2me_BITMAPINFOHEADER(s->bih);
431 429
432 if (aspect != 0) { 430 if (aspect != 0) {
433 int fields = vprp.nbFieldPerFrame; 431 int fields = vprp.nbFieldPerFrame;
434 le2me_VideoPropHeader(&vprp); 432 le2me_VideoPropHeader(&vprp);
435 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[0]); 433 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[0]);
436 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[1]); 434 le2me_VIDEO_FIELD_DESC(&vprp.FieldInfo[1]);
437 write_avi_chunk(f,mmioFOURCC('v','p','r','p'), 435 write_avi_chunk(muxer->stream,mmioFOURCC('v','p','r','p'),
438 sizeof(VideoPropHeader) - 436 sizeof(VideoPropHeader) -
439 sizeof(VIDEO_FIELD_DESC)*(2-fields), 437 sizeof(VIDEO_FIELD_DESC)*(2-fields),
440 &vprp); /* Video Properties Header */ 438 &vprp); /* Video Properties Header */
441 } 439 }
442 } 440 }
443 break; 441 break;
444 case MUXER_TYPE_AUDIO: 442 case MUXER_TYPE_AUDIO:
445 { 443 {
446 int wfsize = WFSIZE(s->wf); 444 int wfsize = WFSIZE(s->wf);
447 le2me_WAVEFORMATEX(s->wf); 445 le2me_WAVEFORMATEX(s->wf);
448 write_avi_chunk(f,ckidSTREAMFORMAT,wfsize,s->wf); /* WAVEFORMATEX */ 446 write_avi_chunk(muxer->stream,ckidSTREAMFORMAT,wfsize,s->wf); /* WAVEFORMATEX */
449 le2me_WAVEFORMATEX(s->wf); 447 le2me_WAVEFORMATEX(s->wf);
450 } 448 }
451 break; 449 break;
452 } 450 }
453 if (isodml && si && si->superidx && si->superidxsize) { 451 if (isodml && si && si->superidx && si->superidxsize) {
460 idxhdr[4] = le2me_32(s->ckid); 458 idxhdr[4] = le2me_32(s->ckid);
461 idxhdr[5] = 0; 459 idxhdr[5] = 0;
462 idxhdr[6] = 0; 460 idxhdr[6] = 0;
463 idxhdr[7] = 0; 461 idxhdr[7] = 0;
464 462
465 fwrite(idxhdr,sizeof(idxhdr),1,f); 463 stream_write_buffer(muxer->stream,idxhdr,sizeof(idxhdr));
466 for (j=0; j<n; j++) { 464 for (j=0; j<n; j++) {
467 struct avi_odmlsuperidx_entry *entry = &si->superidx[j]; 465 struct avi_odmlsuperidx_entry *entry = &si->superidx[j];
468 unsigned int data[4]; 466 unsigned int data[4];
469 data[0] = le2me_32(entry->ofs); 467 data[0] = le2me_32(entry->ofs);
470 data[1] = le2me_32(entry->ofs >> 32); 468 data[1] = le2me_32(entry->ofs >> 32);
471 data[2] = le2me_32(entry->len); 469 data[2] = le2me_32(entry->len);
472 data[3] = le2me_32(entry->duration); 470 data[3] = le2me_32(entry->duration);
473 fwrite(data,sizeof(data),1,f); 471 stream_write_buffer(muxer->stream,data,sizeof(data));
474 } 472 }
475 } 473 }
476 } 474 }
477 475
478 // ODML 476 // ODML
479 if (isodml) { 477 if (isodml) {
480 memset(dmlh, 0, sizeof(dmlh)); 478 memset(dmlh, 0, sizeof(dmlh));
481 dmlh[0] = le2me_32(muxer->avih.dwTotalFrames); 479 dmlh[0] = le2me_32(muxer->avih.dwTotalFrames);
482 write_avi_list(f,mmioFOURCC('o','d','m','l'),sizeof(dmlh)+8); 480 write_avi_list(muxer->stream,mmioFOURCC('o','d','m','l'),sizeof(dmlh)+8);
483 write_avi_chunk(f,mmioFOURCC('d','m','l','h'),sizeof(dmlh),dmlh); 481 write_avi_chunk(muxer->stream,mmioFOURCC('d','m','l','h'),sizeof(dmlh),dmlh);
484 } 482 }
485 483
486 // ============= INFO =============== 484 // ============= INFO ===============
487 // always include software info 485 // always include software info
488 info[0].id=mmioFOURCC('I','S','F','T'); // Software: 486 info[0].id=mmioFOURCC('I','S','F','T'); // Software:
525 size_t sz=strlen(info[i].text)+1; 523 size_t sz=strlen(info[i].text)+1;
526 hdrsize+=sz+8+sz%2; 524 hdrsize+=sz+8+sz%2;
527 } 525 }
528 // write infos: 526 // write infos:
529 if (hdrsize!=0){ 527 if (hdrsize!=0){
530 write_avi_list(f,mmioFOURCC('I','N','F','O'),hdrsize); 528 write_avi_list(muxer->stream,mmioFOURCC('I','N','F','O'),hdrsize);
531 for(i=0;info[i].id!=0;i++) if(info[i].text){ 529 for(i=0;info[i].id!=0;i++) if(info[i].text){
532 write_avi_chunk(f,info[i].id,strlen(info[i].text)+1,info[i].text); 530 write_avi_chunk(muxer->stream,info[i].id,strlen(info[i].text)+1,info[i].text);
533 } 531 }
534 } 532 }
535 533
536 // JUNK: 534 // JUNK:
537 write_avi_chunk(f,ckidAVIPADDING,MOVIALIGN-(ftello(f)%MOVIALIGN)-8,NULL); /* junk */ 535 write_avi_chunk(muxer->stream,ckidAVIPADDING,MOVIALIGN-(stream_tell(muxer->stream)%MOVIALIGN)-8,NULL); /* junk */
538 if (!isodml) { 536 if (!isodml) {
539 // 'movi' header: 537 // 'movi' header:
540 write_avi_list(f,listtypeAVIMOVIE,muxer->movi_end-ftello(f)-12); 538 write_avi_list(muxer->stream,listtypeAVIMOVIE,muxer->movi_end-stream_tell(muxer->stream)-12);
541 } else { 539 } else {
542 if (ftello(f) != MOVIALIGN) { 540 if (stream_tell(muxer->stream) != MOVIALIGN) {
543 mp_msg(MSGT_MUXER, MSGL_ERR, "Opendml superindex is too big for reserved space!\n"); 541 mp_msg(MSGT_MUXER, MSGL_ERR, "Opendml superindex is too big for reserved space!\n");
544 mp_msg(MSGT_MUXER, MSGL_ERR, "Expected filepos %d, real filepos %ld, missing space %ld\n", MOVIALIGN, ftell(muxer->file), ftell(muxer->file)-MOVIALIGN); 542 mp_msg(MSGT_MUXER, MSGL_ERR, "Expected filepos %d, real filepos %ld, missing space %ld\n", MOVIALIGN, stream_tell(muxer->stream), stream_tell(muxer->stream)-MOVIALIGN);
545 mp_msg(MSGT_MUXER, MSGL_ERR, "Try increasing MOVIALIGN in libmpdemux/muxer_avi.c\n"); 543 mp_msg(MSGT_MUXER, MSGL_ERR, "Try increasing MOVIALIGN in libmpdemux/muxer_avi.c\n");
546 } 544 }
547 write_avi_list(f,listtypeAVIMOVIE,muxer->movi_end-ftello(f)-12); 545 write_avi_list(muxer->stream,listtypeAVIMOVIE,muxer->movi_end-stream_tell(muxer->stream)-12);
548 } 546 }
549 muxer->movi_start=ftello(muxer->file); 547 muxer->movi_start=stream_tell(muxer->stream);
550 if (muxer->file_end == 0) muxer->file_end = ftello(muxer->file); 548 if (muxer->file_end == 0) muxer->file_end = stream_tell(muxer->stream);
551 } 549 }
552 550
553 static void avifile_odml_write_index(muxer_t *muxer){ 551 static void avifile_odml_write_index(muxer_t *muxer){
554 muxer_stream_t* s; 552 muxer_stream_t* s;
555 struct avi_stream_info *si; 553 struct avi_stream_info *si;
617 idxhdr[5] = le2me_32(start + 8); 615 idxhdr[5] = le2me_32(start + 8);
618 idxhdr[6] = le2me_32((start + 8)>> 32); 616 idxhdr[6] = le2me_32((start + 8)>> 32);
619 idxhdr[7] = 0; /* unused */ 617 idxhdr[7] = 0; /* unused */
620 618
621 si->superidx[j].len = 32 + 8*k; 619 si->superidx[j].len = 32 + 8*k;
622 si->superidx[j].ofs = ftello(muxer->file); 620 si->superidx[j].ofs = stream_tell(muxer->stream);
623 si->superidx[j].duration = duration; 621 si->superidx[j].duration = duration;
624 622
625 fwrite(idxhdr,sizeof(idxhdr),1,muxer->file); 623 stream_write_buffer(muxer->stream, idxhdr,sizeof(idxhdr));
626 for (k=0; k<entries_per_subidx && idxpos<si->idxpos; k++) { 624 for (k=0; k<entries_per_subidx && idxpos<si->idxpos; k++) {
627 unsigned int entry[2]; 625 unsigned int entry[2];
628 entry[0] = le2me_32(si->idx[idxpos].ofs - start); 626 entry[0] = le2me_32(si->idx[idxpos].ofs - start);
629 entry[1] = le2me_32(si->idx[idxpos].len | si->idx[idxpos].flags); 627 entry[1] = le2me_32(si->idx[idxpos].len | si->idx[idxpos].flags);
630 idxpos++; 628 idxpos++;
631 fwrite(entry,sizeof(entry),1,muxer->file); 629 stream_write_buffer(muxer->stream, entry, sizeof(entry));
632 } 630 }
633 } 631 }
634 } 632 }
635 muxer->file_end=ftello(muxer->file); 633 muxer->file_end=stream_tell(muxer->stream);
636 } 634 }
637 635
638 static void avifile_write_standard_index(muxer_t *muxer){ 636 static void avifile_write_standard_index(muxer_t *muxer){
639 637
640 muxer->movi_end=ftello(muxer->file); 638 muxer->movi_end=stream_tell(muxer->stream);
641 if(muxer->idx && muxer->idx_pos>0){ 639 if(muxer->idx && muxer->idx_pos>0){
642 int i; 640 int i;
643 // fixup index entries: 641 // fixup index entries:
644 // for(i=0;i<muxer->idx_pos;i++) muxer->idx[i].dwChunkOffset-=muxer->movi_start-4; 642 // for(i=0;i<muxer->idx_pos;i++) muxer->idx[i].dwChunkOffset-=muxer->movi_start-4;
645 // write index chunk: 643 // write index chunk:
646 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i])); 644 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i]));
647 write_avi_chunk(muxer->file,ckidAVINEWINDEX,16*muxer->idx_pos,muxer->idx); /* AVIINDEXENTRY */ 645 write_avi_chunk(muxer->stream,ckidAVINEWINDEX,16*muxer->idx_pos,muxer->idx); /* AVIINDEXENTRY */
648 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i])); 646 for (i=0; i<muxer->idx_pos; i++) le2me_AVIINDEXENTRY((&muxer->idx[i]));
649 muxer->avih.dwFlags|=AVIF_HASINDEX; 647 muxer->avih.dwFlags|=AVIF_HASINDEX;
650 } 648 }
651 muxer->file_end=ftello(muxer->file); 649 muxer->file_end=stream_tell(muxer->stream);
652 } 650 }
653 651
654 static void avifile_write_index(muxer_t *muxer){ 652 static void avifile_write_index(muxer_t *muxer){
655 struct avi_stream_info *vsi = muxer->def_v->priv; 653 struct avi_stream_info *vsi = muxer->def_v->priv;
656 654