← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/jpeglib/jmemansi.c

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/jpeglib/jmemansi.c
 
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
}