non
/
ntk
mirror of https://github.com/original-male/ntk
1
0
Fork 0
Code Releases 2 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
42 Commits
1 Branch
8.9MB
Tree: fc9a9aa987
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fc9a9aa987'
${ noResults }
ntk/jpeg/jdinput.c

662 lines
24KB
Raw Blame History 

  1. /*

  2.  * jdinput.c

  3.  *

  4.  * Copyright (C) 1991-1997, Thomas G. Lane.

  5.  * Modified 2002-2009 by Guido Vollbeding.

  6.  * This file is part of the Independent JPEG Group's software.

  7.  * For conditions of distribution and use, see the accompanying README file.

  8.  *

  9.  * This file contains input control logic for the JPEG decompressor.

  10.  * These routines are concerned with controlling the decompressor's input

  11.  * processing (marker reading and coefficient decoding).  The actual input

  12.  * reading is done in jdmarker.c, jdhuff.c, and jdarith.c.

  13.  */

  14. 

  15. #define JPEG_INTERNALS

  16. #include "jinclude.h"

  17. #include "jpeglib.h"

  18. 

  19. 

  20. /* Private state */

  21. 

  22. typedef struct {

  23.   struct jpeg_input_controller pub; /* public fields */

  24. 

  25.   int inheaders;		/* Nonzero until first SOS is reached */

  26. } my_input_controller;

  27. 

  28. typedef my_input_controller * my_inputctl_ptr;

  29. 

  30. 

  31. /* Forward declarations */

  32. METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo));

  33. 

  34. 

  35. /*

  36.  * Routines to calculate various quantities related to the size of the image.

  37.  */

  38. 

  39. 

  40. /*

  41.  * Compute output image dimensions and related values.

  42.  * NOTE: this is exported for possible use by application.

  43.  * Hence it mustn't do anything that can't be done twice.

  44.  */

  45. 

  46. GLOBAL(void)

  47. jpeg_core_output_dimensions (j_decompress_ptr cinfo)

  48. /* Do computations that are needed before master selection phase.

  49.  * This function is used for transcoding and full decompression.

  50.  */

  51. {

  52. #ifdef IDCT_SCALING_SUPPORTED

  53.   int ci;

  54.   jpeg_component_info *compptr;

  55. 

  56.   /* Compute actual output image dimensions and DCT scaling choices. */

  57.   if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom) {

  58.     /* Provide 1/block_size scaling */

  59.     cinfo->output_width = (JDIMENSION)

  60.       jdiv_round_up((long) cinfo->image_width, (long) cinfo->block_size);

  61.     cinfo->output_height = (JDIMENSION)

  62.       jdiv_round_up((long) cinfo->image_height, (long) cinfo->block_size);

  63.     cinfo->min_DCT_h_scaled_size = 1;

  64.     cinfo->min_DCT_v_scaled_size = 1;

  65.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 2) {

  66.     /* Provide 2/block_size scaling */

  67.     cinfo->output_width = (JDIMENSION)

  68.       jdiv_round_up((long) cinfo->image_width * 2L, (long) cinfo->block_size);

  69.     cinfo->output_height = (JDIMENSION)

  70.       jdiv_round_up((long) cinfo->image_height * 2L, (long) cinfo->block_size);

  71.     cinfo->min_DCT_h_scaled_size = 2;

  72.     cinfo->min_DCT_v_scaled_size = 2;

  73.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 3) {

  74.     /* Provide 3/block_size scaling */

  75.     cinfo->output_width = (JDIMENSION)

  76.       jdiv_round_up((long) cinfo->image_width * 3L, (long) cinfo->block_size);

  77.     cinfo->output_height = (JDIMENSION)

  78.       jdiv_round_up((long) cinfo->image_height * 3L, (long) cinfo->block_size);

  79.     cinfo->min_DCT_h_scaled_size = 3;

  80.     cinfo->min_DCT_v_scaled_size = 3;

  81.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 4) {

  82.     /* Provide 4/block_size scaling */

  83.     cinfo->output_width = (JDIMENSION)

  84.       jdiv_round_up((long) cinfo->image_width * 4L, (long) cinfo->block_size);

  85.     cinfo->output_height = (JDIMENSION)

  86.       jdiv_round_up((long) cinfo->image_height * 4L, (long) cinfo->block_size);

  87.     cinfo->min_DCT_h_scaled_size = 4;

  88.     cinfo->min_DCT_v_scaled_size = 4;

  89.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 5) {

  90.     /* Provide 5/block_size scaling */

  91.     cinfo->output_width = (JDIMENSION)

  92.       jdiv_round_up((long) cinfo->image_width * 5L, (long) cinfo->block_size);

  93.     cinfo->output_height = (JDIMENSION)

  94.       jdiv_round_up((long) cinfo->image_height * 5L, (long) cinfo->block_size);

  95.     cinfo->min_DCT_h_scaled_size = 5;

  96.     cinfo->min_DCT_v_scaled_size = 5;

  97.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 6) {

  98.     /* Provide 6/block_size scaling */

  99.     cinfo->output_width = (JDIMENSION)

  100.       jdiv_round_up((long) cinfo->image_width * 6L, (long) cinfo->block_size);

  101.     cinfo->output_height = (JDIMENSION)

  102.       jdiv_round_up((long) cinfo->image_height * 6L, (long) cinfo->block_size);

  103.     cinfo->min_DCT_h_scaled_size = 6;

  104.     cinfo->min_DCT_v_scaled_size = 6;

  105.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 7) {

  106.     /* Provide 7/block_size scaling */

  107.     cinfo->output_width = (JDIMENSION)

  108.       jdiv_round_up((long) cinfo->image_width * 7L, (long) cinfo->block_size);

  109.     cinfo->output_height = (JDIMENSION)

  110.       jdiv_round_up((long) cinfo->image_height * 7L, (long) cinfo->block_size);

  111.     cinfo->min_DCT_h_scaled_size = 7;

  112.     cinfo->min_DCT_v_scaled_size = 7;

  113.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 8) {

  114.     /* Provide 8/block_size scaling */

  115.     cinfo->output_width = (JDIMENSION)

  116.       jdiv_round_up((long) cinfo->image_width * 8L, (long) cinfo->block_size);

  117.     cinfo->output_height = (JDIMENSION)

  118.       jdiv_round_up((long) cinfo->image_height * 8L, (long) cinfo->block_size);

  119.     cinfo->min_DCT_h_scaled_size = 8;

  120.     cinfo->min_DCT_v_scaled_size = 8;

  121.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 9) {

  122.     /* Provide 9/block_size scaling */

  123.     cinfo->output_width = (JDIMENSION)

  124.       jdiv_round_up((long) cinfo->image_width * 9L, (long) cinfo->block_size);

  125.     cinfo->output_height = (JDIMENSION)

  126.       jdiv_round_up((long) cinfo->image_height * 9L, (long) cinfo->block_size);

  127.     cinfo->min_DCT_h_scaled_size = 9;

  128.     cinfo->min_DCT_v_scaled_size = 9;

  129.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 10) {

  130.     /* Provide 10/block_size scaling */

  131.     cinfo->output_width = (JDIMENSION)

  132.       jdiv_round_up((long) cinfo->image_width * 10L, (long) cinfo->block_size);

  133.     cinfo->output_height = (JDIMENSION)

  134.       jdiv_round_up((long) cinfo->image_height * 10L, (long) cinfo->block_size);

  135.     cinfo->min_DCT_h_scaled_size = 10;

  136.     cinfo->min_DCT_v_scaled_size = 10;

  137.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 11) {

  138.     /* Provide 11/block_size scaling */

  139.     cinfo->output_width = (JDIMENSION)

  140.       jdiv_round_up((long) cinfo->image_width * 11L, (long) cinfo->block_size);

  141.     cinfo->output_height = (JDIMENSION)

  142.       jdiv_round_up((long) cinfo->image_height * 11L, (long) cinfo->block_size);

  143.     cinfo->min_DCT_h_scaled_size = 11;

  144.     cinfo->min_DCT_v_scaled_size = 11;

  145.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 12) {

  146.     /* Provide 12/block_size scaling */

  147.     cinfo->output_width = (JDIMENSION)

  148.       jdiv_round_up((long) cinfo->image_width * 12L, (long) cinfo->block_size);

  149.     cinfo->output_height = (JDIMENSION)

  150.       jdiv_round_up((long) cinfo->image_height * 12L, (long) cinfo->block_size);

  151.     cinfo->min_DCT_h_scaled_size = 12;

  152.     cinfo->min_DCT_v_scaled_size = 12;

  153.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 13) {

  154.     /* Provide 13/block_size scaling */

  155.     cinfo->output_width = (JDIMENSION)

  156.       jdiv_round_up((long) cinfo->image_width * 13L, (long) cinfo->block_size);

  157.     cinfo->output_height = (JDIMENSION)

  158.       jdiv_round_up((long) cinfo->image_height * 13L, (long) cinfo->block_size);

  159.     cinfo->min_DCT_h_scaled_size = 13;

  160.     cinfo->min_DCT_v_scaled_size = 13;

  161.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 14) {

  162.     /* Provide 14/block_size scaling */

  163.     cinfo->output_width = (JDIMENSION)

  164.       jdiv_round_up((long) cinfo->image_width * 14L, (long) cinfo->block_size);

  165.     cinfo->output_height = (JDIMENSION)

  166.       jdiv_round_up((long) cinfo->image_height * 14L, (long) cinfo->block_size);

  167.     cinfo->min_DCT_h_scaled_size = 14;

  168.     cinfo->min_DCT_v_scaled_size = 14;

  169.   } else if (cinfo->scale_num * cinfo->block_size <= cinfo->scale_denom * 15) {

  170.     /* Provide 15/block_size scaling */

  171.     cinfo->output_width = (JDIMENSION)

  172.       jdiv_round_up((long) cinfo->image_width * 15L, (long) cinfo->block_size);

  173.     cinfo->output_height = (JDIMENSION)

  174.       jdiv_round_up((long) cinfo->image_height * 15L, (long) cinfo->block_size);

  175.     cinfo->min_DCT_h_scaled_size = 15;

  176.     cinfo->min_DCT_v_scaled_size = 15;

  177.   } else {

  178.     /* Provide 16/block_size scaling */

  179.     cinfo->output_width = (JDIMENSION)

  180.       jdiv_round_up((long) cinfo->image_width * 16L, (long) cinfo->block_size);

  181.     cinfo->output_height = (JDIMENSION)

  182.       jdiv_round_up((long) cinfo->image_height * 16L, (long) cinfo->block_size);

  183.     cinfo->min_DCT_h_scaled_size = 16;

  184.     cinfo->min_DCT_v_scaled_size = 16;

  185.   }

  186. 

  187.   /* Recompute dimensions of components */

  188.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;

  189.        ci++, compptr++) {

  190.     compptr->DCT_h_scaled_size = cinfo->min_DCT_h_scaled_size;

  191.     compptr->DCT_v_scaled_size = cinfo->min_DCT_v_scaled_size;

  192.   }

  193. 

  194. #else /* !IDCT_SCALING_SUPPORTED */

  195. 

  196.   /* Hardwire it to "no scaling" */

  197.   cinfo->output_width = cinfo->image_width;

  198.   cinfo->output_height = cinfo->image_height;

  199.   /* jdinput.c has already initialized DCT_scaled_size,

  200.    * and has computed unscaled downsampled_width and downsampled_height.

  201.    */

  202. 

  203. #endif /* IDCT_SCALING_SUPPORTED */

  204. }

  205. 

  206. 

  207. LOCAL(void)

  208. initial_setup (j_decompress_ptr cinfo)

  209. /* Called once, when first SOS marker is reached */

  210. {

  211.   int ci;

  212.   jpeg_component_info *compptr;

  213. 

  214.   /* Make sure image isn't bigger than I can handle */

  215.   if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||

  216.       (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)

  217.     ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);

  218. 

  219.   /* For now, precision must match compiled-in value... */

  220.   if (cinfo->data_precision != BITS_IN_JSAMPLE)

  221.     ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);

  222. 

  223.   /* Check that number of components won't exceed internal array sizes */

  224.   if (cinfo->num_components > MAX_COMPONENTS)

  225.     ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,

  226. 	     MAX_COMPONENTS);

  227. 

  228.   /* Compute maximum sampling factors; check factor validity */

  229.   cinfo->max_h_samp_factor = 1;

  230.   cinfo->max_v_samp_factor = 1;

  231.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;

  232.        ci++, compptr++) {

  233.     if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||

  234. 	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)

  235.       ERREXIT(cinfo, JERR_BAD_SAMPLING);

  236.     cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,

  237. 				   compptr->h_samp_factor);

  238.     cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,

  239. 				   compptr->v_samp_factor);

  240.   }

  241. 

  242.   /* Derive block_size, natural_order, and lim_Se */

  243.   if (cinfo->is_baseline || (cinfo->progressive_mode &&

  244.       cinfo->comps_in_scan)) { /* no pseudo SOS marker */

  245.     cinfo->block_size = DCTSIZE;

  246.     cinfo->natural_order = jpeg_natural_order;

  247.     cinfo->lim_Se = DCTSIZE2-1;

  248.   } else

  249.     switch (cinfo->Se) {

  250.     case (1*1-1):

  251.       cinfo->block_size = 1;

  252.       cinfo->natural_order = jpeg_natural_order; /* not needed */

  253.       cinfo->lim_Se = cinfo->Se;

  254.       break;

  255.     case (2*2-1):

  256.       cinfo->block_size = 2;

  257.       cinfo->natural_order = jpeg_natural_order2;

  258.       cinfo->lim_Se = cinfo->Se;

  259.       break;

  260.     case (3*3-1):

  261.       cinfo->block_size = 3;

  262.       cinfo->natural_order = jpeg_natural_order3;

  263.       cinfo->lim_Se = cinfo->Se;

  264.       break;

  265.     case (4*4-1):

  266.       cinfo->block_size = 4;

  267.       cinfo->natural_order = jpeg_natural_order4;

  268.       cinfo->lim_Se = cinfo->Se;

  269.       break;

  270.     case (5*5-1):

  271.       cinfo->block_size = 5;

  272.       cinfo->natural_order = jpeg_natural_order5;

  273.       cinfo->lim_Se = cinfo->Se;

  274.       break;

  275.     case (6*6-1):

  276.       cinfo->block_size = 6;

  277.       cinfo->natural_order = jpeg_natural_order6;

  278.       cinfo->lim_Se = cinfo->Se;

  279.       break;

  280.     case (7*7-1):

  281.       cinfo->block_size = 7;

  282.       cinfo->natural_order = jpeg_natural_order7;

  283.       cinfo->lim_Se = cinfo->Se;

  284.       break;

  285.     case (8*8-1):

  286.       cinfo->block_size = 8;

  287.       cinfo->natural_order = jpeg_natural_order;

  288.       cinfo->lim_Se = DCTSIZE2-1;

  289.       break;

  290.     case (9*9-1):

  291.       cinfo->block_size = 9;

  292.       cinfo->natural_order = jpeg_natural_order;

  293.       cinfo->lim_Se = DCTSIZE2-1;

  294.       break;

  295.     case (10*10-1):

  296.       cinfo->block_size = 10;

  297.       cinfo->natural_order = jpeg_natural_order;

  298.       cinfo->lim_Se = DCTSIZE2-1;

  299.       break;

  300.     case (11*11-1):

  301.       cinfo->block_size = 11;

  302.       cinfo->natural_order = jpeg_natural_order;

  303.       cinfo->lim_Se = DCTSIZE2-1;

  304.       break;

  305.     case (12*12-1):

  306.       cinfo->block_size = 12;

  307.       cinfo->natural_order = jpeg_natural_order;

  308.       cinfo->lim_Se = DCTSIZE2-1;

  309.       break;

  310.     case (13*13-1):

  311.       cinfo->block_size = 13;

  312.       cinfo->natural_order = jpeg_natural_order;

  313.       cinfo->lim_Se = DCTSIZE2-1;

  314.       break;

  315.     case (14*14-1):

  316.       cinfo->block_size = 14;

  317.       cinfo->natural_order = jpeg_natural_order;

  318.       cinfo->lim_Se = DCTSIZE2-1;

  319.       break;

  320.     case (15*15-1):

  321.       cinfo->block_size = 15;

  322.       cinfo->natural_order = jpeg_natural_order;

  323.       cinfo->lim_Se = DCTSIZE2-1;

  324.       break;

  325.     case (16*16-1):

  326.       cinfo->block_size = 16;

  327.       cinfo->natural_order = jpeg_natural_order;

  328.       cinfo->lim_Se = DCTSIZE2-1;

  329.       break;

  330.     default:

  331.       ERREXIT4(cinfo, JERR_BAD_PROGRESSION,

  332. 	       cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);

  333.       break;

  334.     }

  335. 

  336.   /* We initialize DCT_scaled_size and min_DCT_scaled_size to block_size.

  337.    * In the full decompressor,

  338.    * this will be overridden by jpeg_calc_output_dimensions in jdmaster.c;

  339.    * but in the transcoder,

  340.    * jpeg_calc_output_dimensions is not used, so we must do it here.

  341.    */

  342.   cinfo->min_DCT_h_scaled_size = cinfo->block_size;

  343.   cinfo->min_DCT_v_scaled_size = cinfo->block_size;

  344. 

  345.   /* Compute dimensions of components */

  346.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;

  347.        ci++, compptr++) {

  348.     compptr->DCT_h_scaled_size = cinfo->block_size;

  349.     compptr->DCT_v_scaled_size = cinfo->block_size;

  350.     /* Size in DCT blocks */

  351.     compptr->width_in_blocks = (JDIMENSION)

  352.       jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,

  353. 		    (long) (cinfo->max_h_samp_factor * cinfo->block_size));

  354.     compptr->height_in_blocks = (JDIMENSION)

  355.       jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,

  356. 		    (long) (cinfo->max_v_samp_factor * cinfo->block_size));

  357.     /* downsampled_width and downsampled_height will also be overridden by

  358.      * jdmaster.c if we are doing full decompression.  The transcoder library

  359.      * doesn't use these values, but the calling application might.

  360.      */

  361.     /* Size in samples */

  362.     compptr->downsampled_width = (JDIMENSION)

  363.       jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,

  364. 		    (long) cinfo->max_h_samp_factor);

  365.     compptr->downsampled_height = (JDIMENSION)

  366.       jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,

  367. 		    (long) cinfo->max_v_samp_factor);

  368.     /* Mark component needed, until color conversion says otherwise */

  369.     compptr->component_needed = TRUE;

  370.     /* Mark no quantization table yet saved for component */

  371.     compptr->quant_table = NULL;

  372.   }

  373. 

  374.   /* Compute number of fully interleaved MCU rows. */

  375.   cinfo->total_iMCU_rows = (JDIMENSION)

  376.     jdiv_round_up((long) cinfo->image_height,

  377. 	          (long) (cinfo->max_v_samp_factor * cinfo->block_size));

  378. 

  379.   /* Decide whether file contains multiple scans */

  380.   if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)

  381.     cinfo->inputctl->has_multiple_scans = TRUE;

  382.   else

  383.     cinfo->inputctl->has_multiple_scans = FALSE;

  384. }

  385. 

  386. 

  387. LOCAL(void)

  388. per_scan_setup (j_decompress_ptr cinfo)

  389. /* Do computations that are needed before processing a JPEG scan */

  390. /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */

  391. {

  392.   int ci, mcublks, tmp;

  393.   jpeg_component_info *compptr;

  394.   

  395.   if (cinfo->comps_in_scan == 1) {

  396.     

  397.     /* Noninterleaved (single-component) scan */

  398.     compptr = cinfo->cur_comp_info[0];

  399.     

  400.     /* Overall image size in MCUs */

  401.     cinfo->MCUs_per_row = compptr->width_in_blocks;

  402.     cinfo->MCU_rows_in_scan = compptr->height_in_blocks;

  403.     

  404.     /* For noninterleaved scan, always one block per MCU */

  405.     compptr->MCU_width = 1;

  406.     compptr->MCU_height = 1;

  407.     compptr->MCU_blocks = 1;

  408.     compptr->MCU_sample_width = compptr->DCT_h_scaled_size;

  409.     compptr->last_col_width = 1;

  410.     /* For noninterleaved scans, it is convenient to define last_row_height

  411.      * as the number of block rows present in the last iMCU row.

  412.      */

  413.     tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);

  414.     if (tmp == 0) tmp = compptr->v_samp_factor;

  415.     compptr->last_row_height = tmp;

  416.     

  417.     /* Prepare array describing MCU composition */

  418.     cinfo->blocks_in_MCU = 1;

  419.     cinfo->MCU_membership[0] = 0;

  420.     

  421.   } else {

  422.     

  423.     /* Interleaved (multi-component) scan */

  424.     if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)

  425.       ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,

  426. 	       MAX_COMPS_IN_SCAN);

  427.     

  428.     /* Overall image size in MCUs */

  429.     cinfo->MCUs_per_row = (JDIMENSION)

  430.       jdiv_round_up((long) cinfo->image_width,

  431. 		    (long) (cinfo->max_h_samp_factor * cinfo->block_size));

  432.     cinfo->MCU_rows_in_scan = (JDIMENSION)

  433.       jdiv_round_up((long) cinfo->image_height,

  434. 		    (long) (cinfo->max_v_samp_factor * cinfo->block_size));

  435.     

  436.     cinfo->blocks_in_MCU = 0;

  437.     

  438.     for (ci = 0; ci < cinfo->comps_in_scan; ci++) {

  439.       compptr = cinfo->cur_comp_info[ci];

  440.       /* Sampling factors give # of blocks of component in each MCU */

  441.       compptr->MCU_width = compptr->h_samp_factor;

  442.       compptr->MCU_height = compptr->v_samp_factor;

  443.       compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;

  444.       compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_h_scaled_size;

  445.       /* Figure number of non-dummy blocks in last MCU column & row */

  446.       tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);

  447.       if (tmp == 0) tmp = compptr->MCU_width;

  448.       compptr->last_col_width = tmp;

  449.       tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);

  450.       if (tmp == 0) tmp = compptr->MCU_height;

  451.       compptr->last_row_height = tmp;

  452.       /* Prepare array describing MCU composition */

  453.       mcublks = compptr->MCU_blocks;

  454.       if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)

  455. 	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);

  456.       while (mcublks-- > 0) {

  457. 	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;

  458.       }

  459.     }

  460.     

  461.   }

  462. }

  463. 

  464. 

  465. /*

  466.  * Save away a copy of the Q-table referenced by each component present

  467.  * in the current scan, unless already saved during a prior scan.

  468.  *

  469.  * In a multiple-scan JPEG file, the encoder could assign different components

  470.  * the same Q-table slot number, but change table definitions between scans

  471.  * so that each component uses a different Q-table.  (The IJG encoder is not

  472.  * currently capable of doing this, but other encoders might.)  Since we want

  473.  * to be able to dequantize all the components at the end of the file, this

  474.  * means that we have to save away the table actually used for each component.

  475.  * We do this by copying the table at the start of the first scan containing

  476.  * the component.

  477.  * The JPEG spec prohibits the encoder from changing the contents of a Q-table

  478.  * slot between scans of a component using that slot.  If the encoder does so

  479.  * anyway, this decoder will simply use the Q-table values that were current

  480.  * at the start of the first scan for the component.

  481.  *

  482.  * The decompressor output side looks only at the saved quant tables,

  483.  * not at the current Q-table slots.

  484.  */

  485. 

  486. LOCAL(void)

  487. latch_quant_tables (j_decompress_ptr cinfo)

  488. {

  489.   int ci, qtblno;

  490.   jpeg_component_info *compptr;

  491.   JQUANT_TBL * qtbl;

  492. 

  493.   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {

  494.     compptr = cinfo->cur_comp_info[ci];

  495.     /* No work if we already saved Q-table for this component */

  496.     if (compptr->quant_table != NULL)

  497.       continue;

  498.     /* Make sure specified quantization table is present */

  499.     qtblno = compptr->quant_tbl_no;

  500.     if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||

  501. 	cinfo->quant_tbl_ptrs[qtblno] == NULL)

  502.       ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);

  503.     /* OK, save away the quantization table */

  504.     qtbl = (JQUANT_TBL *)

  505.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,

  506. 				  SIZEOF(JQUANT_TBL));

  507.     MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));

  508.     compptr->quant_table = qtbl;

  509.   }

  510. }

  511. 

  512. 

  513. /*

  514.  * Initialize the input modules to read a scan of compressed data.

  515.  * The first call to this is done by jdmaster.c after initializing

  516.  * the entire decompressor (during jpeg_start_decompress).

  517.  * Subsequent calls come from consume_markers, below.

  518.  */

  519. 

  520. METHODDEF(void)

  521. start_input_pass (j_decompress_ptr cinfo)

  522. {

  523.   per_scan_setup(cinfo);

  524.   latch_quant_tables(cinfo);

  525.   (*cinfo->entropy->start_pass) (cinfo);

  526.   (*cinfo->coef->start_input_pass) (cinfo);

  527.   cinfo->inputctl->consume_input = cinfo->coef->consume_data;

  528. }

  529. 

  530. 

  531. /*

  532.  * Finish up after inputting a compressed-data scan.

  533.  * This is called by the coefficient controller after it's read all

  534.  * the expected data of the scan.

  535.  */

  536. 

  537. METHODDEF(void)

  538. finish_input_pass (j_decompress_ptr cinfo)

  539. {

  540.   cinfo->inputctl->consume_input = consume_markers;

  541. }

  542. 

  543. 

  544. /*

  545.  * Read JPEG markers before, between, or after compressed-data scans.

  546.  * Change state as necessary when a new scan is reached.

  547.  * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.

  548.  *

  549.  * The consume_input method pointer points either here or to the

  550.  * coefficient controller's consume_data routine, depending on whether

  551.  * we are reading a compressed data segment or inter-segment markers.

  552.  *

  553.  * Note: This function should NOT return a pseudo SOS marker (with zero

  554.  * component number) to the caller.  A pseudo marker received by

  555.  * read_markers is processed and then skipped for other markers.

  556.  */

  557. 

  558. METHODDEF(int)

  559. consume_markers (j_decompress_ptr cinfo)

  560. {

  561.   my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;

  562.   int val;

  563. 

  564.   if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */

  565.     return JPEG_REACHED_EOI;

  566. 

  567.   for (;;) {			/* Loop to pass pseudo SOS marker */

  568.     val = (*cinfo->marker->read_markers) (cinfo);

  569. 

  570.     switch (val) {

  571.     case JPEG_REACHED_SOS:	/* Found SOS */

  572.       if (inputctl->inheaders) { /* 1st SOS */

  573. 	if (inputctl->inheaders == 1)

  574. 	  initial_setup(cinfo);

  575. 	if (cinfo->comps_in_scan == 0) { /* pseudo SOS marker */

  576. 	  inputctl->inheaders = 2;

  577. 	  break;

  578. 	}

  579. 	inputctl->inheaders = 0;

  580. 	/* Note: start_input_pass must be called by jdmaster.c

  581. 	 * before any more input can be consumed.  jdapimin.c is

  582. 	 * responsible for enforcing this sequencing.

  583. 	 */

  584.       } else {			/* 2nd or later SOS marker */

  585. 	if (! inputctl->pub.has_multiple_scans)

  586. 	  ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */

  587. 	if (cinfo->comps_in_scan == 0) /* unexpected pseudo SOS marker */

  588. 	  break;

  589. 	start_input_pass(cinfo);

  590.       }

  591.       return val;

  592.     case JPEG_REACHED_EOI:	/* Found EOI */

  593.       inputctl->pub.eoi_reached = TRUE;

  594.       if (inputctl->inheaders) { /* Tables-only datastream, apparently */

  595. 	if (cinfo->marker->saw_SOF)

  596. 	  ERREXIT(cinfo, JERR_SOF_NO_SOS);

  597.       } else {

  598. 	/* Prevent infinite loop in coef ctlr's decompress_data routine

  599. 	 * if user set output_scan_number larger than number of scans.

  600. 	 */

  601. 	if (cinfo->output_scan_number > cinfo->input_scan_number)

  602. 	  cinfo->output_scan_number = cinfo->input_scan_number;

  603.       }

  604.       return val;

  605.     case JPEG_SUSPENDED:

  606.       return val;

  607.     default:

  608.       return val;

  609.     }

  610.   }

  611. }

  612. 

  613. 

  614. /*

  615.  * Reset state to begin a fresh datastream.

  616.  */

  617. 

  618. METHODDEF(void)

  619. reset_input_controller (j_decompress_ptr cinfo)

  620. {

  621.   my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;

  622. 

  623.   inputctl->pub.consume_input = consume_markers;

  624.   inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */

  625.   inputctl->pub.eoi_reached = FALSE;

  626.   inputctl->inheaders = 1;

  627.   /* Reset other modules */

  628.   (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);

  629.   (*cinfo->marker->reset_marker_reader) (cinfo);

  630.   /* Reset progression state -- would be cleaner if entropy decoder did this */

  631.   cinfo->coef_bits = NULL;

  632. }

  633. 

  634. 

  635. /*

  636.  * Initialize the input controller module.

  637.  * This is called only once, when the decompression object is created.

  638.  */

  639. 

  640. GLOBAL(void)

  641. jinit_input_controller (j_decompress_ptr cinfo)

  642. {

  643.   my_inputctl_ptr inputctl;

  644. 

  645.   /* Create subobject in permanent pool */

  646.   inputctl = (my_inputctl_ptr)

  647.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,

  648. 				SIZEOF(my_input_controller));

  649.   cinfo->inputctl = (struct jpeg_input_controller *) inputctl;

  650.   /* Initialize method pointers */

  651.   inputctl->pub.consume_input = consume_markers;

  652.   inputctl->pub.reset_input_controller = reset_input_controller;

  653.   inputctl->pub.start_input_pass = start_input_pass;

  654.   inputctl->pub.finish_input_pass = finish_input_pass;

  655.   /* Initialize state: can't use reset_input_controller since we don't

  656.    * want to try to reset other modules yet.

  657.    */

  658.   inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */

  659.   inputctl->pub.eoi_reached = FALSE;

  660.   inputctl->inheaders = 1;

  661. }