Commit | Line | Data |
---|---|---|
e1929140 RR |
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 | } |