Subversion Repositories Kolibri OS

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
6417 ashmew2 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		/*  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 
}