1/*
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}
187