Skip to content

Commit d71a770

Browse files
andelfandelf
committed
fix compile error: string change, sdlresult change
1 parent 52cce1f commit d71a770

File tree

4 files changed

+179
-177
lines changed

4 files changed

+179
-177
lines changed

‎src/sdl2_gfx/framerate.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@
33
use libc;
44
use libc::{c_void, uint32_t, malloc};
55
use std::mem;
6+
use sdl2::SdlResult;
7+
68

79
mod ll {
810
/* automatically generated by rust-bindgen */
@@ -40,10 +42,10 @@ impl FPSManager {
4042
}
4143

4244
/// Set the framerate in Hz.
43-
pub fn set_framerate(&mut self, rate: uint) -> Result<(), ~str> {
45+
pub fn set_framerate(&mut self, rate: uint) -> SdlResult<()> {
4446
let ret = unsafe { ll::SDL_setFramerate(self.raw, rate as uint32_t) };
4547
if ret == 0 { Ok(()) }
46-
else { Err("set_framerate error: beyond lower/upper limit.".to_owned()) }
48+
else { Err("set_framerate error: beyond lower/upper limit.".to_string()) }
4749
}
4850

4951
/// Return the current target framerate in Hz.

‎src/sdl2_gfx/imagefilter.rs

Lines changed: 55 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use std::mem;
44
use std::c_vec::CVec;
55
use libc;
66
use libc::{size_t, c_void, c_uint, c_int};
7+
use sdl2::SdlResult;
78

89
mod ll {
910
/* automatically generated by rust-bindgen */
@@ -111,7 +112,7 @@ fn cvec_with_size(sz: uint) -> CVec<u8> {
111112
}
112113

113114
/// Filter using Add: D = saturation255(S1 + S2).
114-
pub fn add(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
115+
pub fn add(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
115116
assert_eq!(src1.len(), src2.len());
116117
let size = src1.len();
117118
let dest = cvec_with_size(size);
@@ -120,11 +121,11 @@ pub fn add(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
120121
mem::transmute(dest.get(0)),
121122
size as c_uint) };
122123
if ret == 0 { Ok(dest) }
123-
else { Err("SDL_imageFilterAdd error".to_owned()) }
124+
else { Err("SDL_imageFilterAdd error".to_string()) }
124125
}
125126

126127
/// Filter using Mean: D = S1/2 + S2/2.
127-
pub fn mean(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
128+
pub fn mean(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
128129
assert_eq!(src1.len(), src2.len());
129130
let size = src1.len();
130131
let dest = cvec_with_size(size);
@@ -133,11 +134,11 @@ pub fn mean(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
133134
mem::transmute(dest.get(0)),
134135
size as c_uint) };
135136
if ret == 0 { Ok(dest) }
136-
else { Err("SDL_imageFilterMean error".to_owned()) }
137+
else { Err("SDL_imageFilterMean error".to_string()) }
137138
}
138139

139140
/// Filter using Sub: D = saturation0(S1 - S2).
140-
pub fn sub(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
141+
pub fn sub(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
141142
assert_eq!(src1.len(), src2.len());
142143
let size = src1.len();
143144
let dest = cvec_with_size(size);
@@ -146,11 +147,11 @@ pub fn sub(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
146147
mem::transmute(dest.get(0)),
147148
size as c_uint) };
148149
if ret == 0 { Ok(dest) }
149-
else { Err("SDL_imageFilterSub error".to_owned()) }
150+
else { Err("SDL_imageFilterSub error".to_string()) }
150151
}
151152

152153
/// Filter using AbsDiff: D = | S1 - S2 |.
153-
pub fn abs_diff(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
154+
pub fn abs_diff(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
154155
assert_eq!(src1.len(), src2.len());
155156
let size = src1.len();
156157
let dest = cvec_with_size(size);
@@ -159,11 +160,11 @@ pub fn abs_diff(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
159160
mem::transmute(dest.get(0)),
160161
size as c_uint) };
161162
if ret == 0 { Ok(dest) }
162-
else { Err("SDL_imageFilterAbsDiff error".to_owned()) }
163+
else { Err("SDL_imageFilterAbsDiff error".to_string()) }
163164
}
164165

165166
/// Filter using Mult: D = saturation255(S1 * S2).
166-
pub fn mult(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
167+
pub fn mult(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
167168
assert_eq!(src1.len(), src2.len());
168169
let size = src1.len();
169170
let dest = cvec_with_size(size);
@@ -172,11 +173,11 @@ pub fn mult(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
172173
mem::transmute(dest.get(0)),
173174
size as c_uint) };
174175
if ret == 0 { Ok(dest) }
175-
else { Err("SDL_imageFilterMult error".to_owned()) }
176+
else { Err("SDL_imageFilterMult error".to_string()) }
176177
}
177178

178179
/// Filter using MultNor: D = S1 * S2.
179-
pub fn mult_nor(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
180+
pub fn mult_nor(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
180181
assert_eq!(src1.len(), src2.len());
181182
let size = src1.len();
182183
let dest = cvec_with_size(size);
@@ -185,11 +186,11 @@ pub fn mult_nor(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
185186
mem::transmute(dest.get(0)),
186187
size as c_uint) };
187188
if ret == 0 { Ok(dest) }
188-
else { Err("SDL_imageFilterMultNor error".to_owned()) }
189+
else { Err("SDL_imageFilterMultNor error".to_string()) }
189190
}
190191

191192
/// Filter using MultDivby2: D = saturation255(S1/2 * S2).
192-
pub fn mult_div_by2(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
193+
pub fn mult_div_by2(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
193194
assert_eq!(src1.len(), src2.len());
194195
let size = src1.len();
195196
let dest = cvec_with_size(size);
@@ -198,11 +199,11 @@ pub fn mult_div_by2(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
198199
mem::transmute(dest.get(0)),
199200
size as c_uint) };
200201
if ret == 0 { Ok(dest) }
201-
else { Err("SDL_imageFilterMultDivby2 error".to_owned()) }
202+
else { Err("SDL_imageFilterMultDivby2 error".to_string()) }
202203
}
203204

204205
/// Filter using MultDivby4: D = saturation255(S1/2 * S2/2).
205-
pub fn mult_div_by4(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
206+
pub fn mult_div_by4(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
206207
assert_eq!(src1.len(), src2.len());
207208
let size = src1.len();
208209
let dest = cvec_with_size(size);
@@ -211,11 +212,11 @@ pub fn mult_div_by4(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
211212
mem::transmute(dest.get(0)),
212213
size as c_uint) };
213214
if ret == 0 { Ok(dest) }
214-
else { Err("SDL_imageFilterMultDivby4 error".to_owned()) }
215+
else { Err("SDL_imageFilterMultDivby4 error".to_string()) }
215216
}
216217

217218
/// Filter using BitAnd: D = S1 & S2.
218-
pub fn bit_and(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
219+
pub fn bit_and(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
219220
assert_eq!(src1.len(), src2.len());
220221
let size = src1.len();
221222
let dest = cvec_with_size(size);
@@ -224,11 +225,11 @@ pub fn bit_and(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
224225
mem::transmute(dest.get(0)),
225226
size as c_uint) };
226227
if ret == 0 { Ok(dest) }
227-
else { Err("SDL_imageFilterBitAnd error".to_owned()) }
228+
else { Err("SDL_imageFilterBitAnd error".to_string()) }
228229
}
229230

230231
/// Filter using BitOr: D = S1 | S2.
231-
pub fn bit_or(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
232+
pub fn bit_or(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
232233
assert_eq!(src1.len(), src2.len());
233234
let size = src1.len();
234235
let dest = cvec_with_size(size);
@@ -237,11 +238,11 @@ pub fn bit_or(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
237238
mem::transmute(dest.get(0)),
238239
size as c_uint) };
239240
if ret == 0 { Ok(dest) }
240-
else { Err("SDL_imageFilterBitOr error".to_owned()) }
241+
else { Err("SDL_imageFilterBitOr error".to_string()) }
241242
}
242243

243244
/// Filter using Div: D = S1 / S2.
244-
pub fn div(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
245+
pub fn div(src1: CVec<u8>, src2: CVec<u8>) -> SdlResult<CVec<u8>> {
245246
assert_eq!(src1.len(), src2.len());
246247
let size = src1.len();
247248
let dest = cvec_with_size(size);
@@ -250,176 +251,176 @@ pub fn div(src1: CVec<u8>, src2: CVec<u8>) -> Result<CVec<u8>, ~str> {
250251
mem::transmute(dest.get(0)),
251252
size as c_uint) };
252253
if ret == 0 { Ok(dest) }
253-
else { Err("SDL_imageFilterDiv error".to_owned()) }
254+
else { Err("SDL_imageFilterDiv error".to_string()) }
254255
}
255256

256257
/// Filter using BitNegation: D = !S.
257-
pub fn bit_negation(src1: CVec<u8>) -> Result<CVec<u8>, ~str> {
258+
pub fn bit_negation(src1: CVec<u8>) -> SdlResult<CVec<u8>> {
258259
let size = src1.len();
259260
let dest = cvec_with_size(size);
260261
let ret = unsafe { ll::SDL_imageFilterBitNegation(mem::transmute(src1.get(0)),
261262
mem::transmute(dest.get(0)),
262263
size as c_uint) };
263264
if ret == 0 { Ok(dest) }
264-
else { Err("SDL_imageFilterBitNegation error".to_owned()) }
265+
else { Err("SDL_imageFilterBitNegation error".to_string()) }
265266
}
266267

267268
/// Filter using AddByte: D = saturation255(S + C).
268-
pub fn add_byte(src1: CVec<u8>, c: u8) -> Result<CVec<u8>, ~str> {
269+
pub fn add_byte(src1: CVec<u8>, c: u8) -> SdlResult<CVec<u8>> {
269270
let size = src1.len();
270271
let dest = cvec_with_size(size);
271272
let ret = unsafe { ll::SDL_imageFilterAddByte(mem::transmute(src1.get(0)),
272273
mem::transmute(dest.get(0)),
273274
size as c_uint, c) };
274275
if ret == 0 { Ok(dest) }
275-
else { Err("SDL_imageFilterAddByte error".to_owned()) }
276+
else { Err("SDL_imageFilterAddByte error".to_string()) }
276277
}
277278

278279
/// Filter using AddUint: D = saturation255((S[i] + Cs[i % 4]), Cs=Swap32((uint)C).
279-
pub fn add_uint(src1: CVec<u8>, c: u32) -> Result<CVec<u8>, ~str> {
280+
pub fn add_uint(src1: CVec<u8>, c: u32) -> SdlResult<CVec<u8>> {
280281
let size = src1.len();
281282
let dest = cvec_with_size(size);
282283
let ret = unsafe { ll::SDL_imageFilterAddUint(mem::transmute(src1.get(0)),
283284
mem::transmute(dest.get(0)),
284285
size as c_uint, c) };
285286
if ret == 0 { Ok(dest) }
286-
else { Err("SDL_imageFilterAddUint error".to_owned()) }
287+
else { Err("SDL_imageFilterAddUint error".to_string()) }
287288
}
288289

289290
/// Filter using AddByteToHalf: D = saturation255(S/2 + C).
290-
pub fn add_byte_to_half(src1: CVec<u8>, c: u8) -> Result<CVec<u8>, ~str> {
291+
pub fn add_byte_to_half(src1: CVec<u8>, c: u8) -> SdlResult<CVec<u8>> {
291292
let size = src1.len();
292293
let dest = cvec_with_size(size);
293294
let ret = unsafe { ll::SDL_imageFilterAddByteToHalf(mem::transmute(src1.get(0)),
294295
mem::transmute(dest.get(0)),
295296
size as c_uint, c) };
296297
if ret == 0 { Ok(dest) }
297-
else { Err("SDL_imageFilterAddByteToHalf error".to_owned()) }
298+
else { Err("SDL_imageFilterAddByteToHalf error".to_string()) }
298299
}
299300

300301
/// Filter using SubByte: D = saturation0(S - C).
301-
pub fn sub_byte(src1: CVec<u8>, c: u8) -> Result<CVec<u8>, ~str> {
302+
pub fn sub_byte(src1: CVec<u8>, c: u8) -> SdlResult<CVec<u8>> {
302303
let size = src1.len();
303304
let dest = cvec_with_size(size);
304305
let ret = unsafe { ll::SDL_imageFilterSubByte(mem::transmute(src1.get(0)),
305306
mem::transmute(dest.get(0)),
306307
size as c_uint, c) };
307308
if ret == 0 { Ok(dest) }
308-
else { Err("SDL_imageFilterSubByte error".to_owned()) }
309+
else { Err("SDL_imageFilterSubByte error".to_string()) }
309310
}
310311

311312
/// Filter using SubUint: D = saturation0(S[i] - Cs[i % 4]), Cs=Swap32((uint)C).
312-
pub fn sub_uint(src1: CVec<u8>, c: u32) -> Result<CVec<u8>, ~str> {
313+
pub fn sub_uint(src1: CVec<u8>, c: u32) -> SdlResult<CVec<u8>> {
313314
let size = src1.len();
314315
let dest = cvec_with_size(size);
315316
let ret = unsafe { ll::SDL_imageFilterSubUint(mem::transmute(src1.get(0)),
316317
mem::transmute(dest.get(0)),
317318
size as c_uint, c) };
318319
if ret == 0 { Ok(dest) }
319-
else { Err("SDL_imageFilterSubUint error".to_owned()) }
320+
else { Err("SDL_imageFilterSubUint error".to_string()) }
320321
}
321322

322323
/// Filter using ShiftRight: D = saturation0(S >> N).
323-
pub fn shift_right(src1: CVec<u8>, n: u8) -> Result<CVec<u8>, ~str> {
324+
pub fn shift_right(src1: CVec<u8>, n: u8) -> SdlResult<CVec<u8>> {
324325
let size = src1.len();
325326
let dest = cvec_with_size(size);
326327
let ret = unsafe { ll::SDL_imageFilterShiftRight(mem::transmute(src1.get(0)),
327328
mem::transmute(dest.get(0)),
328329
size as c_uint, n) };
329330
if ret == 0 { Ok(dest) }
330-
else { Err("SDL_imageFilterShiftRight error".to_owned()) }
331+
else { Err("SDL_imageFilterShiftRight error".to_string()) }
331332
}
332333

333334
/// Filter using ShiftRightUint: D = saturation0((uint)S[i] >> N).
334-
pub fn shift_right_uint(src1: CVec<u8>, n: u8) -> Result<CVec<u8>, ~str> {
335+
pub fn shift_right_uint(src1: CVec<u8>, n: u8) -> SdlResult<CVec<u8>> {
335336
let size = src1.len();
336337
let dest = cvec_with_size(size);
337338
let ret = unsafe { ll::SDL_imageFilterShiftRightUint(mem::transmute(src1.get(0)),
338339
mem::transmute(dest.get(0)),
339340
size as c_uint, n) };
340341
if ret == 0 { Ok(dest) }
341-
else { Err("SDL_imageFilterShiftRightUint error".to_owned()) }
342+
else { Err("SDL_imageFilterShiftRightUint error".to_string()) }
342343
}
343344

344345
/// Filter using MultByByte: D = saturation255(S * C).
345-
pub fn mult_by_byte(src1: CVec<u8>, c: u8) -> Result<CVec<u8>, ~str> {
346+
pub fn mult_by_byte(src1: CVec<u8>, c: u8) -> SdlResult<CVec<u8>> {
346347
let size = src1.len();
347348
let dest = cvec_with_size(size);
348349
let ret = unsafe { ll::SDL_imageFilterMultByByte(mem::transmute(src1.get(0)),
349350
mem::transmute(dest.get(0)),
350351
size as c_uint, c) };
351352
if ret == 0 { Ok(dest) }
352-
else { Err("SDL_imageFilterMultByByte error".to_owned()) }
353+
else { Err("SDL_imageFilterMultByByte error".to_string()) }
353354
}
354355

355356
/// Filter using ShiftRightAndMultByByte: D = saturation255((S >> N) * C).
356-
pub fn shift_right_and_mult_by_byte(src1: CVec<u8>, n: u8, c: u8) -> Result<CVec<u8>, ~str> {
357+
pub fn shift_right_and_mult_by_byte(src1: CVec<u8>, n: u8, c: u8) -> SdlResult<CVec<u8>> {
357358
let size = src1.len();
358359
let dest = cvec_with_size(size);
359360
let ret = unsafe { ll::SDL_imageFilterShiftRightAndMultByByte(mem::transmute(src1.get(0)),
360361
mem::transmute(dest.get(0)),
361362
size as c_uint, n, c) };
362363
if ret == 0 { Ok(dest) }
363-
else { Err("SDL_imageFilterShiftRightAndMultByByte error".to_owned()) }
364+
else { Err("SDL_imageFilterShiftRightAndMultByByte error".to_string()) }
364365
}
365366

366367
/// Filter using ShiftLeftByte: D = (S << N).
367-
pub fn shift_left_byte(src1: CVec<u8>, n: u8) -> Result<CVec<u8>, ~str> {
368+
pub fn shift_left_byte(src1: CVec<u8>, n: u8) -> SdlResult<CVec<u8>> {
368369
let size = src1.len();
369370
let dest = cvec_with_size(size);
370371
let ret = unsafe { ll::SDL_imageFilterShiftLeftByte(mem::transmute(src1.get(0)),
371372
mem::transmute(dest.get(0)),
372373
size as c_uint, n) };
373374
if ret == 0 { Ok(dest) }
374-
else { Err("SDL_imageFilterShiftLeftByte error".to_owned()) }
375+
else { Err("SDL_imageFilterShiftLeftByte error".to_string()) }
375376
}
376377

377378
/// Filter using ShiftLeftUint: D = ((uint)S << N).
378-
pub fn shift_left_uint(src1: CVec<u8>, n: u8) -> Result<CVec<u8>, ~str> {
379+
pub fn shift_left_uint(src1: CVec<u8>, n: u8) -> SdlResult<CVec<u8>> {
379380
let size = src1.len();
380381
let dest = cvec_with_size(size);
381382
let ret = unsafe { ll::SDL_imageFilterShiftLeftUint(mem::transmute(src1.get(0)),
382383
mem::transmute(dest.get(0)),
383384
size as c_uint, n) };
384385
if ret == 0 { Ok(dest) }
385-
else { Err("SDL_imageFilterShiftLeftUint error".to_owned()) }
386+
else { Err("SDL_imageFilterShiftLeftUint error".to_string()) }
386387
}
387388

388389
/// Filter ShiftLeft: D = saturation255(S << N).
389-
pub fn shift_left(src1: CVec<u8>, n: u8) -> Result<CVec<u8>, ~str> {
390+
pub fn shift_left(src1: CVec<u8>, n: u8) -> SdlResult<CVec<u8>> {
390391
let size = src1.len();
391392
let dest = cvec_with_size(size);
392393
let ret = unsafe { ll::SDL_imageFilterShiftLeft(mem::transmute(src1.get(0)),
393394
mem::transmute(dest.get(0)),
394395
size as c_uint, n) };
395396
if ret == 0 { Ok(dest) }
396-
else { Err("SDL_imageFilterShiftLeft error".to_owned()) }
397+
else { Err("SDL_imageFilterShiftLeft error".to_string()) }
397398
}
398399

399400
/// Filter using BinarizeUsingThreshold: D = (S >= T) ? 255:0.
400-
pub fn binarize_using_threshold(src1: CVec<u8>, t: u8) -> Result<CVec<u8>, ~str> {
401+
pub fn binarize_using_threshold(src1: CVec<u8>, t: u8) -> SdlResult<CVec<u8>> {
401402
let size = src1.len();
402403
let dest = cvec_with_size(size);
403404
let ret = unsafe { ll::SDL_imageFilterBinarizeUsingThreshold(mem::transmute(src1.get(0)),
404405
mem::transmute(dest.get(0)),
405406
size as c_uint, t) };
406407
if ret == 0 { Ok(dest) }
407-
else { Err("SDL_imageFilterBinarizeUsingThreshold error".to_owned()) }
408+
else { Err("SDL_imageFilterBinarizeUsingThreshold error".to_string()) }
408409
}
409410

410411
/// Filter using ClipToRange: D = (S >= Tmin) & (S <= Tmax) S:Tmin | Tmax.
411-
pub fn clip_to_range(src1: CVec<u8>, tmin: u8, tmax: u8) -> Result<CVec<u8>, ~str> {
412+
pub fn clip_to_range(src1: CVec<u8>, tmin: u8, tmax: u8) -> SdlResult<CVec<u8>> {
412413
let size = src1.len();
413414
let dest = cvec_with_size(size);
414415
let ret = unsafe { ll::SDL_imageFilterClipToRange(mem::transmute(src1.get(0)),
415416
mem::transmute(dest.get(0)),
416417
size as c_uint, tmin, tmax) };
417418
if ret == 0 { Ok(dest) }
418-
else { Err("SDL_imageFilterClipToRange error".to_owned()) }
419+
else { Err("SDL_imageFilterClipToRange error".to_string()) }
419420
}
420421

421422
/// Filter using NormalizeLinear: D = saturation255((Nmax - Nmin)/(Cmax - Cmin)*(S - Cmin) + Nmin).
422-
pub fn normalize_linear(src1: CVec<u8>, cmin: int, cmax: int, nmin: int, nmax: int) -> Result<CVec<u8>, ~str> {
423+
pub fn normalize_linear(src1: CVec<u8>, cmin: int, cmax: int, nmin: int, nmax: int) -> SdlResult<CVec<u8>> {
423424
let size = src1.len();
424425
let dest = cvec_with_size(size);
425426
let ret = unsafe { ll::SDL_imageFilterNormalizeLinear(mem::transmute(src1.get(0)),
@@ -428,5 +429,5 @@ pub fn normalize_linear(src1: CVec<u8>, cmin: int, cmax: int, nmin: int, nmax: i
428429
cmin as c_int, cmax as c_int,
429430
nmin as c_int, nmax as c_int) };
430431
if ret == 0 { Ok(dest) }
431-
else { Err("SDL_imageFilterNormalizeLinear error".to_owned()) }
432+
else { Err("SDL_imageFilterNormalizeLinear error".to_string()) }
432433
}

0 commit comments

Comments
 (0)