Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
96 | giacomo | 1 | |
2 | /* pngrio.c - functions for data input |
||
3 | * |
||
4 | * libpng 1.2.5 - October 3, 2002 |
||
5 | * For conditions of distribution and use, see copyright notice in png.h |
||
6 | * Copyright (c) 1998-2002 Glenn Randers-Pehrson |
||
7 | * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
||
8 | * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
||
9 | * |
||
10 | * This file provides a location for all input. Users who need |
||
11 | * special handling are expected to write a function that has the same |
||
12 | * arguments as this and performs a similar function, but that possibly |
||
13 | * has a different input method. Note that you shouldn't change this |
||
14 | * function, but rather write a replacement function and then make |
||
15 | * libpng use it at run time with png_set_read_fn(...). |
||
16 | */ |
||
17 | |||
18 | #define PNG_INTERNAL |
||
19 | #include "png.h" |
||
20 | |||
21 | /* Read the data from whatever input you are using. The default routine |
||
22 | reads from a file pointer. Note that this routine sometimes gets called |
||
23 | with very small lengths, so you should implement some kind of simple |
||
24 | buffering if you are using unbuffered reads. This should never be asked |
||
25 | to read more then 64K on a 16 bit machine. */ |
||
26 | void /* PRIVATE */ |
||
27 | png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
||
28 | { |
||
29 | png_debug1(4,"reading %d bytes\n", (int)length); |
||
30 | if (png_ptr->read_data_fn != NULL) |
||
31 | (*(png_ptr->read_data_fn))(png_ptr, data, length); |
||
32 | else |
||
33 | png_error(png_ptr, "Call to NULL read function"); |
||
34 | } |
||
35 | |||
36 | #if !defined(PNG_NO_STDIO) |
||
37 | /* This is the function that does the actual reading of data. If you are |
||
38 | not reading from a standard C stream, you should create a replacement |
||
39 | read_data function and use it at run time with png_set_read_fn(), rather |
||
40 | than changing the library. */ |
||
41 | #ifndef USE_FAR_KEYWORD |
||
42 | void PNGAPI |
||
43 | png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
||
44 | { |
||
45 | png_size_t check; |
||
46 | |||
47 | /* fread() returns 0 on error, so it is OK to store this in a png_size_t |
||
48 | * instead of an int, which is what fread() actually returns. |
||
49 | */ |
||
50 | #if defined(_WIN32_WCE) |
||
51 | if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
||
52 | check = 0; |
||
53 | #else |
||
54 | check = (png_size_t)fread(data, (png_size_t)1, length, |
||
55 | (png_FILE_p)png_ptr->io_ptr); |
||
56 | #endif |
||
57 | |||
58 | if (check != length) |
||
59 | png_error(png_ptr, "Read Error"); |
||
60 | } |
||
61 | #else |
||
62 | /* this is the model-independent version. Since the standard I/O library |
||
63 | can't handle far buffers in the medium and small models, we have to copy |
||
64 | the data. |
||
65 | */ |
||
66 | |||
67 | #define NEAR_BUF_SIZE 1024 |
||
68 | #define MIN(a,b) (a <= b ? a : b) |
||
69 | |||
70 | static void /* PRIVATE */ |
||
71 | png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
||
72 | { |
||
73 | int check; |
||
74 | png_byte *n_data; |
||
75 | png_FILE_p io_ptr; |
||
76 | |||
77 | /* Check if data really is near. If so, use usual code. */ |
||
78 | n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
||
79 | io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
||
80 | if ((png_bytep)n_data == data) |
||
81 | { |
||
82 | #if defined(_WIN32_WCE) |
||
83 | if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
||
84 | check = 0; |
||
85 | #else |
||
86 | check = fread(n_data, 1, length, io_ptr); |
||
87 | #endif |
||
88 | } |
||
89 | else |
||
90 | { |
||
91 | png_byte buf[NEAR_BUF_SIZE]; |
||
92 | png_size_t read, remaining, err; |
||
93 | check = 0; |
||
94 | remaining = length; |
||
95 | do |
||
96 | { |
||
97 | read = MIN(NEAR_BUF_SIZE, remaining); |
||
98 | #if defined(_WIN32_WCE) |
||
99 | if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) |
||
100 | err = 0; |
||
101 | #else |
||
102 | err = fread(buf, (png_size_t)1, read, io_ptr); |
||
103 | #endif |
||
104 | png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
||
105 | if(err != read) |
||
106 | break; |
||
107 | else |
||
108 | check += err; |
||
109 | data += read; |
||
110 | remaining -= read; |
||
111 | } |
||
112 | while (remaining != 0); |
||
113 | } |
||
114 | if ((png_uint_32)check != (png_uint_32)length) |
||
115 | png_error(png_ptr, "read Error"); |
||
116 | } |
||
117 | #endif |
||
118 | #endif |
||
119 | |||
120 | /* This function allows the application to supply a new input function |
||
121 | for libpng if standard C streams aren't being used. |
||
122 | |||
123 | This function takes as its arguments: |
||
124 | png_ptr - pointer to a png input data structure |
||
125 | io_ptr - pointer to user supplied structure containing info about |
||
126 | the input functions. May be NULL. |
||
127 | read_data_fn - pointer to a new input function that takes as its |
||
128 | arguments a pointer to a png_struct, a pointer to |
||
129 | a location where input data can be stored, and a 32-bit |
||
130 | unsigned int that is the number of bytes to be read. |
||
131 | To exit and output any fatal error messages the new write |
||
132 | function should call png_error(png_ptr, "Error msg"). */ |
||
133 | void PNGAPI |
||
134 | png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, |
||
135 | png_rw_ptr read_data_fn) |
||
136 | { |
||
137 | png_ptr->io_ptr = io_ptr; |
||
138 | |||
139 | #if !defined(PNG_NO_STDIO) |
||
140 | if (read_data_fn != NULL) |
||
141 | png_ptr->read_data_fn = read_data_fn; |
||
142 | else |
||
143 | png_ptr->read_data_fn = png_default_read_data; |
||
144 | #else |
||
145 | png_ptr->read_data_fn = read_data_fn; |
||
146 | #endif |
||
147 | |||
148 | /* It is an error to write to a read device */ |
||
149 | if (png_ptr->write_data_fn != NULL) |
||
150 | { |
||
151 | png_ptr->write_data_fn = NULL; |
||
152 | png_warning(png_ptr, |
||
153 | "It's an error to set both read_data_fn and write_data_fn in the "); |
||
154 | png_warning(png_ptr, |
||
155 | "same structure. Resetting write_data_fn to NULL."); |
||
156 | } |
||
157 | |||
158 | #if defined(PNG_WRITE_FLUSH_SUPPORTED) |
||
159 | png_ptr->output_flush_fn = NULL; |
||
160 | #endif |
||
161 | } |