diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemansi.c | 167 |
1 files changed, 167 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemansi.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemansi.c new file mode 100644 index 0000000..b5da474 --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jmemansi.c | |||
@@ -0,0 +1,167 @@ | |||
1 | /* | ||
2 | * jmemansi.c | ||
3 | * | ||
4 | * Copyright (C) 1992-1996, Thomas G. Lane. | ||
5 | * This file is part of the Independent JPEG Group's software. | ||
6 | * For conditions of distribution and use, see the accompanying README file. | ||
7 | * | ||
8 | * This file provides a simple generic implementation of the system- | ||
9 | * dependent portion of the JPEG memory manager. This implementation | ||
10 | * assumes that you have the ANSI-standard library routine tmpfile(). | ||
11 | * Also, the problem of determining the amount of memory available | ||
12 | * is shoved onto the user. | ||
13 | */ | ||
14 | |||
15 | #define JPEG_INTERNALS | ||
16 | #include "jinclude.h" | ||
17 | #include "jpeglib.h" | ||
18 | #include "jmemsys.h" /* import the system-dependent declarations */ | ||
19 | |||
20 | #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ | ||
21 | extern void * malloc JPP((size_t size)); | ||
22 | extern void free JPP((void *ptr)); | ||
23 | #endif | ||
24 | |||
25 | #ifndef SEEK_SET /* pre-ANSI systems may not define this; */ | ||
26 | #define SEEK_SET 0 /* if not, assume 0 is correct */ | ||
27 | #endif | ||
28 | |||
29 | |||
30 | /* | ||
31 | * Memory allocation and freeing are controlled by the regular library | ||
32 | * routines malloc() and free(). | ||
33 | */ | ||
34 | |||
35 | GLOBAL(void *) | ||
36 | jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) | ||
37 | { | ||
38 | return (void *) malloc(sizeofobject); | ||
39 | } | ||
40 | |||
41 | GLOBAL(void) | ||
42 | jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) | ||
43 | { | ||
44 | free(object); | ||
45 | } | ||
46 | |||
47 | |||
48 | /* | ||
49 | * "Large" objects are treated the same as "small" ones. | ||
50 | * NB: although we include FAR keywords in the routine declarations, | ||
51 | * this file won't actually work in 80x86 small/medium model; at least, | ||
52 | * you probably won't be able to process useful-size images in only 64KB. | ||
53 | */ | ||
54 | |||
55 | GLOBAL(void FAR *) | ||
56 | jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) | ||
57 | { | ||
58 | return (void FAR *) malloc(sizeofobject); | ||
59 | } | ||
60 | |||
61 | GLOBAL(void) | ||
62 | jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) | ||
63 | { | ||
64 | free(object); | ||
65 | } | ||
66 | |||
67 | |||
68 | /* | ||
69 | * This routine computes the total memory space available for allocation. | ||
70 | * It's impossible to do this in a portable way; our current solution is | ||
71 | * to make the user tell us (with a default value set at compile time). | ||
72 | * If you can actually get the available space, it's a good idea to subtract | ||
73 | * a slop factor of 5% or so. | ||
74 | */ | ||
75 | |||
76 | #ifndef DEFAULT_MAX_MEM /* so can override from makefile */ | ||
77 | #define DEFAULT_MAX_MEM 1000000L /* default: one megabyte */ | ||
78 | #endif | ||
79 | |||
80 | GLOBAL(long) | ||
81 | jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, | ||
82 | long max_bytes_needed, long already_allocated) | ||
83 | { | ||
84 | return cinfo->mem->max_memory_to_use - already_allocated; | ||
85 | } | ||
86 | |||
87 | |||
88 | /* | ||
89 | * Backing store (temporary file) management. | ||
90 | * Backing store objects are only used when the value returned by | ||
91 | * jpeg_mem_available is less than the total space needed. You can dispense | ||
92 | * with these routines if you have plenty of virtual memory; see jmemnobs.c. | ||
93 | */ | ||
94 | |||
95 | |||
96 | METHODDEF(void) | ||
97 | read_backing_store (j_common_ptr cinfo, backing_store_ptr info, | ||
98 | void FAR * buffer_address, | ||
99 | long file_offset, long byte_count) | ||
100 | { | ||
101 | if (fseek(info->temp_file, file_offset, SEEK_SET)) | ||
102 | ERREXIT(cinfo, JERR_TFILE_SEEK); | ||
103 | if (JFREAD(info->temp_file, buffer_address, byte_count) | ||
104 | != (size_t) byte_count) | ||
105 | ERREXIT(cinfo, JERR_TFILE_READ); | ||
106 | } | ||
107 | |||
108 | |||
109 | METHODDEF(void) | ||
110 | write_backing_store (j_common_ptr cinfo, backing_store_ptr info, | ||
111 | void FAR * buffer_address, | ||
112 | long file_offset, long byte_count) | ||
113 | { | ||
114 | if (fseek(info->temp_file, file_offset, SEEK_SET)) | ||
115 | ERREXIT(cinfo, JERR_TFILE_SEEK); | ||
116 | if (JFWRITE(info->temp_file, buffer_address, byte_count) | ||
117 | != (size_t) byte_count) | ||
118 | ERREXIT(cinfo, JERR_TFILE_WRITE); | ||
119 | } | ||
120 | |||
121 | |||
122 | METHODDEF(void) | ||
123 | close_backing_store (j_common_ptr cinfo, backing_store_ptr info) | ||
124 | { | ||
125 | fclose(info->temp_file); | ||
126 | /* Since this implementation uses tmpfile() to create the file, | ||
127 | * no explicit file deletion is needed. | ||
128 | */ | ||
129 | } | ||
130 | |||
131 | |||
132 | /* | ||
133 | * Initial opening of a backing-store object. | ||
134 | * | ||
135 | * This version uses tmpfile(), which constructs a suitable file name | ||
136 | * behind the scenes. We don't have to use info->temp_name[] at all; | ||
137 | * indeed, we can't even find out the actual name of the temp file. | ||
138 | */ | ||
139 | |||
140 | GLOBAL(void) | ||
141 | jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, | ||
142 | long total_bytes_needed) | ||
143 | { | ||
144 | if ((info->temp_file = tmpfile()) == NULL) | ||
145 | ERREXITS(cinfo, JERR_TFILE_CREATE, ""); | ||
146 | info->read_backing_store = read_backing_store; | ||
147 | info->write_backing_store = write_backing_store; | ||
148 | info->close_backing_store = close_backing_store; | ||
149 | } | ||
150 | |||
151 | |||
152 | /* | ||
153 | * These routines take care of any system-dependent initialization and | ||
154 | * cleanup required. | ||
155 | */ | ||
156 | |||
157 | GLOBAL(long) | ||
158 | jpeg_mem_init (j_common_ptr cinfo) | ||
159 | { | ||
160 | return DEFAULT_MAX_MEM; /* default for max_memory_to_use */ | ||
161 | } | ||
162 | |||
163 | GLOBAL(void) | ||
164 | jpeg_mem_term (j_common_ptr cinfo) | ||
165 | { | ||
166 | /* no work */ | ||
167 | } | ||