blob: 5da4d0a6d1bd6c85c671ac3d01cb2e1b385e1cc8 [file] [log] [blame]
Dees_Troy51a0e822012-09-05 15:24:24 -04001/*
2 * Copyright (C) 2007-2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define JPEG_INTERNALS
18#include "jinclude.h"
19#include "jpeglib.h"
20#include "jmemsys.h" /* import the system-dependent declarations */
21
22#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
23extern void * malloc JPP((size_t size));
24extern void free JPP((void *ptr));
25#endif
26
27#ifndef SEEK_SET /* pre-ANSI systems may not define this; */
28#define SEEK_SET 0 /* if not, assume 0 is correct */
29#endif
30
31
32/*
33 * Memory allocation and freeing are controlled by the regular library
34 * routines malloc() and free().
35 */
36
37GLOBAL(void *)
38jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
39{
40 return (void *) malloc(sizeofobject);
41}
42
43GLOBAL(void)
44jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
45{
46 free(object);
47}
48
49
50/*
51 * "Large" objects are treated the same as "small" ones.
52 * NB: although we include FAR keywords in the routine declarations,
53 * this file won't actually work in 80x86 small/medium model; at least,
54 * you probably won't be able to process useful-size images in only 64KB.
55 */
56
57GLOBAL(void FAR *)
58jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
59{
60 return (void FAR *) malloc(sizeofobject);
61}
62
63GLOBAL(void)
64jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
65{
66 free(object);
67}
68
69
70/*
71 * This routine computes the total memory space available for allocation.
72 * It's impossible to do this in a portable way; our current solution is
73 * to make the user tell us (with a default value set at compile time).
74 * If you can actually get the available space, it's a good idea to subtract
75 * a slop factor of 5% or so.
76 */
77
78#ifndef DEFAULT_MAX_MEM /* so can override from makefile */
79#define DEFAULT_MAX_MEM 10000000L /* default: ten megabyte */
80#endif
81
82GLOBAL(long)
83jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
84 long max_bytes_needed, long already_allocated)
85{
86 return cinfo->mem->max_memory_to_use - already_allocated;
87}
88
89
90/*
91 * Backing store (temporary file) management.
92 * Backing store objects are only used when the value returned by
93 * jpeg_mem_available is less than the total space needed. You can dispense
94 * with these routines if you have plenty of virtual memory; see jmemnobs.c.
95 */
96
97
98METHODDEF(void)
99read_backing_store (j_common_ptr cinfo, backing_store_ptr info,
100 void FAR * buffer_address,
101 long file_offset, long byte_count)
102{
103 if (fseek(info->temp_file, file_offset, SEEK_SET))
104 ERREXIT(cinfo, JERR_TFILE_SEEK);
105 if (JFREAD(info->temp_file, buffer_address, byte_count)
106 != (size_t) byte_count)
107 ERREXIT(cinfo, JERR_TFILE_READ);
108}
109
110
111METHODDEF(void)
112write_backing_store (j_common_ptr cinfo, backing_store_ptr info,
113 void FAR * buffer_address,
114 long file_offset, long byte_count)
115{
116 if (fseek(info->temp_file, file_offset, SEEK_SET))
117 ERREXIT(cinfo, JERR_TFILE_SEEK);
118 if (JFWRITE(info->temp_file, buffer_address, byte_count)
119 != (size_t) byte_count)
120 ERREXIT(cinfo, JERR_TFILE_WRITE);
121}
122
123
124METHODDEF(void)
125close_backing_store (j_common_ptr cinfo, backing_store_ptr info)
126{
127 fclose(info->temp_file);
128 /* Since this implementation uses tmpfile() to create the file,
129 * no explicit file deletion is needed.
130 */
131}
132
133static FILE* getTempFileFromPath(const char * path) {
134 FILE * fd = fopen(path, "w+");
135 unlink(path);
136 return fd;
137}
138
139static FILE* getTempFile() {
140 char path[1024];
141 snprintf(path, 1023, "/sdcard/.%d.tmp", getpid());
142 FILE * fd = getTempFileFromPath(path);
143 if (fd == NULL) {
144 // anywhere else we can create a temp file?
145 // snprintf(path, 1023, "/data/data/.%d.tmp", getpid());
146 // fd = getTempFileFromPath(path);
147 }
148 return fd;
149}
150
151/*
152 * Initial opening of a backing-store object.
153 *
154 * This version uses tmpfile(), which constructs a suitable file name
155 * behind the scenes. We don't have to use info->temp_name[] at all;
156 * indeed, we can't even find out the actual name of the temp file.
157 */
158
159GLOBAL(void)
160jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
161 long total_bytes_needed)
162{
163 if ((info->temp_file = getTempFile()) == NULL)
164 ERREXITS(cinfo, JERR_TFILE_CREATE, "");
165 info->read_backing_store = read_backing_store;
166 info->write_backing_store = write_backing_store;
167 info->close_backing_store = close_backing_store;
168}
169
170
171/*
172 * These routines take care of any system-dependent initialization and
173 * cleanup required.
174 */
175
176GLOBAL(long)
177jpeg_mem_init (j_common_ptr cinfo)
178{
179 return DEFAULT_MAX_MEM; /* default for max_memory_to_use */
180}
181
182GLOBAL(void)
183jpeg_mem_term (j_common_ptr cinfo)
184{
185 /* no work */
186}