     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74

    use decoder::MAX_COMPONENTS;
    use error::Result;
    use idct::dequantize_and_idct_block;
    use std::mem;
    use std::sync::Arc;
    use parser::Component;
    use super::{RowData, Worker};

    pub struct ImmediateWorker {
        offsets: [usize; MAX_COMPONENTS],
        results: Vec<Vec<u8>>,
        components: Vec<Option<Component>>,
        quantization_tables: Vec<Option<Arc<[u16; 64]>>>,
    }

    impl ImmediateWorker {
        pub fn new_immediate() -> ImmediateWorker {
            ImmediateWorker {
                offsets: [0; MAX_COMPONENTS],
                results: vec![Vec::new(); MAX_COMPONENTS],
                components: vec![None; MAX_COMPONENTS],
                quantization_tables: vec![None; MAX_COMPONENTS],
            }
        }
        pub fn start_immediate(&mut self, data: RowData) {
            assert!(self.results[data.index].is_empty());

            self.offsets[data.index] = 0;
            self.results[data.index].resize(data.component.block_size.width as usize * data.component.block_size.height as usize * 64, 0u8);
            self.components[data.index] = Some(data.component);
            self.quantization_tables[data.index] = Some(data.quantization_table);
        }
        pub fn append_row_immediate(&mut self, (index, data): (usize, Vec<i16>)) {
            // Convert coefficients from a MCU row to samples.

            let component = self.components[index].as_ref().unwrap();
            let quantization_table = self.quantization_tables[index].as_ref().unwrap();
            let block_count = component.block_size.width as usize * component.vertical_sampling_factor as usize;
            let line_stride = component.block_size.width as usize * 8;

            assert_eq!(data.len(), block_count * 64);

            for i in 0..block_count {
                let x = (i % component.block_size.width as usize) * 8;
                let y = (i / component.block_size.width as usize) * 8;
                dequantize_and_idct_block(&data[i * 64..(i + 1) * 64],
                                        quantization_table,
                                        line_stride,
                                        &mut self.results[index][self.offsets[index] + y * line_stride + x..]);
            }

            self.offsets[index] += data.len();
        }
        pub fn get_result_immediate(&mut self, index: usize) -> Vec<u8> {
            mem::replace(&mut self.results[index], Vec::new())
        }
    }

    impl Worker for ImmediateWorker {
        fn new() -> Result<Self> {
            Ok(ImmediateWorker::new_immediate())
        }
        fn start(&mut self, data: RowData) -> Result<()> {
            self.start_immediate(data);
            Ok(())
        }
        fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> {
            self.append_row_immediate(row);
            Ok(())
        }
        fn get_result(&mut self, index: usize) -> Result<Vec<u8>> {
            Ok(self.get_result_immediate(index))
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)