← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/libjpeg/jmemnobs.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/libjpeg/jmemnobs.c
 
1
/*
 
2
 * jmemnobs.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 really simple implementation of the system-
 
9
 * dependent portion of the JPEG memory manager.  This implementation
 
10
 * assumes that no backing-store files are needed: all required space
 
11
 * can be obtained from malloc().
 
12
 * This is very portable in the sense that it'll compile on almost anything,
 
13
 * but you'd better have lots of main memory (or virtual memory) if you want
 
14
 * to process big images.
 
15
 * Note that the max_memory_to_use option is ignored by this implementation.
 
16
 */
 
17
 
 
18
#define JPEG_INTERNALS
 
19
#include "jinclude.h"
 
20
#include "jpeglib.h"
 
21
#include "jmemsys.h"            /* import the system-dependent declarations */
 
22
 
 
23
#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
 
24
extern void * malloc JPP((size_t size));
 
25
extern void free JPP((void *ptr));
 
26
#endif
 
27
 
 
28
 
 
29
/*
 
30
 * Memory allocation and freeing are controlled by the regular library
 
31
 * routines malloc() and free().
 
32
 */
 
33
 
 
34
GLOBAL(void *)
 
35
jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
 
36
{
 
37
  return (void *) malloc(sizeofobject);
 
38
}
 
39
 
 
40
GLOBAL(void)
 
41
jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
 
42
{
 
43
  free(object);
 
44
}
 
45
 
 
46
 
 
47
/*
 
48
 * "Large" objects are treated the same as "small" ones.
 
49
 * NB: although we include FAR keywords in the routine declarations,
 
50
 * this file won't actually work in 80x86 small/medium model; at least,
 
51
 * you probably won't be able to process useful-size images in only 64KB.
 
52
 */
 
53
 
 
54
GLOBAL(void FAR *)
 
55
jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
 
56
{
 
57
  return (void FAR *) malloc(sizeofobject);
 
58
}
 
59
 
 
60
GLOBAL(void)
 
61
jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
 
62
{
 
63
  free(object);
 
64
}
 
65
 
 
66
 
 
67
/*
 
68
 * This routine computes the total memory space available for allocation.
 
69
 * Here we always say, "we got all you want bud!"
 
70
 */
 
71
 
 
72
GLOBAL(long)
 
73
jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
 
74
                    long max_bytes_needed, long already_allocated)
 
75
{
 
76
  return max_bytes_needed;
 
77
}
 
78
 
 
79
 
 
80
/*
 
81
 * Backing store (temporary file) management.
 
82
 * Since jpeg_mem_available always promised the moon,
 
83
 * this should never be called and we can just error out.
 
84
 */
 
85
 
 
86
GLOBAL(void)
 
87
jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
 
88
                         long total_bytes_needed)
 
89
{
 
90
  ERREXIT(cinfo, JERR_NO_BACKING_STORE);
 
91
}
 
92
 
 
93
 
 
94
/*
 
95
 * These routines take care of any system-dependent initialization and
 
96
 * cleanup required.  Here, there isn't any.
 
97
 */
 
98
 
 
99
GLOBAL(long)
 
100
jpeg_mem_init (j_common_ptr cinfo)
 
101
{
 
102
  return 0;                     /* just set max_memory_to_use to 0 */
 
103
}
 
104
 
 
105
GLOBAL(void)
 
106
jpeg_mem_term (j_common_ptr cinfo)
 
107
{
 
108
  /* no work */
 
109
}