![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screenSnapShot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to screenSnapShot.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
1.1.1.5 root 2: Hatari - screenSnapShot.c
1.1 root 3:
1.1.1.5 root 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: Screen Snapshots.
1.1 root 8: */
1.1.1.10! root 9: const char ScreenSnapShot_rcsid[] = "Hatari $Id: screenSnapShot.c,v 1.19 2008-11-16 09:42:12 thothy Exp $";
1.1 root 10:
1.1.1.2 root 11: #include <SDL.h>
12: #include <dirent.h>
13: #include <string.h>
1.1 root 14: #include "main.h"
1.1.1.6 root 15: #include "log.h"
1.1.1.8 root 16: #include "paths.h"
1.1 root 17: #include "screen.h"
18: #include "screenSnapShot.h"
19: #include "video.h"
1.1.1.9 root 20: /* after above that bring in config.h */
21: #if HAVE_LIBPNG
22: # include <png.h>
23: # include <assert.h>
24: #endif
1.1 root 25:
1.1.1.2 root 26:
1.1.1.9 root 27: bool bRecordingAnimation = FALSE; /* Recording animation? */
1.1.1.6 root 28: static int nScreenShots = 0; /* Number of screen shots saved */
1.1.1.9 root 29: static bool bGrabWhenChange;
1.1.1.6 root 30:
1.1 root 31:
1.1.1.2 root 32: /*-----------------------------------------------------------------------*/
1.1.1.8 root 33: /**
34: * Scan working directory to get the screenshot number
35: */
1.1.1.5 root 36: static void ScreenSnapShot_GetNum(void)
37: {
1.1.1.8 root 38: char dummy[5];
39: int i, num;
40: DIR *workingdir = opendir(Paths_GetWorkingDir());
41: struct dirent *file;
42:
43: nScreenShots = 0;
44: if (workingdir == NULL) return;
45:
46: file = readdir(workingdir);
47: while (file != NULL)
48: {
49: if ( strncmp("grab", file->d_name, 4) == 0 )
50: {
51: /* copy next 4 numbers */
52: for (i = 0; i < 4; i++)
53: {
54: if (file->d_name[4+i] >= '0' && file->d_name[4+i] <= '9')
55: dummy[i] = file->d_name[4+i];
56: else
57: break;
58: }
59:
60: dummy[i] = '\0'; /* null terminate */
61: num = atoi(dummy);
62: if (num > nScreenShots) nScreenShots = num;
63: }
64: /* next file.. */
65: file = readdir(workingdir);
66: }
67:
68: closedir(workingdir);
1.1.1.2 root 69: }
70:
1.1.1.8 root 71:
1.1.1.9 root 72: #if HAVE_LIBPNG
1.1.1.2 root 73: /*-----------------------------------------------------------------------*/
1.1.1.8 root 74: /**
1.1.1.9 root 75: * Unpack 8-bit data with RGB palette to 24-bit RGB pixels
76: */
77: static inline void ScreenSnapShot_8to24Bits(Uint8 *dst, Uint8 *src, int w, SDL_Color *colors)
78: {
79: int x;
80: for (x = 0; x < w; x++, src++) {
81: *dst++ = colors[*src].r;
82: *dst++ = colors[*src].g;
83: *dst++ = colors[*src].b;
84: }
85: }
86:
87: /**
88: * Unpack 16-bit RGB pixels to 24-bit RGB pixels
89: */
90: static inline void ScreenSnapShot_16to24Bits(Uint8 *dst, Uint16 *src, int w, SDL_PixelFormat *fmt)
91: {
92: int x;
93: for (x = 0; x < w; x++, src++) {
94: *dst++ = (((*src & fmt->Rmask) >> fmt->Rshift) << fmt->Rloss);
95: *dst++ = (((*src & fmt->Gmask) >> fmt->Gshift) << fmt->Gloss);
96: *dst++ = (((*src & fmt->Bmask) >> fmt->Bshift) << fmt->Bloss);
97: }
98: }
99:
100: /**
101: * unpack 32-bit RGBA pixels to 24-bit RGB pixels
102: */
103: static inline void ScreenSnapShot_32to24Bits(Uint8 *dst, Uint8 *src, int w)
104: {
105: int x;
106: for (x = 0; x < w; x++, src += 4) {
107: #if SDL_BYTEORDER == SDL_BIG_ENDIAN
108: *dst++ = src[1];
109: *dst++ = src[2];
110: *dst++ = src[3];
111: #else
112: *dst++ = src[2];
113: *dst++ = src[1];
114: *dst++ = src[0];
115: #endif
116: }
117: }
118:
119: /**
120: * Save given SDL surface as PNG. Return zero for success.
121: */
122: static int ScreenSnapShot_SavePNG(SDL_Surface *surface, const char *filename)
123: {
124: int y, ret = -1;
125: int w = surface->w;
126: int h = surface->h;
127: Uint8 *src_ptr, *row_ptr;
128: Uint8 rowbuf[3*surface->w];
129: SDL_PixelFormat *fmt = surface->format;
130: png_colorp palette_ptr = NULL;
131: png_infop info_ptr = NULL;
132: png_structp png_ptr;
133: png_text pngtext;
134: char key[] = "Title";
135: char text[] = "Hatari screenshot";
136: FILE *fp = NULL;
137:
138: /* Create and initialize the png_struct with error handler functions. */
139: png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
140: if (!png_ptr)
141: {
142: return ret;
143: }
144:
145: /* Allocate/initialize the image information data. */
146: info_ptr = png_create_info_struct(png_ptr);
147: if (!info_ptr)
148: goto png_cleanup;
149:
150: /* libpng ugliness: Set error handling when not supplying own
151: * error handling functions in the png_create_write_struct() call.
152: */
153: if (setjmp(png_jmpbuf(png_ptr)))
154: goto png_cleanup;
155:
156: fp = fopen(filename, "wb");
157: if (!fp)
158: goto png_cleanup;
159:
160: /* initialize the png structure */
161: png_init_io(png_ptr, fp);
162:
163: /* image data properties */
164: png_set_IHDR(png_ptr, info_ptr, w, h, 8, PNG_COLOR_TYPE_RGB,
165: PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
166: PNG_FILTER_TYPE_DEFAULT);
167:
168: /* image info */
169: pngtext.key = key;
170: pngtext.text = text;
171: pngtext.compression = PNG_TEXT_COMPRESSION_NONE;
172: #ifdef PNG_iTXt_SUPPORTED
173: pngtext.lang = NULL;
174: #endif
175: png_set_text(png_ptr, info_ptr, &pngtext, 1);
176:
177: /* write the file header information */
178: png_write_info(png_ptr, info_ptr);
179:
180: /* write surface data row at the time */
181: src_ptr = surface->pixels;
182: for (y = 0; y < h; y++) {
183: switch (fmt->BytesPerPixel) {
184: case 1:
185: /* unpack 8-bit data with RGB palette */
186: row_ptr = rowbuf;
187: ScreenSnapShot_8to24Bits(row_ptr, src_ptr, w, fmt->palette->colors);
188: break;
189: case 2:
190: /* unpack 16-bit RGB pixels */
191: row_ptr = rowbuf;
192: ScreenSnapShot_16to24Bits(row_ptr, (Uint16*)src_ptr, w, fmt);
193: break;
194: case 3:
195: /* PNG can handle 24-bits */
196: row_ptr = src_ptr;
197: break;
198: case 4:
199: /* unpack 32-bit RGBA pixels */
200: row_ptr = rowbuf;
201: ScreenSnapShot_32to24Bits(row_ptr, src_ptr, w);
202: break;
203: }
204: src_ptr += surface->pitch;
205: SDL_UnlockSurface(surface);
206: png_write_row(png_ptr, rowbuf);
207: }
208:
209: /* write the additional chuncks to the PNG file */
210: png_write_end(png_ptr, info_ptr);
211:
212: ret = 0;
213: png_cleanup:
214: if (fp)
215: fclose(fp);
216: if (palette_ptr)
217: free(palette_ptr);
218: if (png_ptr)
219: png_destroy_write_struct(&png_ptr, NULL);
220: return ret;
221: }
222: #endif
223:
224:
225: /*-----------------------------------------------------------------------*/
226: /**
227: * Save screen shot file with filename 'grab0000.<ext>','grab0001.<ext>'...
228: * Whether screen shots are saved as BMP or PNG depends on Hatari configuration.
1.1.1.8 root 229: */
1.1 root 230: void ScreenSnapShot_SaveScreen(void)
231: {
1.1.1.8 root 232: char *szFileName = malloc(FILENAME_MAX);
1.1.1.6 root 233:
1.1.1.8 root 234: if (!szFileName) return;
1.1.1.5 root 235:
1.1.1.8 root 236: ScreenSnapShot_GetNum();
237: /* Create our filename */
238: nScreenShots++;
1.1.1.9 root 239: #if HAVE_LIBPNG
240: /* try first PNG */
241: sprintf(szFileName,"%s/grab%4.4d.png", Paths_GetWorkingDir(), nScreenShots);
242: if (ScreenSnapShot_SavePNG(sdlscrn, szFileName) == 0)
243: {
244: fprintf(stderr, "Screen dump saved to: %s\n", szFileName);
245: free(szFileName);
246: return;
247: }
248: #endif
1.1.1.8 root 249: sprintf(szFileName,"%s/grab%4.4d.bmp", Paths_GetWorkingDir(), nScreenShots);
250: if (SDL_SaveBMP(sdlscrn, szFileName))
251: fprintf(stderr, "Screen dump failed!\n");
252: else
253: fprintf(stderr, "Screen dump saved to: %s\n", szFileName);
1.1.1.5 root 254:
1.1.1.8 root 255: free(szFileName);
1.1 root 256: }
257:
1.1.1.8 root 258:
1.1.1.2 root 259: /*-----------------------------------------------------------------------*/
1.1.1.8 root 260: /**
261: * Are we recording an animation?
262: */
1.1.1.9 root 263: bool ScreenSnapShot_AreWeRecording(void)
1.1 root 264: {
1.1.1.8 root 265: return bRecordingAnimation;
1.1 root 266: }
267:
1.1.1.8 root 268:
1.1 root 269: /*-----------------------------------------------------------------------*/
1.1.1.8 root 270: /**
271: * Start recording animation
272: */
1.1.1.9 root 273: void ScreenSnapShot_BeginRecording(bool bCaptureChange)
1.1 root 274: {
1.1.1.8 root 275: /* Set in globals */
276: bGrabWhenChange = bCaptureChange;
1.1.1.9 root 277:
1.1.1.8 root 278: /* Start animation */
279: bRecordingAnimation = TRUE;
280:
281: /* And inform user */
282: Log_AlertDlg(LOG_INFO, "Screenshot recording started.");
1.1 root 283: }
284:
1.1.1.8 root 285:
1.1 root 286: /*-----------------------------------------------------------------------*/
1.1.1.8 root 287: /**
288: * Stop recording animation
289: */
1.1 root 290: void ScreenSnapShot_EndRecording()
291: {
1.1.1.8 root 292: /* Were we recording? */
293: if (bRecordingAnimation)
294: {
295: /* Stop animation */
296: bRecordingAnimation = FALSE;
1.1.1.6 root 297:
1.1.1.8 root 298: /* And inform user */
299: Log_AlertDlg(LOG_INFO, "Screenshot recording stopped.");
300: }
1.1 root 301: }
302:
1.1.1.8 root 303:
1.1.1.2 root 304: /*-----------------------------------------------------------------------*/
1.1.1.8 root 305: /**
306: * Recording animation frame
307: */
1.1.1.9 root 308: void ScreenSnapShot_RecordFrame(bool bFrameChanged)
1.1 root 309: {
1.1.1.9 root 310: /* As we recording and do we really want to save this frame? */
311: if (bRecordingAnimation && (!bGrabWhenChange || bFrameChanged))
1.1.1.8 root 312: {
1.1.1.9 root 313: ScreenSnapShot_SaveScreen();
1.1.1.8 root 314: }
1.1 root 315: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.