| 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; |