![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to avi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / main|
Return to avi.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / main |
1.1 ! root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */ ! 2: ! 3: #include <sys/types.h> ! 4: #include <unistd.h> ! 5: #include <stdio.h> ! 6: #include <stdlib.h> ! 7: #include <errno.h> ! 8: ! 9: #include "generator.h" ! 10: ! 11: #include "vdp.h" ! 12: #include "ui.h" ! 13: #include "dib.h" ! 14: #include "avi.h" ! 15: ! 16: #ifdef JPEG ! 17: # include "jpeglib.h" ! 18: #endif ! 19: ! 20: /* From vfw.h */ ! 21: ! 22: /* The following is a short description of the AVI file format. Please ! 23: * see the accompanying documentation for a full explanation. ! 24: * ! 25: * An AVI file is the following RIFF form: ! 26: * ! 27: * RIFF('AVI' ! 28: * LIST('hdrl' ! 29: * avih(<MainAVIHeader>) ! 30: * LIST ('strl' ! 31: * strh(<Stream header>) ! 32: * strf(<Stream format>) ! 33: * ... additional header data ! 34: * LIST('movi' ! 35: * { LIST('rec' ! 36: * SubChunk... ! 37: * ) ! 38: * | SubChunk } .... ! 39: * ) ! 40: * [ <AVIIndex> ] ! 41: * ) ! 42: * ! 43: * The main file header specifies how many streams are present. For ! 44: * each one, there must be a stream header chunk and a stream format ! 45: * chunk, enlosed in a 'strl' LIST chunk. The 'strf' chunk contains ! 46: * type-specific format information; for a video stream, this should ! 47: * be a BITMAPINFO structure, including palette. For an audio stream, ! 48: * this should be a WAVEFORMAT (or PCMWAVEFORMAT) structure. ! 49: * ! 50: * The actual data is contained in subchunks within the 'movi' LIST ! 51: * chunk. The first two characters of each data chunk are the ! 52: * stream number with which that data is associated. ! 53: * ! 54: * Some defined chunk types: ! 55: * Video Streams: ! 56: * ##db: RGB DIB bits ! 57: * ##dc: RLE8 compressed DIB bits ! 58: * ##pc: Palette Change ! 59: * ! 60: * Audio Streams: ! 61: * ##wb: waveform audio bytes ! 62: * ! 63: * The grouping into LIST 'rec' chunks implies only that the contents of ! 64: * the chunk should be read into memory at the same time. This ! 65: * grouping is used for files specifically intended to be played from ! 66: * CD-ROM. ! 67: * ! 68: * The index chunk at the end of the file should contain one entry for ! 69: * each data chunk in the file. ! 70: * ! 71: * Limitations for the current software: ! 72: * Only one video stream and one audio stream are allowed. ! 73: * The streams must start at the beginning of the file. ! 74: * ! 75: * ! 76: * To register codec types please obtain a copy of the Multimedia ! 77: * Developer Registration Kit from: ! 78: * ! 79: * Microsoft Corporation ! 80: * Multimedia Systems Group ! 81: * Product Marketing ! 82: * One Microsoft Way ! 83: * Redmond, WA 98052-6399 ! 84: * ! 85: */ ! 86: ! 87: #ifdef JPEG ! 88: struct jpeg_compress_struct avi_cinfo; ! 89: struct jpeg_error_mgr avi_jerr; ! 90: #endif ! 91: ! 92: t_avi *avi_open(char *filename, t_aviinfo *info, int jpeg) ! 93: { ! 94: t_avi *avi; ! 95: int saved_errno; ! 96: t_avi_header h; ! 97: unsigned int rate; ! 98: uint32 usperframe; ! 99: t_bmih dib; ! 100: t_bmih *diblittle; ! 101: ! 102: memset(&h, 0, sizeof(t_avi_header)); ! 103: if ((avi = malloc(sizeof(t_avi))) == NULL) ! 104: return NULL; ! 105: memset(avi, 0, sizeof(t_avi)); ! 106: avi->fd = fopen(filename, "wb"); ! 107: if (avi->fd == NULL) { ! 108: saved_errno = errno; ! 109: free(avi); ! 110: errno = saved_errno; ! 111: return NULL; ! 112: } ! 113: memcpy(&avi->info, info, sizeof(avi->info)); ! 114: ! 115: /* record items that need to be post-written */ ! 116: avi->off_length = (char *)&h.length - (char *)&h; ! 117: avi->off_movilength = (char *)&h.movi.length - (char *)&h; ! 118: avi->off_totalframes = (char *)&h.hdrl.avih.TotalFrames - (char *)&h; ! 119: avi->off_videolength = (char *)&h.hdrl.strl_video.strh.Length - (char *)&h; ! 120: avi->off_audiolength = (char *)&h.hdrl.strl_audio.strh.Length - (char *)&h; ! 121: ! 122: rate = 0; ! 123: rate+= info->width * info->height * 3; /* 24 bit bmp */ ! 124: rate+= 2 * 2 * info->sampspersec * info->fps / 1000; /* stereo, 16 bit */ ! 125: usperframe = (long long)1000000000 / info->fps; ! 126: memcpy(h.riff, "RIFF", 4); ! 127: h.length = 0; /* to be filled in later */ ! 128: memcpy(h.avi, "AVI ", 4); ! 129: memcpy(h.hdrl.list, "LIST", 4); ! 130: h.hdrl.length = LOCENDIAN32L(sizeof(h.hdrl) - 8); ! 131: memcpy(h.hdrl.hdrl, "hdrl", 4); ! 132: memcpy(h.hdrl.avih.avih, "avih", 4); ! 133: h.hdrl.avih.length = LOCENDIAN32L(sizeof(h.hdrl.avih) - 8); ! 134: h.hdrl.avih.MicroSecPerFrame = LOCENDIAN32L(usperframe); ! 135: h.hdrl.avih.MaxBytesPerSec = LOCENDIAN32L(rate * info->fps / 1000); ! 136: h.hdrl.avih.PaddingGranularity = 0; ! 137: h.hdrl.avih.Flags = LOCENDIAN32L(AVIF_ISINTERLEAVED); ! 138: h.hdrl.avih.TotalFrames = 0; /* to be filled in later */ ! 139: h.hdrl.avih.InitialFrames = 0; ! 140: h.hdrl.avih.Streams = LOCENDIAN32L(2); ! 141: h.hdrl.avih.SuggestedBufferSize = LOCENDIAN32L(rate * 2); /* 2 for luck */ ! 142: h.hdrl.avih.Width = LOCENDIAN32L(info->width); ! 143: h.hdrl.avih.Height = LOCENDIAN32L(info->height); ! 144: ! 145: /* VIDEO strl LIST */ ! 146: ! 147: memcpy(h.hdrl.strl_video.list, "LIST", 4); ! 148: h.hdrl.strl_video.length = LOCENDIAN32L(sizeof(h.hdrl.strl_video) - 8); ! 149: memcpy(h.hdrl.strl_video.strl, "strl", 4); ! 150: memcpy(h.hdrl.strl_video.strh.strh, "strh", 4); ! 151: h.hdrl.strl_video.strh.length = ! 152: LOCENDIAN32L(sizeof(h.hdrl.strl_video.strh) - 8); ! 153: memcpy(h.hdrl.strl_video.strh.Type, "vids", 4); ! 154: memset(&h.hdrl.strl_video.strh.Handler, 0, 4); ! 155: h.hdrl.strl_video.strh.Flags = LOCENDIAN32L(0); ! 156: h.hdrl.strl_video.strh.Priority = LOCENDIAN16L(0); ! 157: h.hdrl.strl_video.strh.Language = LOCENDIAN16L(0); ! 158: h.hdrl.strl_video.strh.InitialFrames = LOCENDIAN32L(0); ! 159: h.hdrl.strl_video.strh.Scale = LOCENDIAN32L(usperframe); ! 160: h.hdrl.strl_video.strh.Rate = LOCENDIAN32L(1000000); ! 161: h.hdrl.strl_video.strh.Start = LOCENDIAN32L(0); ! 162: h.hdrl.strl_video.strh.Length = 0; /* to be filled in later */ ! 163: h.hdrl.strl_video.strh.SuggestedBufferSize = LOCENDIAN32L(rate * 2); ! 164: h.hdrl.strl_video.strh.Quality = LOCENDIAN32L(0); /* this or 10,000? */ ! 165: h.hdrl.strl_video.strh.SampleSize = LOCENDIAN32L(0); /* n/a XXX: Check */ ! 166: h.hdrl.strl_video.strh.rcFrame.left = LOCENDIAN32L(0); ! 167: h.hdrl.strl_video.strh.rcFrame.top = LOCENDIAN32L(0); ! 168: h.hdrl.strl_video.strh.rcFrame.right = LOCENDIAN32L(info->width); ! 169: h.hdrl.strl_video.strh.rcFrame.bottom = LOCENDIAN32L(info->height); ! 170: memcpy(h.hdrl.strl_video.strf.strf, "strf", 4); ! 171: h.hdrl.strl_video.strf.length = ! 172: LOCENDIAN32L(sizeof(h.hdrl.strl_video.strf) - 8); ! 173: dib_setheader(&dib, info->width, info->height); ! 174: diblittle = &h.hdrl.strl_video.strf.bmih; ! 175: diblittle->biSize = LOCENDIAN32L(dib.biSize); ! 176: diblittle->biWidth = LOCENDIAN32L(dib.biWidth); ! 177: diblittle->biHeight = LOCENDIAN32L(dib.biHeight); ! 178: diblittle->biPlanes = LOCENDIAN16L(dib.biPlanes); ! 179: diblittle->biBitCount = LOCENDIAN16L(dib.biBitCount); ! 180: diblittle->biCompression = LOCENDIAN32L(dib.biCompression); ! 181: diblittle->biSizeImage = LOCENDIAN32L(dib.biSizeImage); ! 182: diblittle->biXPelsPerMeter = LOCENDIAN32L(dib.biXPelsPerMeter); ! 183: diblittle->biYPelsPerMeter = LOCENDIAN32L(dib.biYPelsPerMeter); ! 184: diblittle->biClrUsed = LOCENDIAN32L(dib.biClrUsed); ! 185: diblittle->biClrImportant = LOCENDIAN32L(dib.biClrImportant); ! 186: ! 187: /* AUDIO strl LIST */ ! 188: ! 189: memcpy(h.hdrl.strl_audio.list, "LIST", 4); ! 190: h.hdrl.strl_audio.length = LOCENDIAN32L(sizeof(h.hdrl.strl_audio) - 8); ! 191: memcpy(h.hdrl.strl_audio.strl, "strl", 4); ! 192: memcpy(h.hdrl.strl_audio.strh.strh, "strh", 4); ! 193: h.hdrl.strl_audio.strh.length = ! 194: LOCENDIAN32L(sizeof(h.hdrl.strl_audio.strh) - 8); ! 195: memcpy(h.hdrl.strl_audio.strh.Type, "auds", 4); ! 196: memset(&h.hdrl.strl_audio.strh.Handler, 0, 4); ! 197: h.hdrl.strl_audio.strh.Flags = LOCENDIAN32L(0); ! 198: h.hdrl.strl_audio.strh.Priority = LOCENDIAN16L(0); ! 199: h.hdrl.strl_audio.strh.Language = LOCENDIAN16L(0); ! 200: h.hdrl.strl_audio.strh.InitialFrames = LOCENDIAN32L(0); ! 201: h.hdrl.strl_audio.strh.Scale = LOCENDIAN32L(1); ! 202: h.hdrl.strl_audio.strh.Rate = LOCENDIAN32L(info->sampspersec); ! 203: h.hdrl.strl_audio.strh.Start = LOCENDIAN32L(0); ! 204: h.hdrl.strl_audio.strh.Length = 0; /* to be filled in later */ ! 205: h.hdrl.strl_audio.strh.SuggestedBufferSize = 0; /* XXX: ok? */ ! 206: h.hdrl.strl_audio.strh.Quality = LOCENDIAN32L(0); /* this or 10,000? */ ! 207: h.hdrl.strl_audio.strh.SampleSize = LOCENDIAN32L(4); /* stereo 16 bit */ ! 208: h.hdrl.strl_audio.strh.rcFrame.left = LOCENDIAN32L(0); /* n/a */ ! 209: h.hdrl.strl_audio.strh.rcFrame.top = LOCENDIAN32L(0); /* n/a */ ! 210: h.hdrl.strl_audio.strh.rcFrame.right = LOCENDIAN32L(0); /* n/a */ ! 211: h.hdrl.strl_audio.strh.rcFrame.bottom = LOCENDIAN32L(0); /* n/a */ ! 212: memcpy(h.hdrl.strl_audio.strf.strf, "strf", 4); ! 213: h.hdrl.strl_audio.strf.length = ! 214: LOCENDIAN32L(sizeof(h.hdrl.strl_audio.strf) - 8); ! 215: h.hdrl.strl_audio.strf.wFormatTag = LOCENDIAN16L(WAVE_FORMAT_PCM); ! 216: h.hdrl.strl_audio.strf.nChannels = LOCENDIAN16L(2); ! 217: h.hdrl.strl_audio.strf.nSamplesPerSec = LOCENDIAN32L(info->sampspersec); ! 218: h.hdrl.strl_audio.strf.nAvgBytesPerSec = LOCENDIAN32L(info->sampspersec * 4); ! 219: h.hdrl.strl_audio.strf.nBlockAlign = LOCENDIAN16L(4); /* stereo 16 bit */ ! 220: h.hdrl.strl_audio.strf.wBitsPerSample = LOCENDIAN16L(16); ! 221: ! 222: /* trailing movi... */ ! 223: ! 224: memcpy(h.movi.list, "LIST", 4); ! 225: h.movi.length = 0; /* to be filled in later */ ! 226: memcpy(h.movi.movi, "movi", 4); ! 227: ! 228: #ifdef JPEG ! 229: if (jpeg) { ! 230: memcpy(&h.hdrl.strl_video.strh.Handler, "MJPG", 4); ! 231: memcpy(&diblittle->biCompression, "MJPG", 4); ! 232: avi->jpeg = 1; ! 233: avi->bgr = 0; /* jpeg needs RGB data */ ! 234: avi_cinfo.err = jpeg_std_error(&avi_jerr); ! 235: jpeg_create_compress(&avi_cinfo); ! 236: jpeg_stdio_dest(&avi_cinfo, avi->fd); ! 237: avi_cinfo.image_width = avi->info.width; ! 238: avi_cinfo.image_height = avi->info.height; ! 239: avi_cinfo.input_components = 3; ! 240: avi_cinfo.in_color_space = JCS_RGB; ! 241: jpeg_set_defaults(&avi_cinfo); ! 242: jpeg_set_quality(&avi_cinfo, info->jpegquality, 0); ! 243: } else { ! 244: #endif ! 245: avi->jpeg = 0; ! 246: avi->bgr = 1; /* uncompressed avi needs BGR data */ ! 247: #ifdef JPEG ! 248: } ! 249: #endif ! 250: ! 251: /* pre-create ##db, ##wb chunk headers */ ! 252: sprintf(avi->dibchunkh, "00db"); ! 253: sprintf(avi->wavechunkh, "01wb"); ! 254: ! 255: avi->linebytes = ((3 * info->width) + 3) & ~3; /* round up */ ! 256: if (fwrite(&h, sizeof(h), 1, avi->fd) != 1) { ! 257: free(avi); ! 258: fclose(avi->fd); ! 259: errno = EIO; ! 260: return NULL; ! 261: } ! 262: avi->frames = 0; ! 263: avi->audiolength = 0; ! 264: avi->movilength = 4; /* "movi" string */ ! 265: return avi; ! 266: } ! 267: ! 268: static int avi_update32(t_avi *avi, uint32 offset, uint32 data) ! 269: { ! 270: uint32 little_data; ! 271: ! 272: if (fseek(avi->fd, offset, SEEK_SET) != 0) ! 273: return -1; ! 274: ! 275: little_data = LOCENDIAN32L(data); ! 276: if (fwrite(&little_data, 4, 1, avi->fd) != 1) { ! 277: errno = EIO; ! 278: return -1; ! 279: } ! 280: return 0; ! 281: } ! 282: ! 283: int avi_close(t_avi *avi) ! 284: { ! 285: int saved_errno; ! 286: long pos; ! 287: ! 288: if ((pos = ftell(avi->fd)) == -1) ! 289: return -1; ! 290: ! 291: if (avi_update32(avi, avi->off_length, pos - 8) != 0 || ! 292: avi_update32(avi, avi->off_movilength, avi->movilength) != 0 || ! 293: avi_update32(avi, avi->off_totalframes, avi->frames) != 0 || ! 294: avi_update32(avi, avi->off_videolength, avi->frames) != 0 || ! 295: avi_update32(avi, avi->off_audiolength, avi->audiolength) != 0) { ! 296: saved_errno = errno; ! 297: fclose(avi->fd); ! 298: errno = saved_errno; ! 299: return -1; ! 300: } ! 301: if (fclose(avi->fd) != 0) ! 302: return -1; ! 303: #ifdef JPEG ! 304: jpeg_destroy_compress(&avi_cinfo); ! 305: #endif ! 306: return 0; ! 307: } ! 308: ! 309: #ifdef JPEG ! 310: ! 311: int avi_video_jpeg(t_avi *avi, uint8 *video) ! 312: { ! 313: JSAMPROW row[1]; ! 314: unsigned int line; ! 315: long pos1, pos2; ! 316: int pad; ! 317: uint32 zero = 0; ! 318: ! 319: if ((pos1 = ftell(avi->fd)) == -1) ! 320: return -1; ! 321: ! 322: *(uint32 *)(avi->dibchunkh + 4) = 0; ! 323: if (fwrite(avi->dibchunkh, 8, 1, avi->fd) != 1) { ! 324: errno = EIO; ! 325: return -1; ! 326: } ! 327: jpeg_start_compress(&avi_cinfo, TRUE); ! 328: for (line = 0; line < avi->info.height; line++) { ! 329: row[0] = video + line * (3 * avi->info.width); ! 330: jpeg_write_scanlines(&avi_cinfo, row, 1); ! 331: } ! 332: jpeg_finish_compress(&avi_cinfo); ! 333: ! 334: if ((pos2 = ftell(avi->fd)) == -1) ! 335: return -1; ! 336: ! 337: pad = ((pos2 & 3) == 0 ? 0 : (4 - (pos2 & 3))); ! 338: if (fwrite(&zero, pad, 1, avi->fd) != 1) { ! 339: errno = EIO; ! 340: return -1; ! 341: } ! 342: ! 343: /* write chunk length at pos1 + 4 */ ! 344: avi_update32(avi, pos1 + 4, pos2 - pos1 + pad - 8); ! 345: ! 346: if (fseek(avi->fd, 0, SEEK_END) != 0) ! 347: return -1; ! 348: ! 349: avi->frames+= 1; ! 350: avi->movilength+= pos2 - pos1 + pad; ! 351: return 0; ! 352: } ! 353: ! 354: #endif ! 355: ! 356: int avi_video_raw(t_avi *avi, uint8 *video) ! 357: { ! 358: uint32 size; ! 359: unsigned int line, x; ! 360: uint8 buf[3 * 1024]; ! 361: uint8 *p, *v; ! 362: ! 363: if (avi->linebytes > sizeof(buf)) ! 364: ui_err("avi_video_raw buffer too small"); ! 365: ! 366: size = avi->linebytes * avi->info.height; ! 367: ! 368: *(uint32 *)(avi->dibchunkh + 4) = LOCENDIAN32L(size); ! 369: if (fwrite(avi->dibchunkh, 8, 1, avi->fd) != 1) { ! 370: errno = EIO; ! 371: return -1; ! 372: } ! 373: /* convert from RGB to BGR */ ! 374: for (line = 0; line < avi->info.height; line++) { ! 375: v = video + (avi->info.height - line - 1) * (avi->info.width * 3); ! 376: p = buf; ! 377: for (x = 0; x < avi->info.width; x++) { ! 378: *p++ = v[2]; ! 379: *p++ = v[1]; ! 380: *p++ = v[0]; ! 381: v+= 3; ! 382: } ! 383: /* we should have avi->linebytes of data - pad with zeros */ ! 384: for (x = 0; x < (avi->linebytes - (avi->info.width * 3)); x++) ! 385: *p++ = '\0'; /* pad */ ! 386: if (fwrite(buf, avi->linebytes, 1, avi->fd) != 1) { ! 387: errno = EIO; ! 388: return -1; ! 389: } ! 390: } ! 391: avi->frames+= 1; ! 392: avi->movilength+= 8 + avi->linebytes * avi->info.height; ! 393: return 0; ! 394: } ! 395: ! 396: int avi_video(t_avi *avi, uint8 *video) ! 397: { ! 398: #ifdef JPEG ! 399: if (avi->jpeg) ! 400: return avi_video_jpeg(avi, video); ! 401: #endif ! 402: return avi_video_raw(avi, video); ! 403: } ! 404: ! 405: int avi_audio(t_avi *avi, uint8 *audio, uint32 samples) ! 406: { ! 407: /* audio format is left/right 16 bit little samples */ ! 408: ! 409: *(uint32 *)(avi->wavechunkh + 4) = LOCENDIAN32L(4 * samples); ! 410: if (fwrite(avi->wavechunkh, 8, 1, avi->fd) != 1 || ! 411: fwrite(audio, 4 * samples, 1, avi->fd) != 1) { ! 412: errno = EIO; ! 413: return -1; ! 414: } ! 415: avi->audiolength+= samples; ! 416: avi->movilength+= 8 + 4 * samples; ! 417: return 0; ! 418: } ! 419:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.