Debian Codegraph @

lib/aviwrite/AviWrite.cpp

raw
1 /********************************************************
2
3 AviWriteStream/AviWriteFile class implementation
4 Copyright 2000 Eugene Kuznetsov ([email protected])
5
6 *********************************************************/
7
8 #define _LARGEFILE64_SOURCE
9 #include "AviWrite.h"
10 #include "audioencoder.h"
11 #include "avm_output.h"
12 #include <fcntl.h>
13 #include <stdlib.h>
14 #include <stdio.h>
15
16 #if defined(__FreeBSD__) || defined(__NetBSD__)
17 #define lseek64 lseek
18 #define O_LARGEFILE 0
19 #endif
20
21
22 /*
23 audiopreloadtime; (ms)
24 audiopreloadsize; bytes
25
26
27 avm::vector<char*> x;
28
29
30 audio/video add_buffer()
31 {
32 if (size + chunks > XX)
33 syncfile();
34
35 if (iskeyframe)
36
37
38
39 }
40
41
42 avi flush_buffer()
43 {
44 lastvideo()
45 while ()
46 {
47 audiochunk += audiochunksize;
48 if (audiochunk > limit)
49 {
50 write();
51
52
53 }
54 }
55
56
57 addindex()
58 write()
59 }
60
61 */
62
63 AVM_BEGIN_NAMESPACE;
64
65 #define __MODULE__ "WriteFile"
66
67 IWriteFile::~IWriteFile() {}
68 IAudioWriteStream::~IAudioWriteStream() {}
69 IVideoWriteStream::~IVideoWriteStream() {}
70
71 AviWriteStream::AviWriteStream(AviWriteFile* file, int ckid,
72 IStream::StreamType type,
73 fourcc_t handler, int frame_rate,
74 int flags,
75 const void* format, size_t format_size,
76 size_t samplesize, int quality)
77 :m_pFile(file), m_pcFormat(0), m_uiLength(0), m_ckid(ckid), m_stop(0)
78 {
79 m_type = type;
80 memset(&m_Header, 0, sizeof(m_Header));
81 switch (type)
82 {
83 case Video:
84 if (format)
85 {
86 const BITMAPINFOHEADER* bh = (const BITMAPINFOHEADER*) format;
87 m_Header.rcFrame.right = (int16_t) bh->biWidth;
88 m_Header.rcFrame.bottom = (int16_t) bh->biHeight;
89 }
90 m_Header.dwRate = 1000000;
91 m_Header.dwScale = frame_rate;
92 m_Header.fccType = streamtypeVIDEO;
93 break;
94 case Audio:
95 m_Header.dwRate = frame_rate;
96 printf("frame rate for audio: %d\n",frame_rate);
97
98 m_Header.dwScale = format ?
99 (uint32_t) ((const WAVEFORMATEX*) format)->nBlockAlign : (uint32_t) samplesize;
100 m_Header.fccType = streamtypeAUDIO;
101 break;
102 default:
103 throw FATAL("Unsupported stream type");
104 }
105
106 if (format && format_size > 0)
107 {
108 m_pcFormat = new char[format_size];
109 m_uiFormatSize = format_size;
110 memcpy(m_pcFormat, format, format_size);
111 }
112
113 m_Header.fccHandler = handler;
114 m_Header.dwFlags = flags;
115 m_Header.dwLength = 0;
116 m_Header.dwSampleSize = (uint32_t)samplesize;
117 m_Header.dwQuality = quality;
118 }
119
120 AviWriteStream::~AviWriteStream()
121 {
122 delete[] m_pcFormat;
123 }
124
125 int AviWriteStream::AddChunk(const void* chunk, size_t size, int flags)
126 {
127 if (!chunk && size)
128 {
129 AVM_WRITE("AVI writer", "Invalid argument to AviWriteStream::AddChunk()\n");
130 return -1;
131 }
132
133 m_pFile->AddChunk(chunk, size, m_ckid, flags);
134 //AVM_WRITE("AVI writer", "Addchunk %d %d\n", m_Header.dwSampleSize, size);
135 if (m_Header.dwSampleSize)
136 {
137 m_uiLength += size;
138 m_Header.dwLength = (uint32_t) m_uiLength / m_Header.dwSampleSize;
139 }
140 else
141 m_Header.dwLength++;
142
143 return 0;
144 }
145
146
147 /*
148 *
149 * WriteFile
150 *
151 */
152 AviWriteFile::AviWriteFile(const char* name, int64_t limit, int flags, int mask)
153 :m_pFileBuffer(0), m_lFlimit(limit), m_Filename(name), m_iFlags(flags),
154 m_iMask(mask)
155 {
156 init();
157 //AVM_WRITE("AVI writer", "AviWriteFile::AviWriteFile()\n");
158 }
159
160 AviWriteFile::~AviWriteFile()
161 {
162 //AVM_WRITE("AVI writer", "AviWriteFile::~AviWriteFile()\n");
163 if (!m_iStatus)
164 return;
165 try
166 {
167 // Stop encoders on all opened streams so it may flush
168 // all buffered data
169 for (size_t i = 0; i < m_Streams.size(); ++i)
170 {
171 if (m_Streams[i]->m_stop)
172 {
173 switch (m_Streams[i]->GetType())
174 {
175 case AviWriteStream::Video:
176 ((AviVideoWriteStream*)m_Streams[i])->Stop();
177 break;
178 case AviWriteStream::Audio:
179 ((AviAudioWriteStream*)m_Streams[i])->Stop();
180 break;
181 default:
182 break;
183 }
184 }
185 }
186 finish();
187 }
188 catch (...) {}
189
190 for (unsigned i = 0; i < m_Streams.size(); i++)
191 delete m_Streams[i];
192 m_Streams.clear();
193 }
194
195 void AviWriteFile::init()
196 {
197 segment_flag=false;
198 segmenting_name="";
199
200 m_iStatus = 0;
201 memset(&m_Header, 0, sizeof(m_Header));
202 m_Header.dwFlags = m_iFlags;
203 m_Index.clear();
204 for (size_t i = 0; i < m_Streams.size(); i++)
205 {
206 m_Streams[i]->m_Header.dwLength = 0;
207 m_Streams[i]->Start();
208 }
209
210 m_pFileBuffer = new FileBuffer(m_Filename.c_str(),
211 O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE,
212 m_iMask);
213 }
214
215 void AviWriteFile::finish()
216 {
217 off_t videoendpos = m_pFileBuffer->lseek(0, SEEK_CUR);
218 if (videoendpos & 1)
219 {
220 // padding
221 int junk = -1;
222 m_pFileBuffer->write(&junk, 1);
223 videoendpos++;
224 }
225
226 WriteHeaders();
227
228 write_le32(ckidAVINEWINDEX);
229 write_le32((uint32_t)(m_Index.size() * sizeof(AVIIndexEntry)));
230 m_pFileBuffer->write(&m_Index[0], m_Index.size() * sizeof(AVIIndexEntry));
231 //printf("INDEX SIZE %d\n", m_Index.size()*sizeof(AVIINDEXENTRY));
232 videoendpos = m_pFileBuffer->lseek(0, SEEK_END);
233 m_pFileBuffer->lseek(4, SEEK_SET);
234 write_le32((uint32_t)(videoendpos - 8));
235
236 delete m_pFileBuffer;
237 m_pFileBuffer = 0;
238
239 for (size_t i = 0; i < m_Streams.size(); i++)
240 m_Streams[i]->Stop();
241 }
242
243 IWriteStream* AviWriteFile::AddStream(IStream::StreamType type,
244 const void* format,
245 size_t format_size,
246 fourcc_t handler, int frame_rate,
247 size_t samplesize, int quality,
248 int flags)
249 {
250 int ckid = MAKEAVICKID((type==AviWriteStream::Video)
251 ? cktypeDIBcompressed : cktypeWAVEbytes,
252 m_Streams.size());
253
254 AviWriteStream* r =
255 new AviWriteStream(this, ckid, type, handler, frame_rate, flags,
256 format, format_size,
257 samplesize, quality);
258 m_Streams.push_back(r);
259 return r;
260 }
261
262 IWriteStream* AviWriteFile::AddStream(IReadStream* pStream)
263 {
264 AviWriteStream* r = 0;
265 IStream::StreamType type = pStream->GetType();
266 size_t format_size = 0;
267 char* format = 0;
268 int flags = 0;
269 int frame_rate;
270 int ckid;
271
272 StreamInfo* si = pStream->GetStreamInfo();
273 size_t samplesize = si->GetSampleSize();
274 int quality = si->GetQuality();
275 fourcc_t handler = si->GetFormat();
276
277 switch (type)
278 {
279 case IStream::Video:
280 format_size = pStream->GetVideoFormat();
281 if (!format_size)
282 goto end;
283 format = new char[format_size];
284 pStream->GetVideoFormat(format, format_size);
285 ckid = MAKEAVICKID(cktypeDIBcompressed, m_Streams.size());
286 frame_rate = (unsigned int)(1000000.*pStream->GetFrameTime());
287 break;
288 case IStream::Audio:
289 format_size = pStream->GetAudioFormat();
290 if (!format_size)
291 goto end;
292 format = new char[format_size];
293 pStream->GetAudioFormat(format, format_size);
294 ckid = MAKEAVICKID(cktypeWAVEbytes, m_Streams.size());
295 frame_rate = si->GetAudioSamplesPerSec();
296 break;
297 default:
298 return 0;
299 }
300
301 r = new AviWriteStream(this, ckid, type, handler, frame_rate, flags,
302 format, format_size,
303 samplesize, quality);
304 delete[] format;
305 m_Streams.push_back(r);
306 end:
307 delete si;
308 return r;
309 }
310
311 IVideoWriteStream* AviWriteFile::AddVideoStream(const CodecInfo& ci,
312 const BITMAPINFOHEADER* srchdr,
313 int frame_rate, int flags)
314 {
315 int ckid = MAKEAVICKID(cktypeDIBcompressed, m_Streams.size());
316
317 AviVideoWriteStream* r =
318 new AviVideoWriteStream(this, ckid, ci, srchdr,
319 frame_rate, flags);
320 m_Streams.push_back(r);
321 return r;
322 }
323
324 IVideoWriteStream* AviWriteFile::AddVideoStream(fourcc_t fourcc,
325 const BITMAPINFOHEADER* srchdr,
326 int frame_rate, int flags)
327 {
328 const CodecInfo* pci = CodecInfo::match(fourcc, CodecInfo::Video,
329 0, CodecInfo::Encode);
330 if (!pci)
331 throw FATAL("No known video codecs for this fourcc");
332 return AddVideoStream(*pci, srchdr, frame_rate, flags);
333 }
334
335 IVideoWriteStream* AviWriteFile::AddVideoStream(const VideoEncoderInfo* vi,
336 int frame_rate, int flags)
337 {
338 const CodecInfo* pci = CodecInfo::match(CodecInfo::Video, vi->cname.c_str());
339 if (!pci)
340 throw FATAL("No known video codecs for this VideoEncoderInfo");
341 return AddVideoStream(*pci, &vi->header, frame_rate, flags);
342 }
343
344 IAudioWriteStream* AviWriteFile::AddAudioStream(const CodecInfo& ci,
345 const WAVEFORMATEX* fmt,
346 int bitrate, int flags)
347 {
348 int ckid = MAKEAVICKID(cktypeWAVEbytes, m_Streams.size());
349
350 AviAudioWriteStream* r =
351 new AviAudioWriteStream(this, ckid, ci, fmt, bitrate, flags);
352
353 m_Streams.push_back(r);
354 return r;
355 }
356
357 IAudioWriteStream* AviWriteFile::AddAudioStream(fourcc_t fourcc,
358 const WAVEFORMATEX* fmt,
359 int bitrate, int flags)
360 {
361 const CodecInfo* pci = CodecInfo::match(fourcc, CodecInfo::Audio,
362 0, CodecInfo::Encode);
363 if (!pci)
364 throw FATAL("No known audio codecs for this fourcc");
365 return AddAudioStream(*pci, fmt, bitrate, flags);
366 }
367
368
369 void AviWriteFile::AddChunk(const void* chunk, size_t size, uint_t ckid, int flags)
370 {
371 if ( (m_lFlimit && GetFileSize() > m_lFlimit) || segment_flag)
372 {
373 //AVM_WRITE("AVI writer", "Size %lld limit %lld\n", GetFileSize(), m_lFlimit);
374
375 if( ( ((ckid >> 16) & 0xffff) == ('c' << 8 | 'd') ) && flags){
376 printf("segmenting\n");
377 Segment();
378 }
379 }
380
381 if (m_Index.size() == 0)
382 {
383 const int junk_size = 0x800;
384 char* junk = new char[junk_size];
385 memset(junk, 0, junk_size);
386 m_pFileBuffer->write(junk, junk_size);
387 delete[] junk;
388 m_iStatus = 1;
389 }
390
391 off_t offset = m_pFileBuffer->lseek(0, SEEK_CUR);
392
393 // let's make some fun
394 if (offset > 0xffff0000) throw FATAL("Unsupported AVI file size!");
395
396 write_le32(ckid);
397 write_le32((uint32_t)size);
398 if (chunk)
399 {
400 m_pFileBuffer->write(chunk, size);
401 if (size & 1)
402 m_pFileBuffer->write(chunk, 1);
403 }
404
405 //AVM_WRITE("AVI writer", "CKID 0x%x %5d %8d %8d %d\n", ckid, flags, size, m_lFlimit, GetFileSize());
406 AVIIndexEntry entry;
407 entry.ckid = ckid;
408 entry.dwFlags = flags;
409 entry.dwChunkOffset = (uint32_t)(offset - 0x7fc);
410 entry.dwChunkLength = (uint32_t)size;
411 m_Index.push_back(entry);
412 if (m_Index.size() % 1000 == 1)
413 WriteHeaders();
414 }
415
416 int64_t AviWriteFile::GetFileSize() const
417 {
418 return m_pFileBuffer->lseek(0, SEEK_CUR);
419 }
420
421 int AviWriteFile::Reserve(size_t size)
422 {
423 return -1;
424 }
425
426 int AviWriteFile::WriteChunk(fourcc_t fourcc, void* data, size_t size)
427 {
428 return -1;
429 }
430
431 void AviWriteFile::SetSegmentName(const avm::string& new_name)
432 {
433 segmenting_name=new_name;
434 }
435
436 void AviWriteFile::SegmentAtKeyframe()
437 {
438 segment_flag=true;
439 }
440
441 int AviWriteFile::Segment()
442 {
443 avm::string newfilename;
444
445 if(segmenting_name==""){
446 newfilename=m_Filename;
447 }
448 else{
449 newfilename=segmenting_name;
450 }
451
452 if (newfilename.size() < 6)
453 newfilename = avm::string("_____")+newfilename;
454
455 avm::string::size_type st = newfilename.find(".avi");
456 if (st == avm::string::npos)
457 newfilename += ".000.avi";
458 else
459 {
460 if (newfilename[st-4]=='.')
461 {
462 char* newval=&newfilename[st-3];
463 int i = atoi(newval) + 1;
464 if (i >= 1000)
465 i = 0;
466 char s[4];
467 sprintf(s, "%03d", i);
468 memcpy(newval, s, 3);
469 }
470 else
471 newfilename.insert(st, ".000");
472 }
473 segment_flag=false;
474 segmenting_name="";
475 finish();
476
477 m_Filename=newfilename;
478
479 init();
480 return 0;
481 }
482
483 void AviWriteFile::WriteHeaders()
484 {
485 //printf("**** Writing headers **** %d\n", m_iStatus);;
486 if (m_iStatus == 0)
487 return;
488
489 off_t endpos = m_pFileBuffer->lseek(0, SEEK_END);
490 if (m_pFileBuffer->lseek(0, SEEK_SET) != 0)
491 return;
492
493 m_Header.dwFlags |= AVIF_HASINDEX | AVIF_TRUSTCKTYPE;
494 m_Header.dwPaddingGranularity = 0;
495 m_Header.dwStreams = (uint32_t)m_Streams.size();
496 m_Header.dwTotalFrames = 0;
497 for (unsigned i = 0; i < m_Streams.size(); i++)
498 {
499 if (m_Streams[i]->GetType() == AviWriteStream::Video)
500 {
501 m_Header.dwTotalFrames = (uint32_t) m_Streams[i]->GetLength();
502 m_Header.dwMicroSecPerFrame = m_Header.dwScale = m_Streams[i]->m_Header.dwScale;
503 m_Header.dwWidth = m_Streams[i]->m_Header.rcFrame.right;
504 m_Header.dwHeight = (uint32_t) labs(m_Streams[i]->m_Header.rcFrame.bottom);
505 m_Header.dwRate = m_Streams[i]->m_Header.dwRate;
506 m_Header.dwStart = m_Streams[i]->m_Header.dwStart;
507 printf("header: video stream %d mspframe=%d rate=%d start=%d\n",i,m_Header.dwMicroSecPerFrame,m_Header.dwRate,m_Header.dwStart);
508 break;
509 }
510 }
511 if (m_Header.dwTotalFrames == 0)
512 if (m_Streams.size())
513 {
514 m_Header.dwTotalFrames = (uint32_t) m_Streams[0]->GetLength();
515 m_Header.dwWidth = m_Header.dwHeight = 0;
516 }
517
518 write_le32(FOURCC_RIFF);
519 write_le32((uint32_t)endpos - 8);
520 write_le32(formtypeAVI);// Here goes chunk with all headers
521 write_le32(FOURCC_LIST);
522
523 // header pos = 0x10
524 write_le32(0);//here header chunk size hdr_size will be
525 size_t hdr_size = 12 + sizeof(AVIMainHeader);
526
527 // Write AVIMainHeader
528 write_le32(listtypeAVIHEADER);
529 write_le32(ckidAVIMAINHDR);
530 write_le32(sizeof(AVIMainHeader));
531
532 write_le32(m_Header.dwMicroSecPerFrame);
533 write_le32(m_Header.dwMaxBytesPerSec);
534 write_le32(m_Header.dwPaddingGranularity);
535 write_le32(m_Header.dwFlags);
536 write_le32(m_Header.dwTotalFrames);
537 write_le32(m_Header.dwInitialFrames);
538 write_le32(m_Header.dwStreams);
539 write_le32(m_Header.dwSuggestedBufferSize);
540 write_le32(m_Header.dwWidth);
541 write_le32(m_Header.dwHeight);
542
543 write_le32(m_Header.dwScale);
544 write_le32(m_Header.dwRate);
545 write_le32(m_Header.dwStart);
546 write_le32(m_Header.dwLength);
547
548 for (unsigned j = 0; j < m_Streams.size(); j++)
549 {
550 size_t s = sizeof(AVIStreamHeader) + m_Streams[j]->m_uiFormatSize
551 + (m_Streams[j]->m_uiFormatSize & 1);
552 hdr_size += 28 + s;
553 write_le32(FOURCC_LIST);
554 write_le32((uint32_t)(20 + s));
555 write_le32(listtypeSTREAMHEADER);
556 write_le32(ckidSTREAMHEADER);
557 write_le32(sizeof(AVIStreamHeader));
558 m_pFileBuffer->write(&m_Streams[j]->m_Header, sizeof(AVIStreamHeader));
559
560 write_le32(ckidSTREAMFORMAT);
561 #if 0
562 if (m_Streams[j]->m_uiFormatSize == 30)
563 {
564 char b[200];
565 avm_wave_format(b, sizeof(b), (const WAVEFORMATEX*)m_Streams[j]->m_pcFormat);
566 AVM_WRITE("AVI writer", "STORE %p %s\n", m_Streams[j]->m_pcFormat, b);
567 }
568 #endif
569 if (m_Streams[j]->m_uiFormatSize)
570 {
571 AVM_WRITE("AVI writer", 1, "WriteHdr %" PRIsz "\n", m_Streams[j]->m_uiFormatSize);
572 write_le32((uint32_t)(m_Streams[j]->m_uiFormatSize));
573 m_pFileBuffer->write(m_Streams[j]->m_pcFormat, m_Streams[j]->m_uiFormatSize);
574 if (m_Streams[j]->m_uiFormatSize & 1)
575 m_pFileBuffer->write(&m_pFileBuffer, 1);
576 }
577 else
578 {
579 // fake header
580 write_le32(4);
581 write_le32(0);
582 }
583 }
584
585 if (hdr_size > 0x700)
586 throw FATAL("Too large header. Aborting");
587
588 uint32_t curpos = (uint32_t) m_pFileBuffer->lseek(0, SEEK_CUR);
589 write_le32(ckidAVIPADDING);
590 write_le32(0x7F4 - (curpos + 8));
591
592 m_pFileBuffer->lseek(0x7F4, SEEK_SET);
593 write_le32(FOURCC_LIST);
594 write_le32((uint32_t)(endpos - 0x7FC));
595 write_le32(listtypeAVIMOVIE);
596
597 m_pFileBuffer->lseek(0x10, SEEK_SET);
598 write_le32((uint32_t)hdr_size);
599 m_pFileBuffer->lseek(0, SEEK_END);
600 }
601
602 IWriteFile* CreateWriteFile(const char* name, int64_t flimit,
603 IStream::StreamFormat fmt,
604 int flags, int mask)
605 {
606 return new AviWriteFile(name, flimit, flags, mask);
607 }
608
609 #undef __MODULE__
610
611 AVM_END_NAMESPACE;