Skip to content

Commit 5b738b7

Browse files
lilithlilith
committed
Replace try! with ?
1 parent 1599d62 commit 5b738b7

File tree

5 files changed

+105
-105
lines changed

5 files changed

+105
-105
lines changed

‎src/decoder.rs

Lines changed: 54 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,7 @@ impl<R: Read> Decoder<R> {
127127
// The metadata has already been read.
128128
return Ok(Vec::new());
129129
}
130-
else if self.frame.is_none() && (try!(self.reader.read_u8()) != 0xFF || Marker::from_u8(try!(self.reader.read_u8())) != Some(Marker::SOI)) {
130+
else if self.frame.is_none() && (self.reader.read_u8()? != 0xFF || Marker::from_u8(try!(self.reader.read_u8())) != Some(Marker::SOI)) {
131131
return Err(Error::Format("first two bytes is not a SOI marker".to_owned()));
132132
}
133133

@@ -140,7 +140,7 @@ impl<R: Read> Decoder<R> {
140140
loop {
141141
let marker = match pending_marker.take() {
142142
Some(m) => m,
143-
None => try!(self.read_marker()),
143+
None => self.read_marker()?,
144144
};
145145

146146
match marker {
@@ -154,7 +154,7 @@ impl<R: Read> Decoder<R> {
154154
return Err(Error::Unsupported(UnsupportedFeature::Hierarchical));
155155
}
156156

157-
let frame = try!(parse_sof(&mut self.reader, marker));
157+
let frame = parse_sof(&mut self.reader, marker)?;
158158
let component_count = frame.components.len();
159159

160160
if frame.is_differential {
@@ -177,7 +177,7 @@ impl<R: Read> Decoder<R> {
177177
}
178178

179179
// Make sure we support the subsampling ratios used.
180-
let _ = try!(Upsampler::new(&frame.components, frame.image_size.width, frame.image_size.height));
180+
let _ = Upsampler::new(&frame.components, frame.image_size.width, frame.image_size.height)?;
181181

182182
self.frame = Some(frame);
183183

@@ -194,11 +194,11 @@ impl<R: Read> Decoder<R> {
194194
return Err(Error::Format("scan encountered before frame".to_owned()));
195195
}
196196
if worker_chan.is_none() {
197-
worker_chan = Some(try!(spawn_worker_thread()));
197+
worker_chan = Some(spawn_worker_thread()?);
198198
}
199199

200200
let frame = self.frame.clone().unwrap();
201-
let scan = try!(parse_sos(&mut self.reader, &frame));
201+
let scan = parse_sos(&mut self.reader, &frame)?;
202202

203203
if frame.coding_process == CodingProcess::DctProgressive && self.coefficients.is_empty() {
204204
self.coefficients = frame.components.iter().map(|c| {
@@ -216,7 +216,7 @@ impl<R: Read> Decoder<R> {
216216
}
217217

218218
let is_final_scan = scan.component_indices.iter().all(|&i| self.coefficients_finished[i] == !0);
219-
let (marker, data) = try!(self.decode_scan(&frame, &scan, worker_chan.as_ref().unwrap(), is_final_scan));
219+
let (marker, data) = self.decode_scan(&frame, &scan, worker_chan.as_ref().unwrap(), is_final_scan)?;
220220

221221
if let Some(data) = data {
222222
for (i, plane) in data.into_iter().enumerate().filter(|&(_, ref plane)| !plane.is_empty()) {
@@ -231,7 +231,7 @@ impl<R: Read> Decoder<R> {
231231
// Table-specification and miscellaneous markers
232232
// Quantization table-specification
233233
Marker::DQT => {
234-
let tables = try!(parse_dqt(&mut self.reader));
234+
let tables = parse_dqt(&mut self.reader)?;
235235

236236
for (i, &table) in tables.into_iter().enumerate() {
237237
if let Some(table) = table {
@@ -248,7 +248,7 @@ impl<R: Read> Decoder<R> {
248248
// Huffman table-specification
249249
Marker::DHT => {
250250
let is_baseline = self.frame.as_ref().map(|frame| frame.is_baseline);
251-
let (dc_tables, ac_tables) = try!(parse_dht(&mut self.reader, is_baseline));
251+
let (dc_tables, ac_tables) = parse_dht(&mut self.reader, is_baseline)?;
252252

253253
let current_dc_tables = mem::replace(&mut self.dc_huffman_tables, vec![]);
254254
self.dc_huffman_tables = dc_tables.into_iter()
@@ -265,14 +265,14 @@ impl<R: Read> Decoder<R> {
265265
// Arithmetic conditioning table-specification
266266
Marker::DAC => return Err(Error::Unsupported(UnsupportedFeature::ArithmeticEntropyCoding)),
267267
// Restart interval definition
268-
Marker::DRI => self.restart_interval = try!(parse_dri(&mut self.reader)),
268+
Marker::DRI => self.restart_interval = parse_dri(&mut self.reader)?,
269269
// Comment
270270
Marker::COM => {
271-
let _comment = try!(parse_com(&mut self.reader));
271+
let _comment = parse_com(&mut self.reader)?;
272272
},
273273
// Application data
274274
Marker::APP(..) => {
275-
if let Some(data) = try!(parse_app(&mut self.reader, marker)) {
275+
if let Some(data) = parse_app(&mut self.reader, marker)? {
276276
match data {
277277
AppData::Adobe(color_transform) => self.color_transform = Some(color_transform),
278278
AppData::Jfif => {
@@ -338,14 +338,14 @@ impl<R: Read> Decoder<R> {
338338
// libjpeg allows this though and there are images in the wild utilising it, so we are
339339
// forced to support this behavior.
340340
// Sony Ericsson P990i is an example of a device which produce this sort of JPEGs.
341-
while try!(self.reader.read_u8()) != 0xFF {}
341+
while self.reader.read_u8()? != 0xFF {}
342342

343-
let mut byte = try!(self.reader.read_u8());
343+
let mut byte = self.reader.read_u8()?;
344344

345345
// Section B.1.1.2
346346
// "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’."
347347
while byte == 0xFF {
348-
byte = try!(self.reader.read_u8());
348+
byte = self.reader.read_u8()?;
349349
}
350350

351351
match byte {
@@ -394,7 +394,7 @@ impl<R: Read> Decoder<R> {
394394
quantization_table: self.quantization_tables[component.quantization_table_index].clone().unwrap(),
395395
};
396396

397-
try!(worker_chan.send(WorkerMsg::Start(row_data)));
397+
worker_chan.send(WorkerMsg::Start(row_data))?;
398398
}
399399
}
400400

@@ -455,24 +455,24 @@ impl<R: Read> Decoder<R> {
455455
};
456456

457457
if scan.successive_approximation_high == 0 {
458-
try!(decode_block(&mut self.reader,
459-
coefficients,
460-
&mut huffman,
461-
self.dc_huffman_tables[scan.dc_table_indices[i]].as_ref(),
462-
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
463-
scan.spectral_selection.clone(),
464-
scan.successive_approximation_low,
465-
&mut eob_run,
466-
&mut dc_predictors[i]));
458+
decode_block(&mut self.reader,
459+
coefficients,
460+
&mut huffman,
461+
self.dc_huffman_tables[scan.dc_table_indices[i]].as_ref(),
462+
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
463+
scan.spectral_selection.clone(),
464+
scan.successive_approximation_low,
465+
&mut eob_run,
466+
&mut dc_predictors[i])?;
467467
}
468468
else {
469-
try!(decode_block_successive_approximation(&mut self.reader,
470-
coefficients,
471-
&mut huffman,
472-
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
473-
scan.spectral_selection.clone(),
474-
scan.successive_approximation_low,
475-
&mut eob_run));
469+
decode_block_successive_approximation(&mut self.reader,
470+
coefficients,
471+
&mut huffman,
472+
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
473+
scan.spectral_selection.clone(),
474+
scan.successive_approximation_low,
475+
&mut eob_run)?;
476476
}
477477
}
478478
}
@@ -482,7 +482,7 @@ impl<R: Read> Decoder<R> {
482482
mcus_left_until_restart -= 1;
483483

484484
if mcus_left_until_restart == 0 && !is_last_mcu {
485-
match try!(huffman.take_marker(&mut self.reader)) {
485+
match huffman.take_marker(&mut self.reader)? {
486486
Some(Marker::RST(n)) => {
487487
if n != expected_rst_num {
488488
return Err(Error::Format(format!("found RST{} where RST{} was expected", n, expected_rst_num)));
@@ -516,22 +516,22 @@ impl<R: Read> Decoder<R> {
516516
mem::replace(&mut mcu_row_coefficients[i], vec![0i16; coefficients_per_mcu_row])
517517
};
518518

519-
try!(worker_chan.send(WorkerMsg::AppendRow((i, row_coefficients))));
519+
worker_chan.send(WorkerMsg::AppendRow((i, row_coefficients)))?;
520520
}
521521
}
522522
}
523523

524-
let marker = try!(huffman.take_marker(&mut self.reader));
524+
let marker = huffman.take_marker(&mut self.reader)?;
525525

526526
if produce_data {
527527
// Retrieve all the data from the worker thread.
528528
let mut data = vec![Vec::new(); frame.components.len()];
529529

530530
for (i, &component_index) in scan.component_indices.iter().enumerate() {
531531
let (tx, rx) = mpsc::channel();
532-
try!(worker_chan.send(WorkerMsg::GetResult((i, tx))));
532+
worker_chan.send(WorkerMsg::GetResult((i, tx)))?;
533533

534-
data[component_index] = try!(rx.recv());
534+
data[component_index] = rx.recv()?;
535535
}
536536

537537
Ok((marker, Some(data)))
@@ -556,7 +556,7 @@ fn decode_block<R: Read>(reader: &mut R,
556556
if spectral_selection.start == 0 {
557557
// Section F.2.2.1
558558
// Figure F.12
559-
let value = try!(huffman.decode(reader, dc_table.unwrap()));
559+
let value = huffman.decode(reader, dc_table.unwrap())?;
560560
let diff = match value {
561561
0 => 0,
562562
_ => {
@@ -566,7 +566,7 @@ fn decode_block<R: Read>(reader: &mut R,
566566
return Err(Error::Format("invalid DC difference magnitude category".to_owned()));
567567
}
568568

569-
try!(huffman.receive_extend(reader, value))
569+
huffman.receive_extend(reader, value)?
570570
},
571571
};
572572

@@ -585,7 +585,7 @@ fn decode_block<R: Read>(reader: &mut R,
585585

586586
// Section F.1.2.2.1
587587
while index < spectral_selection.end {
588-
if let Some((value, run)) = try!(huffman.decode_fast_ac(reader, ac_table.unwrap())) {
588+
if let Some((value, run)) = huffman.decode_fast_ac(reader, ac_table.unwrap())? {
589589
index += run;
590590

591591
if index >= spectral_selection.end {
@@ -596,7 +596,7 @@ fn decode_block<R: Read>(reader: &mut R,
596596
index += 1;
597597
}
598598
else {
599-
let byte = try!(huffman.decode(reader, ac_table.unwrap()));
599+
let byte = huffman.decode(reader, ac_table.unwrap())?;
600600
let r = byte >> 4;
601601
let s = byte & 0x0f;
602602

@@ -607,7 +607,7 @@ fn decode_block<R: Read>(reader: &mut R,
607607
*eob_run = (1 << r) - 1;
608608

609609
if r > 0 {
610-
*eob_run += try!(huffman.get_bits(reader, r));
610+
*eob_run += huffman.get_bits(reader, r)?;
611611
}
612612

613613
break;
@@ -621,7 +621,7 @@ fn decode_block<R: Read>(reader: &mut R,
621621
break;
622622
}
623623

624-
coefficients[UNZIGZAG[index as usize] as usize] = try!(huffman.receive_extend(reader, s)) << successive_approximation_low;
624+
coefficients[UNZIGZAG[index as usize] as usize] = huffman.receive_extend(reader, s)? << successive_approximation_low;
625625
index += 1;
626626
}
627627
}
@@ -644,7 +644,7 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
644644
if spectral_selection.start == 0 {
645645
// Section G.1.2.1
646646

647-
if try!(huffman.get_bits(reader, 1)) == 1 {
647+
if huffman.get_bits(reader, 1)? == 1 {
648648
coefficients[0] |= bit;
649649
}
650650
}
@@ -653,14 +653,14 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
653653

654654
if *eob_run > 0 {
655655
*eob_run -= 1;
656-
try!(refine_non_zeroes(reader, coefficients, huffman, spectral_selection, 64, bit));
656+
refine_non_zeroes(reader, coefficients, huffman, spectral_selection, 64, bit)?;
657657
return Ok(());
658658
}
659659

660660
let mut index = spectral_selection.start;
661661

662662
while index < spectral_selection.end {
663-
let byte = try!(huffman.decode(reader, ac_table.unwrap()));
663+
let byte = huffman.decode(reader, ac_table.unwrap())?;
664664
let r = byte >> 4;
665665
let s = byte & 0x0f;
666666

@@ -680,7 +680,7 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
680680
*eob_run = (1 << r) - 1;
681681

682682
if r > 0 {
683-
*eob_run += try!(huffman.get_bits(reader, r));
683+
*eob_run += huffman.get_bits(reader, r)?;
684684
}
685685

686686
// Force end of block.
@@ -689,7 +689,7 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
689689
}
690690
},
691691
1 => {
692-
if try!(huffman.get_bits(reader, 1)) == 1 {
692+
if huffman.get_bits(reader, 1)? == 1 {
693693
value = bit;
694694
}
695695
else {
@@ -703,7 +703,7 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
703703
start: index,
704704
end: spectral_selection.end,
705705
};
706-
index = try!(refine_non_zeroes(reader, coefficients, huffman, range, zero_run_length, bit));
706+
index = refine_non_zeroes(reader, coefficients, huffman, range, zero_run_length, bit)?;
707707

708708
if value != 0 {
709709
coefficients[UNZIGZAG[index as usize] as usize] = value;
@@ -737,7 +737,7 @@ fn refine_non_zeroes<R: Read>(reader: &mut R,
737737

738738
zero_run_length -= 1;
739739
}
740-
else if try!(huffman.get_bits(reader, 1)) == 1 && coefficients[index] & bit == 0 {
740+
else if huffman.get_bits(reader, 1)? == 1 && coefficients[index] & bit == 0 {
741741
if coefficients[index] > 0 {
742742
coefficients[index] += bit;
743743
}
@@ -790,8 +790,8 @@ fn compute_image_parallel(components: &[Component],
790790
color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
791791
use rayon::prelude::*;
792792

793-
let color_convert_func = try!(choose_color_convert_func(components.len(), is_jfif, color_transform));
794-
let upsampler = try!(Upsampler::new(components, output_size.width, output_size.height));
793+
let color_convert_func = choose_color_convert_func(components.len(), is_jfif, color_transform)?;
794+
let upsampler = Upsampler::new(components, output_size.width, output_size.height)?;
795795
let line_size = output_size.width as usize * components.len();
796796
let mut image = vec![0u8; line_size * output_size.height as usize];
797797

@@ -812,8 +812,8 @@ fn compute_image_parallel(components: &[Component],
812812
output_size: Dimensions,
813813
is_jfif: bool,
814814
color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
815-
let color_convert_func = try!(choose_color_convert_func(components.len(), is_jfif, color_transform));
816-
let upsampler = try!(Upsampler::new(components, output_size.width, output_size.height));
815+
let color_convert_func = choose_color_convert_func(components.len(), is_jfif, color_transform)?;
816+
let upsampler = Upsampler::new(components, output_size.width, output_size.height)?;
817817
let line_size = output_size.width as usize * components.len();
818818
let mut image = vec![0u8; line_size * output_size.height as usize];
819819

0 commit comments

Comments
 (0)