![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to avi_record.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to avi_record.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 ! root 1: /* ! 2: Hatari - avi_record.c ! 3: ! 4: This file is distributed under the GNU Public License, version 2 or at ! 5: your option any later version. Read the file gpl.txt for details. ! 6: ! 7: AVI File recording ! 8: ! 9: This allows Hatari to record a video file, with both video and audio ! 10: streams, at full frame rate. ! 11: ! 12: Video frames are saved using the current video frequency of the emulated ! 13: machine (50 Hz, 60 Hz, 70 Hz, ...). Frames can be stored using different ! 14: codecs. So far, supported codecs are : ! 15: - BMP : uncompressed RGB images. Very fast to save, very few cpu needed ! 16: but requires a lot of disk bandwidth and a lot of space. ! 17: - PNG : compressed RBG images. Depending on the compression level, this ! 18: can require more cpu and could slow down Hatari. As compressed images ! 19: are much smaller than BMP images, this will require less space on disk ! 20: and much less disk bandwidth. Compression levels 3 or 4 give could ! 21: tradeoff between cpu usage and file size and should not slow down Hatari ! 22: with recent computers. ! 23: ! 24: PNG compression will often give a x20 ratio when compared to BMP and should ! 25: be used if you have a powerful enough cpu. ! 26: ! 27: Sound is saved as 16 bits pcm stereo, using the current Hatari sound output ! 28: frequency. For best accuracy, sound frequency should be a multiple of the ! 29: video frequency ; this means 44.1 kHz is the best choice for 50/60 Hz video. ! 30: ! 31: The AVI file is divided into multiple chunks. Hatari will save one video stream ! 32: and one audio stream, so the overall strucutre of the file is the following : ! 33: ! 34: RIFF avi ! 35: LIST ! 36: hdrl ! 37: avih ! 38: LIST ! 39: strl ! 40: strh (vids) ! 41: strf ! 42: LIST ! 43: strl ! 44: strh (auds) ! 45: strf ! 46: LIST ! 47: INFO ! 48: LIST ! 49: movi ! 50: 00db ! 51: 01wb ! 52: ... ! 53: idx1 ! 54: */ ! 55: ! 56: const char AVIRecord_fileid[] = "Hatari avi_record.c : " __DATE__ " " __TIME__; ! 57: ! 58: #include <SDL.h> ! 59: #include <SDL_endian.h> ! 60: ! 61: #include "main.h" ! 62: #include "audio.h" ! 63: #include "configuration.h" ! 64: #include "log.h" ! 65: #include "screen.h" ! 66: #include "screenSnapShot.h" ! 67: #include "sound.h" ! 68: #include "statusbar.h" ! 69: #include "avi_record.h" ! 70: ! 71: /* after above that brings in config.h */ ! 72: #if HAVE_LIBPNG ! 73: #include <png.h> ! 74: #endif ! 75: ! 76: #include "pixel_convert.h" /* inline functions */ ! 77: ! 78: ! 79: ! 80: typedef struct ! 81: { ! 82: Uint8 ChunkName[4]; /* '00db', '01wb', 'idx1' */ ! 83: Uint8 ChunkSize[4]; ! 84: } AVI_CHUNK; ! 85: ! 86: ! 87: typedef struct ! 88: { ! 89: Uint8 identifier[4]; /* '00db', '01wb', 'idx1' */ ! 90: Uint8 flags[4]; ! 91: Uint8 offset[4]; ! 92: Uint8 length[4]; ! 93: } AVI_CHUNK_INDEX; ! 94: ! 95: ! 96: typedef struct ! 97: { ! 98: Uint8 ChunkName[4]; /* 'strh' */ ! 99: Uint8 ChunkSize[4]; ! 100: ! 101: Uint8 stream_type[4]; /* 'vids' or 'auds' */ ! 102: Uint8 stream_handler[4]; ! 103: Uint8 flags[4]; ! 104: Uint8 priority[2]; ! 105: Uint8 language[2]; ! 106: Uint8 initial_frames[4]; ! 107: Uint8 time_scale[4]; ! 108: Uint8 data_rate[4]; ! 109: Uint8 start_time[4]; ! 110: Uint8 data_length[4]; ! 111: Uint8 buffer_size[4]; ! 112: Uint8 quality[4]; ! 113: Uint8 sample_size[4]; ! 114: Uint8 dest_left[2]; ! 115: Uint8 dest_top[2]; ! 116: Uint8 dest_right[2]; ! 117: Uint8 dest_bottom[2]; ! 118: } AVI_STREAM_HEADER; ! 119: ! 120: ! 121: typedef struct ! 122: { ! 123: Uint8 ChunkName[4]; /* 'strf' */ ! 124: Uint8 ChunkSize[4]; ! 125: ! 126: Uint8 size[4]; ! 127: Uint8 width[4]; ! 128: Uint8 height[4]; ! 129: Uint8 planes[2]; ! 130: Uint8 bit_count[2]; ! 131: Uint8 compression[4]; ! 132: Uint8 size_image[4]; ! 133: Uint8 xpels_meter[4]; ! 134: Uint8 ypels_meter[4]; ! 135: Uint8 clr_used[4]; ! 136: Uint8 clr_important[4]; ! 137: } AVI_STREAM_FORMAT_VIDS; ! 138: ! 139: typedef struct ! 140: { ! 141: Uint8 ChunkName[4]; /* 'LIST' */ ! 142: Uint8 ChunkSize[4]; ! 143: ! 144: Uint8 Name[4]; /* 'strl' */ ! 145: AVI_STREAM_HEADER Header; /* 'strh' */ ! 146: AVI_STREAM_FORMAT_VIDS Format; /* 'strf' */ ! 147: } AVI_STREAM_LIST_VIDS; ! 148: ! 149: ! 150: typedef struct ! 151: { ! 152: Uint8 ChunkName[4]; /* 'strf' */ ! 153: Uint8 ChunkSize[4]; ! 154: ! 155: Uint8 codec[2]; ! 156: Uint8 channels[2]; ! 157: Uint8 sample_rate[4]; ! 158: Uint8 bit_rate[4]; ! 159: Uint8 block_align[2]; ! 160: Uint8 bits_per_sample[2]; ! 161: Uint8 ext_size[2]; ! 162: } AVI_STREAM_FORMAT_AUDS; ! 163: ! 164: typedef struct ! 165: { ! 166: Uint8 ChunkName[4]; /* 'LIST' */ ! 167: Uint8 ChunkSize[4]; ! 168: ! 169: Uint8 Name[4]; /* 'strl' */ ! 170: AVI_STREAM_HEADER Header; /* 'strh' */ ! 171: AVI_STREAM_FORMAT_AUDS Format; /* 'strf' */ ! 172: } AVI_STREAM_LIST_AUDS; ! 173: ! 174: ! 175: typedef struct { ! 176: Uint8 ChunkName[4]; /* 'avih' */ ! 177: Uint8 ChunkSize[4]; ! 178: ! 179: Uint8 microsec_per_frame[4]; ! 180: Uint8 max_bytes_per_second[4]; ! 181: Uint8 padding_granularity[4]; ! 182: Uint8 flags[4]; ! 183: Uint8 total_frames[4]; ! 184: Uint8 init_frame[4]; ! 185: Uint8 nb_streams[4]; ! 186: Uint8 buffer_size[4]; ! 187: Uint8 width[4]; ! 188: Uint8 height[4]; ! 189: Uint8 scale[4]; ! 190: Uint8 rate[4]; ! 191: Uint8 start[4]; ! 192: Uint8 length[4]; ! 193: } AVI_STREAM_AVIH; ! 194: ! 195: typedef struct ! 196: { ! 197: Uint8 ChunkName[4]; /* 'LIST' */ ! 198: Uint8 ChunkSize[4]; ! 199: ! 200: Uint8 Name[4]; /* 'hdrl' */ ! 201: AVI_STREAM_AVIH Header; ! 202: } AVI_STREAM_LIST_AVIH; ! 203: ! 204: ! 205: typedef struct { ! 206: Uint8 ChunkName[4]; /* 'ISFT' (software used) */ ! 207: Uint8 ChunkSize[4]; ! 208: ! 209: // Uint8 Text[2]; /* Text's size should be multiple of 2 (including '\0') */ ! 210: } AVI_STREAM_INFO; ! 211: ! 212: typedef struct ! 213: { ! 214: Uint8 ChunkName[4]; /* 'LIST' */ ! 215: Uint8 ChunkSize[4]; ! 216: ! 217: Uint8 Name[4]; /* 'INFO' */ ! 218: AVI_STREAM_INFO Info; ! 219: } AVI_STREAM_LIST_INFO; ! 220: ! 221: ! 222: typedef struct ! 223: { ! 224: Uint8 ChunkName[4]; /* 'LIST' */ ! 225: Uint8 ChunkSize[4]; ! 226: ! 227: Uint8 Name[4]; /* 'movi' */ ! 228: } AVI_STREAM_LIST_MOVI; ! 229: ! 230: ! 231: typedef struct ! 232: { ! 233: Uint8 signature[4]; /* 'RIFF' */ ! 234: Uint8 filesize[4]; ! 235: Uint8 type[4]; /* 'AVI ' */ ! 236: ! 237: } RIFF_HEADER; ! 238: ! 239: ! 240: typedef struct { ! 241: RIFF_HEADER RiffHeader; ! 242: ! 243: AVI_STREAM_LIST_AVIH AviHeader; ! 244: ! 245: AVI_STREAM_LIST_VIDS VideoStream; ! 246: AVI_STREAM_LIST_AUDS AudioStream; ! 247: ! 248: } AVI_FILE_HEADER; ! 249: ! 250: ! 251: ! 252: #define AUDIO_STREAM_WAVE_FORMAT_PCM 0x0001 ! 253: ! 254: #define VIDEO_STREAM_RGB 0x00000000 /* fourcc for BMP video frames */ ! 255: #define VIDEO_STREAM_PNG "MPNG" /* fourcc for PNG video frames */ ! 256: ! 257: #define AVIF_HASINDEX 0x00000010 /* index at the end of the file */ ! 258: #define AVIF_ISINTERLEAVED 0x00000100 /* data are interleaved */ ! 259: #define AVIF_TRUSTCKTYPE 0x00000800 /* trust chunk type */ ! 260: ! 261: #define AVIIF_KEYFRAME 0x00000010 /* frame is a keyframe */ ! 262: ! 263: ! 264: typedef struct { ! 265: /* Input params to start recording */ ! 266: int VideoCodec; ! 267: int VideoCodecCompressionLevel; /* 0-9 for png compression */ ! 268: ! 269: SDL_Surface *Surface; ! 270: ! 271: int CropLeft; ! 272: int CropRight; ! 273: int CropTop; ! 274: int CropBottom; ! 275: ! 276: int Fps; ! 277: ! 278: int AudioCodec; ! 279: int AudioFreq; ! 280: ! 281: /* Internal data used by the avi recorder */ ! 282: int Width; ! 283: int Height; ! 284: int BitCount; ! 285: FILE *FileOut; /* file to write to */ ! 286: int TotalVideoFrames; /* number of recorded video frames */ ! 287: int TotalAudioSamples; /* number of recorded audio samples */ ! 288: long MoviChunkPosStart; /* as returned by ftell() */ ! 289: long MoviChunkPosEnd; /* as returned by ftell() */ ! 290: } RECORD_AVI_PARAMS; ! 291: ! 292: ! 293: ! 294: bool bRecordingAvi = false; ! 295: #if HAVE_LIBPNG ! 296: int AviRecordDefaultVcodec = AVI_RECORD_VIDEO_CODEC_PNG; ! 297: #else ! 298: int AviRecordDefaultVcodec = AVI_RECORD_VIDEO_CODEC_BMP; ! 299: #endif ! 300: bool AviRecordDefaultCrop = true; ! 301: int AviRecordDefaultFps = 50; ! 302: char AviRecordFile[FILENAME_MAX] = "hatari.avi"; ! 303: ! 304: ! 305: static RECORD_AVI_PARAMS AviParams; ! 306: static AVI_FILE_HEADER AviFileHeader; ! 307: ! 308: ! 309: static void Avi_StoreU16 ( Uint8 *p , Uint16 val ); ! 310: static void Avi_StoreU32 ( Uint8 *p , Uint32 val ); ! 311: static void Avi_Store4cc ( Uint8 *p , const char *text ); ! 312: static Uint32 Avi_ReadU32 ( Uint8 *p ); ! 313: ! 314: static int Avi_GetBmpSize ( int Width , int Height , int BitCount ); ! 315: ! 316: static bool Avi_RecordVideoStream_BMP ( RECORD_AVI_PARAMS *pAviParams ); ! 317: #if HAVE_LIBPNG ! 318: static bool Avi_RecordVideoStream_PNG ( RECORD_AVI_PARAMS *pAviParams ); ! 319: #endif ! 320: static bool Avi_RecordAudioStream_PCM ( RECORD_AVI_PARAMS *pAviParams , Sint16 pSamples[][2], int SampleIndex, int SampleLength ); ! 321: ! 322: static void Avi_BuildFileHeader ( RECORD_AVI_PARAMS *pAviParams , AVI_FILE_HEADER *pAviFileHeader ); ! 323: static bool Avi_BuildIndex ( RECORD_AVI_PARAMS *pAviParams ); ! 324: ! 325: static bool Avi_StartRecording_WithParams ( RECORD_AVI_PARAMS *pAviParams , char *AviFileName ); ! 326: static bool Avi_StopRecording_WithParams ( RECORD_AVI_PARAMS *pAviParams ); ! 327: ! 328: ! 329: ! 330: ! 331: static void Avi_StoreU16 ( Uint8 *p , Uint16 val ) ! 332: { ! 333: *p++ = val & 0xff; ! 334: val >>= 8; ! 335: *p = val & 0xff; ! 336: } ! 337: ! 338: ! 339: static void Avi_StoreU32 ( Uint8 *p , Uint32 val ) ! 340: { ! 341: *p++ = val & 0xff; ! 342: val >>= 8; ! 343: *p++ = val & 0xff; ! 344: val >>= 8; ! 345: *p++ = val & 0xff; ! 346: val >>= 8; ! 347: *p = val & 0xff; ! 348: } ! 349: ! 350: ! 351: static void Avi_Store4cc ( Uint8 *p , const char *text ) ! 352: { ! 353: memcpy ( p , text , 4 ); ! 354: } ! 355: ! 356: ! 357: static Uint32 Avi_ReadU32 ( Uint8 *p ) ! 358: { ! 359: return (p[3]<<24) + (p[2]<<16) + (p[1]<<8) +p[0]; ! 360: } ! 361: ! 362: ! 363: static int Avi_GetBmpSize ( int Width , int Height , int BitCount ) ! 364: { ! 365: return ( Width * Height * BitCount / 8 ); /* bytes in one video frame */ ! 366: } ! 367: ! 368: ! 369: ! 370: static bool Avi_RecordVideoStream_BMP ( RECORD_AVI_PARAMS *pAviParams ) ! 371: { ! 372: AVI_CHUNK Chunk; ! 373: int SizeImage; ! 374: Uint8 LineBuf[ 3 * pAviParams->Width ]; /* temp buffer to convert to 24-bit BGR format */ ! 375: Uint8 *pBitmapIn , *pBitmapOut; ! 376: int y; ! 377: int NeedLock; ! 378: ! 379: SizeImage = Avi_GetBmpSize ( pAviParams->Width , pAviParams->Height , pAviParams->BitCount ); ! 380: ! 381: /* Write the video frame header */ ! 382: Avi_Store4cc ( Chunk.ChunkName , "00db" ); /* stream 0, uncompressed DIB bytes */ ! 383: Avi_StoreU32 ( Chunk.ChunkSize , SizeImage ); /* max size of RGB image */ ! 384: if ( fwrite ( &Chunk , sizeof ( Chunk ) , 1 , pAviParams->FileOut ) != 1 ) ! 385: { ! 386: perror ( "Avi_RecordVideoStream_BMP" ); ! 387: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write bmp frame header" ); ! 388: return false; ! 389: } ! 390: ! 391: ! 392: /* Write the video frame data */ ! 393: NeedLock = SDL_MUSTLOCK( pAviParams->Surface ); ! 394: ! 395: /* Points to the top left pixel after cropping borders */ ! 396: /* For BMP format, frame is stored from bottom to top (origin is in bottom left corner) */ ! 397: /* and bytes are in BGR order (not RGB) */ ! 398: pBitmapIn = (Uint8 *)pAviParams->Surface->pixels ! 399: + pAviParams->Surface->pitch * ( pAviParams->CropTop + pAviParams->Height ) ! 400: + pAviParams->CropLeft * pAviParams->Surface->format->BytesPerPixel; ! 401: ! 402: for ( y=0 ; y<pAviParams->Height ; y++ ) ! 403: { ! 404: if ( NeedLock ) ! 405: SDL_LockSurface ( pAviParams->Surface ); ! 406: ! 407: pBitmapOut = LineBuf; ! 408: switch ( pAviParams->Surface->format->BytesPerPixel ) { ! 409: case 1 : PixelConvert_8to24Bits_BGR(LineBuf, pBitmapIn, pAviParams->Width, pAviParams->Surface->format->palette->colors); ! 410: break; ! 411: case 2 : PixelConvert_16to24Bits_BGR(LineBuf, (Uint16 *)pBitmapIn, pAviParams->Width, pAviParams->Surface->format); ! 412: break; ! 413: case 3 : PixelConvert_24to24Bits_BGR(LineBuf, pBitmapIn, pAviParams->Width); ! 414: break; ! 415: case 4 : PixelConvert_32to24Bits_BGR(LineBuf, (Uint32 *)pBitmapIn, pAviParams->Width, pAviParams->Surface->format); ! 416: break; ! 417: } ! 418: ! 419: if ( NeedLock ) ! 420: SDL_UnlockSurface ( pAviParams->Surface ); ! 421: ! 422: if ( (int)fwrite ( pBitmapOut , 1 , pAviParams->Width*3 , pAviParams->FileOut ) != pAviParams->Width*3 ) ! 423: { ! 424: perror ( "Avi_RecordVideoStream_BMP" ); ! 425: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write bmp video frame" ); ! 426: return false; ! 427: } ! 428: ! 429: pBitmapIn -= pAviParams->Surface->pitch; /* go from bottom to top */ ! 430: } ! 431: ! 432: return true; ! 433: } ! 434: ! 435: ! 436: ! 437: #if HAVE_LIBPNG ! 438: static bool Avi_RecordVideoStream_PNG ( RECORD_AVI_PARAMS *pAviParams ) ! 439: { ! 440: AVI_CHUNK Chunk; ! 441: int SizeImage; ! 442: long ChunkPos; ! 443: Uint8 TempSize[4]; ! 444: ! 445: ! 446: /* Write the video frame header */ ! 447: ChunkPos = ftell ( pAviParams->FileOut ); ! 448: Avi_Store4cc ( Chunk.ChunkName , "00dc" ); /* stream 0, compressed DIB bytes */ ! 449: Avi_StoreU32 ( Chunk.ChunkSize , 0 ); /* size of PNG image (-> completed later) */ ! 450: if ( fwrite ( &Chunk , sizeof ( Chunk ) , 1 , pAviParams->FileOut ) != 1 ) ! 451: { ! 452: perror ( "Avi_RecordVideoStream_PNG" ); ! 453: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write png frame header" ); ! 454: return false; ! 455: } ! 456: ! 457: ! 458: /* Write the video frame data */ ! 459: SizeImage = ScreenSnapShot_SavePNG_ToFile ( pAviParams->Surface , pAviParams->FileOut , ! 460: pAviParams->VideoCodecCompressionLevel , PNG_FILTER_NONE , ! 461: pAviParams->CropLeft , pAviParams->CropRight , pAviParams->CropTop , pAviParams->CropBottom ); ! 462: if ( SizeImage <= 0 ) ! 463: { ! 464: perror ( "Avi_RecordVideoStream_PNG" ); ! 465: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write png video frame" ); ! 466: return false; ! 467: } ! 468: if ( SizeImage & 1 ) ! 469: { ! 470: SizeImage++; /* add an extra '\0' byte to get an even size */ ! 471: fputc ( '\0' , pAviParams->FileOut ); /* next chunk must be aligned on 16 bits boundary */ ! 472: } ! 473: ! 474: /* Update the size of the video chunk */ ! 475: Avi_StoreU32 ( TempSize , SizeImage ); ! 476: if ( fseek ( pAviParams->FileOut , ChunkPos+4 , SEEK_SET ) != 0 ) ! 477: { ! 478: perror ( "Avi_RecordVideoStream_PNG" ); ! 479: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update png frame header" ); ! 480: return false; ! 481: } ! 482: if ( fwrite ( TempSize , sizeof ( TempSize ) , 1 , pAviParams->FileOut ) != 1 ) ! 483: { ! 484: perror ( "Avi_RecordVideoStream_PNG" ); ! 485: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update png frame header" ); ! 486: return false; ! 487: } ! 488: ! 489: ! 490: /* Go to the end of the video frame data */ ! 491: if ( fseek ( pAviParams->FileOut , 0 , SEEK_END ) != 0 ) ! 492: { ! 493: perror ( "Avi_RecordVideoStream_PNG" ); ! 494: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to seek png video frame" ); ! 495: return false; ! 496: } ! 497: ! 498: return true; ! 499: } ! 500: #endif /* HAVE_LIBPNG */ ! 501: ! 502: ! 503: ! 504: bool Avi_RecordVideoStream ( void ) ! 505: { ! 506: if ( AviParams.VideoCodec == AVI_RECORD_VIDEO_CODEC_BMP ) ! 507: { ! 508: if ( Avi_RecordVideoStream_BMP ( &AviParams ) == false ) ! 509: { ! 510: return false; ! 511: } ! 512: } ! 513: #if HAVE_LIBPNG ! 514: else if ( AviParams.VideoCodec == AVI_RECORD_VIDEO_CODEC_PNG ) ! 515: { ! 516: if ( Avi_RecordVideoStream_PNG ( &AviParams ) == false ) ! 517: { ! 518: return false; ! 519: } ! 520: } ! 521: #endif ! 522: else ! 523: { ! 524: return false; ! 525: } ! 526: ! 527: AviParams.TotalVideoFrames++; ! 528: return true; ! 529: } ! 530: ! 531: ! 532: ! 533: static bool Avi_RecordAudioStream_PCM ( RECORD_AVI_PARAMS *pAviParams , Sint16 pSamples[][2] , int SampleIndex , int SampleLength ) ! 534: { ! 535: AVI_CHUNK Chunk; ! 536: Sint16 sample[2]; ! 537: int i; ! 538: ! 539: /* Write the audio frame header */ ! 540: Avi_Store4cc ( Chunk.ChunkName , "01wb" ); /* stream 1, wave bytes */ ! 541: Avi_StoreU32 ( Chunk.ChunkSize , SampleLength * 4 ); /* 16 bits, stereo -> 4 bytes */ ! 542: if ( fwrite ( &Chunk , sizeof ( Chunk ) , 1 , pAviParams->FileOut ) != 1 ) ! 543: { ! 544: perror ( "Avi_RecordAudioStream_PCM" ); ! 545: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write pcm frame header" ); ! 546: return false; ! 547: } ! 548: ! 549: /* Write the audio frame data */ ! 550: for ( i = 0 ; i < SampleLength; i++ ) ! 551: { ! 552: /* Convert sample to little endian */ ! 553: sample[0] = SDL_SwapLE16 ( pSamples[ (SampleIndex+i) % MIXBUFFER_SIZE ][0]); ! 554: sample[1] = SDL_SwapLE16 ( pSamples[ (SampleIndex+i) % MIXBUFFER_SIZE ][1]); ! 555: /* And store */ ! 556: if ( fwrite ( &sample , sizeof ( sample ) , 1 , pAviParams->FileOut ) != 1 ) ! 557: { ! 558: perror ( "Avi_RecordAudioStream_PCM" ); ! 559: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write pcm frame" ); ! 560: return false; ! 561: } ! 562: } ! 563: ! 564: return true; ! 565: } ! 566: ! 567: ! 568: ! 569: bool Avi_RecordAudioStream ( Sint16 pSamples[][2] , int SampleIndex , int SampleLength ) ! 570: { ! 571: if ( AviParams.AudioCodec == AVI_RECORD_AUDIO_CODEC_PCM ) ! 572: { ! 573: if ( Avi_RecordAudioStream_PCM ( &AviParams , pSamples , SampleIndex , SampleLength ) == false ) ! 574: { ! 575: return false; ! 576: } ! 577: } ! 578: else ! 579: { ! 580: return false; ! 581: } ! 582: ! 583: AviParams.TotalAudioSamples += SampleLength; ! 584: return true; ! 585: } ! 586: ! 587: ! 588: ! 589: ! 590: static void Avi_BuildFileHeader ( RECORD_AVI_PARAMS *pAviParams , AVI_FILE_HEADER *pAviFileHeader ) ! 591: { ! 592: int Width , Height , BitCount , Fps , SizeImage; ! 593: int AudioFreq; ! 594: ! 595: memset ( pAviFileHeader , 0 , sizeof ( *pAviFileHeader ) ); ! 596: ! 597: Width = pAviParams->Width; ! 598: Height =pAviParams->Height; ! 599: BitCount = pAviParams->BitCount; ! 600: Fps = pAviParams->Fps; ! 601: AudioFreq = pAviParams->AudioFreq; ! 602: ! 603: SizeImage = 0; ! 604: if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_BMP ) ! 605: SizeImage = Avi_GetBmpSize ( Width , Height , BitCount ); /* size of a BMP image */ ! 606: else if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_PNG ) ! 607: SizeImage = Avi_GetBmpSize ( Width , Height , BitCount ); /* max size of a PNG image */ ! 608: ! 609: ! 610: /* RIFF / AVI headers */ ! 611: Avi_Store4cc ( pAviFileHeader->RiffHeader.signature , "RIFF" ); ! 612: Avi_StoreU32 ( pAviFileHeader->RiffHeader.filesize , 0 ); /* total file size (-> completed later) */ ! 613: Avi_Store4cc ( pAviFileHeader->RiffHeader.type , "AVI " ); ! 614: ! 615: Avi_Store4cc ( pAviFileHeader->AviHeader.ChunkName , "LIST" ); ! 616: Avi_StoreU32 ( pAviFileHeader->AviHeader.ChunkSize , sizeof ( AVI_STREAM_LIST_AVIH ) ! 617: + sizeof ( AVI_STREAM_LIST_VIDS ) + sizeof ( AVI_STREAM_LIST_AUDS ) - 8 ); ! 618: Avi_Store4cc ( pAviFileHeader->AviHeader.Name , "hdrl" ); ! 619: ! 620: Avi_Store4cc ( pAviFileHeader->AviHeader.Header.ChunkName , "avih" ); ! 621: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.ChunkSize , sizeof ( AVI_STREAM_AVIH ) - 8 ); ! 622: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.microsec_per_frame , 1000000 / Fps ); ! 623: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.max_bytes_per_second , SizeImage * Fps + AudioFreq * 4 ); ! 624: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.padding_granularity , 0 ); ! 625: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.flags , AVIF_HASINDEX | AVIF_ISINTERLEAVED | AVIF_TRUSTCKTYPE ); ! 626: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.total_frames , 0 ); /* number of video frames (-> completed later) */ ! 627: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.init_frame , 0 ); ! 628: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.nb_streams , 2 ); /* 1 video and 1 audio */ ! 629: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.buffer_size , SizeImage ); ! 630: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.width , Width ); ! 631: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.height , Height ); ! 632: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.scale , 0 ); /* reserved */ ! 633: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.rate , 0 ); /* reserved */ ! 634: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.start , 0 ); /* reserved */ ! 635: Avi_StoreU32 ( pAviFileHeader->AviHeader.Header.length , 0 ); /* reserved */ ! 636: ! 637: ! 638: /* Video Stream */ ! 639: Avi_Store4cc ( pAviFileHeader->VideoStream.ChunkName , "LIST" ); ! 640: Avi_StoreU32 ( pAviFileHeader->VideoStream.ChunkSize , sizeof ( AVI_STREAM_LIST_VIDS ) - 8 ); ! 641: Avi_Store4cc ( pAviFileHeader->VideoStream.Name , "strl" ); ! 642: ! 643: Avi_Store4cc ( pAviFileHeader->VideoStream.Header.ChunkName , "strh" ); ! 644: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.ChunkSize , sizeof ( AVI_STREAM_HEADER ) - 8 ); ! 645: Avi_Store4cc ( pAviFileHeader->VideoStream.Header.stream_type , "vids" ); ! 646: if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_BMP ) ! 647: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.stream_handler , VIDEO_STREAM_RGB ); ! 648: else if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_PNG ) ! 649: Avi_Store4cc ( pAviFileHeader->VideoStream.Header.stream_handler , VIDEO_STREAM_PNG ); ! 650: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.flags , 0 ); ! 651: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.priority , 0 ); ! 652: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.language , 0 ); ! 653: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.initial_frames , 0 ); ! 654: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.time_scale , 1 ); ! 655: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.data_rate , Fps ); ! 656: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.start_time , 0 ); ! 657: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.data_length , 0 ); /* number of video frames (-> completed later) */ ! 658: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.buffer_size , SizeImage ); /* size of an uncompressed frame */ ! 659: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.quality , -1 ); /* use default quality */ ! 660: Avi_StoreU32 ( pAviFileHeader->VideoStream.Header.sample_size , 0 ); /* 0 for video */ ! 661: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.dest_left , 0 ); ! 662: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.dest_top , 0 ); ! 663: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.dest_right , Width ); ! 664: Avi_StoreU16 ( pAviFileHeader->VideoStream.Header.dest_bottom , Height ); ! 665: ! 666: Avi_Store4cc ( pAviFileHeader->VideoStream.Format.ChunkName , "strf" ); ! 667: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.ChunkSize , sizeof ( AVI_STREAM_FORMAT_VIDS ) - 8 ); ! 668: if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_BMP ) ! 669: { ! 670: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.size , sizeof ( AVI_STREAM_FORMAT_VIDS ) - 8 ); ! 671: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.width , Width ); ! 672: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.height , Height ); ! 673: Avi_StoreU16 ( pAviFileHeader->VideoStream.Format.planes , 1 ); /* always 1 */ ! 674: Avi_StoreU16 ( pAviFileHeader->VideoStream.Format.bit_count , BitCount ); ! 675: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.compression , VIDEO_STREAM_RGB ); ! 676: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.size_image , SizeImage ); ! 677: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.xpels_meter , 0 ); ! 678: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.ypels_meter , 0 ); ! 679: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.clr_used , 0 ); /* no color map */ ! 680: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.clr_important , 0 ); /* no color map */ ! 681: } ! 682: else if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_PNG ) ! 683: { ! 684: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.size , sizeof ( AVI_STREAM_FORMAT_VIDS ) - 8 ); ! 685: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.width , Width ); ! 686: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.height , Height ); ! 687: Avi_StoreU16 ( pAviFileHeader->VideoStream.Format.planes , 1 ); /* always 1 */ ! 688: Avi_StoreU16 ( pAviFileHeader->VideoStream.Format.bit_count , BitCount ); ! 689: Avi_Store4cc ( pAviFileHeader->VideoStream.Format.compression , VIDEO_STREAM_PNG ); ! 690: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.size_image , SizeImage ); /* max size if uncompressed */ ! 691: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.xpels_meter , 0 ); ! 692: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.ypels_meter , 0 ); ! 693: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.clr_used , 0 ); /* no color map */ ! 694: Avi_StoreU32 ( pAviFileHeader->VideoStream.Format.clr_important , 0 ); /* no color map */ ! 695: } ! 696: ! 697: ! 698: /* Audio Stream */ ! 699: Avi_Store4cc ( pAviFileHeader->AudioStream.ChunkName , "LIST" ); ! 700: Avi_StoreU32 ( pAviFileHeader->AudioStream.ChunkSize , sizeof ( AVI_STREAM_LIST_AUDS ) - 8 ); ! 701: Avi_Store4cc ( pAviFileHeader->AudioStream.Name , "strl" ); ! 702: ! 703: Avi_Store4cc ( pAviFileHeader->AudioStream.Header.ChunkName , "strh" ); ! 704: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.ChunkSize , sizeof ( AVI_STREAM_HEADER ) - 8 ); ! 705: Avi_Store4cc ( pAviFileHeader->AudioStream.Header.stream_type , "auds" ); ! 706: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.stream_handler , 0 ); /* not used (or could be 1 for pcm ?) */ ! 707: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.flags , 0 ); ! 708: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.priority , 0 ); ! 709: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.language , 0 ); ! 710: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.initial_frames , 0 ); /* should be 1 in interleaved ? */ ! 711: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.time_scale , 1 ); ! 712: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.data_rate , AudioFreq ); ! 713: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.start_time , 0 ); ! 714: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.data_length , 0 ); /* number of audio samples (-> completed later) */ ! 715: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.buffer_size , AudioFreq * 4 / 50 ); /* min VBL freq is 50 Hz */ ! 716: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.quality , -1 ); /* use default quality */ ! 717: Avi_StoreU32 ( pAviFileHeader->AudioStream.Header.sample_size , 4 ); /* 2 bytes, stereo */ ! 718: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.dest_left , 0 ); ! 719: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.dest_top , 0 ); ! 720: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.dest_right , 0 ); ! 721: Avi_StoreU16 ( pAviFileHeader->AudioStream.Header.dest_bottom , 0 ); ! 722: ! 723: Avi_Store4cc ( pAviFileHeader->AudioStream.Format.ChunkName , "strf" ); ! 724: Avi_StoreU32 ( pAviFileHeader->AudioStream.Format.ChunkSize , sizeof ( AVI_STREAM_FORMAT_AUDS ) - 8 ); ! 725: if ( pAviParams->AudioCodec == AVI_RECORD_AUDIO_CODEC_PCM ) /* 16 bits stereo pcm */ ! 726: { ! 727: Avi_StoreU16 ( pAviFileHeader->AudioStream.Format.codec , AUDIO_STREAM_WAVE_FORMAT_PCM ); /* 0x0001 */ ! 728: Avi_StoreU16 ( pAviFileHeader->AudioStream.Format.channels , 2 ); ! 729: Avi_StoreU32 ( pAviFileHeader->AudioStream.Format.sample_rate , AudioFreq ); ! 730: Avi_StoreU32 ( pAviFileHeader->AudioStream.Format.bit_rate , AudioFreq * 2 * 2 ); /* 2 channels * 2 bytes */ ! 731: Avi_StoreU16 ( pAviFileHeader->AudioStream.Format.block_align , 4 ); ! 732: Avi_StoreU16 ( pAviFileHeader->AudioStream.Format.bits_per_sample , 16 ); ! 733: Avi_StoreU16 ( pAviFileHeader->AudioStream.Format.ext_size , 0 ); ! 734: } ! 735: } ! 736: ! 737: ! 738: static bool Avi_BuildIndex ( RECORD_AVI_PARAMS *pAviParams ) ! 739: { ! 740: AVI_CHUNK Chunk; ! 741: long IndexChunkPosStart; ! 742: long Pos , PosWrite; ! 743: Uint8 TempSize[4]; ! 744: AVI_CHUNK_INDEX ChunkIndex; ! 745: Uint32 Size; ! 746: ! 747: fseek ( pAviParams->FileOut , 0 , SEEK_END ); /* go to the end of the file */ ! 748: ! 749: /* Write the 'idx1' chunk header */ ! 750: IndexChunkPosStart = ftell ( pAviParams->FileOut ); ! 751: Avi_Store4cc ( Chunk.ChunkName , "idx1" ); /* stream 0, uncompressed DIB bytes */ ! 752: Avi_StoreU32 ( Chunk.ChunkSize , 0 ); /* index size (-> completed later) */ ! 753: if ( fwrite ( &Chunk , sizeof ( Chunk ) , 1 , pAviParams->FileOut ) != 1 ) ! 754: { ! 755: perror ( "Avi_BuildIndex" ); ! 756: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write index header" ); ! 757: return false; ! 758: } ! 759: PosWrite = ftell ( pAviParams->FileOut ); /* position to start writing indexes */ ! 760: ! 761: /* Go to the first data chunk in the 'movi' chunk */ ! 762: fseek ( pAviParams->FileOut , pAviParams->MoviChunkPosStart + sizeof ( AVI_STREAM_LIST_MOVI ) , SEEK_SET ); ! 763: Pos = ftell ( pAviParams->FileOut ); ! 764: ! 765: /* Build the index : we seek/read one data chunk and seek/write the */ ! 766: /* corresponding infos at the end of the index, until we reach the */ ! 767: /* end of the 'movi' chunk. */ ! 768: while ( Pos < pAviParams->MoviChunkPosEnd ) ! 769: { ! 770: /* Read the header for this data chunk: ChunkName and ChunkSize */ ! 771: if (fread(&Chunk, sizeof(Chunk), 1, pAviParams->FileOut) != 1) ! 772: { ! 773: perror("Avi_BuildIndex"); ! 774: return false; ! 775: } ! 776: Size = Avi_ReadU32 ( Chunk.ChunkSize ); ! 777: ! 778: /* Write the index infos for this chunk */ ! 779: fseek ( pAviParams->FileOut , PosWrite , SEEK_SET ); ! 780: Avi_Store4cc ( ChunkIndex.identifier , (char *)Chunk.ChunkName ); /* 00dc, 00db, 01wb, ... */ ! 781: Avi_StoreU32 ( ChunkIndex.flags , AVIIF_KEYFRAME ); /* AVIIF_KEYFRAME */ ! 782: Avi_StoreU32 ( ChunkIndex.offset , Pos - pAviParams->MoviChunkPosStart - 8 ); /* pos relative to 'movi' */ ! 783: Avi_StoreU32 ( ChunkIndex.length , Size ); ! 784: fwrite ( &ChunkIndex , sizeof ( ChunkIndex ) , 1 , pAviParams->FileOut ); ! 785: PosWrite = ftell ( pAviParams->FileOut ); /* position for the next index */ ! 786: ! 787: /* Go to the next data chunk in the 'movi' chunk */ ! 788: Pos = Pos + sizeof ( Chunk ) + Size; /* position of the next data chunk */ ! 789: fseek ( pAviParams->FileOut , Pos , SEEK_SET ); ! 790: } ! 791: ! 792: /* Update the size of the 'idx1' chunk */ ! 793: Avi_StoreU32 ( TempSize , PosWrite - IndexChunkPosStart - 8 ); ! 794: if ( fseek ( pAviParams->FileOut , IndexChunkPosStart+4 , SEEK_SET ) != 0 ) ! 795: { ! 796: perror ( "Avi_BuildIndex" ); ! 797: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update idx1 header" ); ! 798: return false; ! 799: } ! 800: if ( fwrite ( TempSize , sizeof ( TempSize ) , 1 , pAviParams->FileOut ) != 1 ) ! 801: { ! 802: perror ( "Avi_BuildIndex" ); ! 803: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update idx1 header" ); ! 804: return false; ! 805: } ! 806: ! 807: return true; ! 808: } ! 809: ! 810: ! 811: static bool Avi_StartRecording_WithParams ( RECORD_AVI_PARAMS *pAviParams , char *AviFileName ) ! 812: { ! 813: AVI_STREAM_LIST_INFO ListInfo; ! 814: char InfoString[ 100 ]; ! 815: int Len , Len_rounded; ! 816: AVI_STREAM_LIST_MOVI ListMovi; ! 817: ! 818: ! 819: if ( bRecordingAvi == true ) /* already recording ? */ ! 820: return false; ! 821: ! 822: /* Compute some video parameters */ ! 823: pAviParams->Width = pAviParams->Surface->w - pAviParams->CropLeft - pAviParams->CropRight; ! 824: pAviParams->Height = pAviParams->Surface->h - pAviParams->CropTop - pAviParams->CropBottom; ! 825: pAviParams->BitCount = 24; ! 826: ! 827: #if !HAVE_LIBPNG ! 828: if ( pAviParams->VideoCodec == AVI_RECORD_VIDEO_CODEC_PNG ) ! 829: { ! 830: perror ( "AviStartRecording" ); ! 831: Log_AlertDlg ( LOG_ERROR, "AVI recording : Hatari was not built with libpng support" ); ! 832: return false; ! 833: } ! 834: #endif ! 835: ! 836: /* Open the file */ ! 837: pAviParams->FileOut = fopen ( AviFileName , "wb+" ); ! 838: if ( !pAviParams->FileOut ) ! 839: { ! 840: perror ( "AviStartRecording" ); ! 841: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to open file" ); ! 842: return false; ! 843: } ! 844: ! 845: /* Build the AVI header */ ! 846: Avi_BuildFileHeader ( pAviParams , &AviFileHeader ); ! 847: ! 848: /* Write the AVI header */ ! 849: if ( fwrite ( &AviFileHeader , sizeof ( AviFileHeader ) , 1 , pAviParams->FileOut ) != 1 ) ! 850: { ! 851: perror ( "AviStartRecording" ); ! 852: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write avi header" ); ! 853: return false; ! 854: } ! 855: ! 856: /* Write the INFO header */ ! 857: memset ( InfoString , 0 , sizeof ( InfoString ) ); ! 858: Len = snprintf ( InfoString , sizeof ( InfoString ) , "%s - the Atari ST, STE, TT and Falcon emulator" , PROG_NAME ) + 1; ! 859: Len_rounded = Len + ( Len % 2 == 0 ? 0 : 1 ); /* round Len to the next multiple of 2 */ ! 860: Avi_Store4cc ( ListInfo.ChunkName , "LIST" ); ! 861: Avi_StoreU32 ( ListInfo.ChunkSize , sizeof ( AVI_STREAM_LIST_INFO ) - 8 + Len_rounded ); ! 862: Avi_Store4cc ( ListInfo.Name , "INFO" ); ! 863: Avi_Store4cc ( ListInfo.Info.ChunkName , "ISFT" ); ! 864: Avi_StoreU32 ( ListInfo.Info.ChunkSize , Len ); ! 865: if ( fwrite ( &ListInfo , sizeof ( ListInfo ) , 1 , pAviParams->FileOut ) != 1 ) ! 866: { ! 867: perror ( "AviStartRecording" ); ! 868: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write info header" ); ! 869: return false; ! 870: } ! 871: /* Write the info string + '\0' and write an optionnal extra '\0' byte to get a total multiple of 2 */ ! 872: if ( fwrite ( InfoString , Len_rounded , 1 , pAviParams->FileOut ) != 1 ) ! 873: { ! 874: perror ( "AviStartRecording" ); ! 875: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write info header" ); ! 876: return false; ! 877: } ! 878: ! 879: /* Write the MOVI header */ ! 880: Avi_Store4cc ( ListMovi.ChunkName , "LIST" ); ! 881: Avi_StoreU32 ( ListMovi.ChunkSize , 0 ); /* completed when recording stops */ ! 882: Avi_Store4cc ( ListMovi.Name , "movi" ); ! 883: pAviParams->MoviChunkPosStart = ftell ( pAviParams->FileOut ); ! 884: if ( fwrite ( &ListMovi , sizeof ( ListMovi ) , 1 , pAviParams->FileOut ) != 1 ) ! 885: { ! 886: perror ( "AviStartRecording" ); ! 887: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to write movi header" ); ! 888: return false; ! 889: } ! 890: ! 891: ! 892: /* We're ok to record */ ! 893: Log_AlertDlg ( LOG_INFO, "AVI recording has been started"); ! 894: bRecordingAvi = true; ! 895: ! 896: return true; ! 897: } ! 898: ! 899: ! 900: ! 901: static bool Avi_StopRecording_WithParams ( RECORD_AVI_PARAMS *pAviParams ) ! 902: { ! 903: long FileSize; ! 904: Uint8 TempSize[4]; ! 905: ! 906: ! 907: if ( bRecordingAvi == false ) /* no recording ? */ ! 908: return true; ! 909: ! 910: /* Update the size of the 'movi' chunk */ ! 911: fseek ( pAviParams->FileOut , 0 , SEEK_END ); /* go to the end of the 'movi' chunk */ ! 912: pAviParams->MoviChunkPosEnd = ftell ( pAviParams->FileOut ); ! 913: Avi_StoreU32 ( TempSize , pAviParams->MoviChunkPosEnd - pAviParams->MoviChunkPosStart - 8 ); ! 914: ! 915: if ( fseek ( pAviParams->FileOut , pAviParams->MoviChunkPosStart+4 , SEEK_SET ) != 0 ) ! 916: { ! 917: perror ( "AviStopRecording" ); ! 918: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update movi header" ); ! 919: return false; ! 920: } ! 921: if ( fwrite ( TempSize , sizeof ( TempSize ) , 1 , pAviParams->FileOut ) != 1 ) ! 922: { ! 923: perror ( "AviStopRecording" ); ! 924: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update movi header" ); ! 925: return false; ! 926: } ! 927: ! 928: /* Build the index chunk */ ! 929: if ( ! Avi_BuildIndex ( pAviParams ) ) ! 930: { ! 931: perror ( "AviStopRecording" ); ! 932: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to build index" ); ! 933: return false; ! 934: } ! 935: ! 936: /* Update the avi header (file size, number of output frames, ...) */ ! 937: fseek ( pAviParams->FileOut , 0 , SEEK_END ); /* go to the end of the file */ ! 938: FileSize = ftell ( pAviParams->FileOut ); ! 939: ! 940: Avi_StoreU32 ( AviFileHeader.RiffHeader.filesize , FileSize - 8 ); /* 32 bits, limited to 4GB */ ! 941: Avi_StoreU32 ( AviFileHeader.AviHeader.Header.total_frames , pAviParams->TotalVideoFrames ); /* number of video frames */ ! 942: Avi_StoreU32 ( AviFileHeader.VideoStream.Header.data_length , pAviParams->TotalVideoFrames ); /* number of video frames */ ! 943: Avi_StoreU32 ( AviFileHeader.AudioStream.Header.data_length , pAviParams->TotalAudioSamples ); /* number of audio samples */ ! 944: ! 945: if ( fseek ( pAviParams->FileOut , 0 , SEEK_SET ) != 0 ) ! 946: { ! 947: perror ( "AviStopRecording" ); ! 948: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update avi header" ); ! 949: return false; ! 950: } ! 951: if ( fwrite ( &AviFileHeader , sizeof ( AviFileHeader ) , 1 , pAviParams->FileOut ) != 1 ) ! 952: { ! 953: perror ( "AviStopRecording" ); ! 954: Log_AlertDlg ( LOG_ERROR, "AVI recording : failed to update avi header" ); ! 955: return false; ! 956: } ! 957: ! 958: ! 959: /* Close the file */ ! 960: fclose ( pAviParams->FileOut ); ! 961: ! 962: Log_AlertDlg ( LOG_INFO, "AVI recording has been stopped"); ! 963: bRecordingAvi = false; ! 964: ! 965: return true; ! 966: } ! 967: ! 968: ! 969: ! 970: ! 971: /*-----------------------------------------------------------------------*/ ! 972: /** ! 973: * Are we recording an AVI ? ! 974: */ ! 975: bool Avi_AreWeRecording ( void ) ! 976: { ! 977: return bRecordingAvi; ! 978: } ! 979: ! 980: ! 981: ! 982: bool Avi_StartRecording ( char *FileName , bool CropGui , int Fps , int VideoCodec ) ! 983: { ! 984: memset ( &AviParams , 0 , sizeof ( AviParams ) ); ! 985: ! 986: AviParams.VideoCodec = VideoCodec; ! 987: AviParams.VideoCodecCompressionLevel = 9; /* png compression level */ ! 988: AviParams.AudioCodec = AVI_RECORD_AUDIO_CODEC_PCM; ! 989: AviParams.AudioFreq = ConfigureParams.Sound.nPlaybackFreq; ! 990: AviParams.Surface = sdlscrn; ! 991: AviParams.Fps = Fps; ! 992: ! 993: if ( !CropGui ) /* Keep gui's status bar */ ! 994: { ! 995: AviParams.CropLeft = 0; ! 996: AviParams.CropRight = 0; ! 997: AviParams.CropTop = 0; ! 998: AviParams.CropBottom = 0; ! 999: } ! 1000: else /* Record only the content of the Atari's screen */ ! 1001: { ! 1002: AviParams.CropLeft = 0; ! 1003: AviParams.CropRight = 0; ! 1004: AviParams.CropTop = 0; ! 1005: AviParams.CropBottom = Statusbar_GetHeight(); ! 1006: } ! 1007: ! 1008: ! 1009: return Avi_StartRecording_WithParams ( &AviParams , FileName ); ! 1010: } ! 1011: ! 1012: ! 1013: bool Avi_StopRecording ( void ) ! 1014: { ! 1015: return Avi_StopRecording_WithParams ( &AviParams ); ! 1016: } ! 1017: ! 1018:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.