public override void start_pass()
{
if (m_cinfo.m_progressive_mode)
{
bool bad = false;
/* Validate progressive scan parameters */
if (m_cinfo.m_Ss == 0)
{
if (m_cinfo.m_Se != 0)
bad = true;
}
else
{
/* need not check Ss/Se < 0 since they came from unsigned bytes */
if (m_cinfo.m_Se < m_cinfo.m_Ss || m_cinfo.m_Se > m_cinfo.lim_Se)
bad = true;
/* AC scans may have only one component */
if (m_cinfo.m_comps_in_scan != 1)
bad = true;
}
if (m_cinfo.m_Ah != 0)
{
/* Successive approximation refinement scan: must have Al = Ah-1. */
if (m_cinfo.m_Ah - 1 != m_cinfo.m_Al)
bad = true;
}
if (m_cinfo.m_Al > 13)
{
/* need not check for < 0 */
/* Arguably the maximum Al value should be less than 13 for 8-bit precision,
* but the spec doesn't say so, and we try to be liberal about what we
* accept. Note: large Al values could result in out-of-range DC
* coefficients during early scans, leading to bizarre displays due to
* overflows in the IDCT math. But we won't crash.
*/
bad = true;
}
if (bad)
{
m_cinfo.ERREXIT(J_MESSAGE_CODE.JERR_BAD_PROGRESSION,
m_cinfo.m_Ss, m_cinfo.m_Se, m_cinfo.m_Ah, m_cinfo.m_Al);
}
/* Update progression status, and verify that scan order is legal.
* Note that inter-scan inconsistencies are treated as warnings
* not fatal errors ... not clear if this is right way to behave.
*/
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
int cindex = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]].Component_index;
if (m_cinfo.m_Ss != 0 && m_cinfo.m_coef_bits[cindex][0] < 0)
{
/* AC without prior DC scan */
m_cinfo.WARNMS(J_MESSAGE_CODE.JWRN_BOGUS_PROGRESSION, cindex, 0);
}
for (int coefi = m_cinfo.m_Ss; coefi <= m_cinfo.m_Se; coefi++)
{
int expected = m_cinfo.m_coef_bits[cindex][coefi];
if (expected < 0)
expected = 0;
if (m_cinfo.m_Ah != expected)
m_cinfo.WARNMS(J_MESSAGE_CODE.JWRN_BOGUS_PROGRESSION, cindex, coefi);
m_cinfo.m_coef_bits[cindex][coefi] = m_cinfo.m_Al;
}
}
/* Select MCU decoding routine */
if (m_cinfo.m_Ah == 0)
{
if (m_cinfo.m_Ss == 0)
decode_mcu = decode_mcu_DC_first;
else
decode_mcu = decode_mcu_AC_first;
}
else
{
if (m_cinfo.m_Ss == 0)
decode_mcu = decode_mcu_DC_refine;
else
decode_mcu = decode_mcu_AC_refine;
}
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
jpeg_component_info compptr = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Make sure requested tables are present, and compute derived tables.
* We may build same derived table more than once, but it's not expensive.
*/
if (m_cinfo.m_Ss == 0)
{
if (m_cinfo.m_Ah == 0)
{
/* DC refinement needs no table */
int tbl = compptr.Dc_tbl_no;
jpeg_make_d_derived_tbl(true, tbl, ref derived_tbls[tbl]);
}
}
else
{
int tbl = compptr.Ac_tbl_no;
jpeg_make_d_derived_tbl(false, tbl, ref derived_tbls[tbl]);
/* remember the single active table */
ac_derived_tbl = derived_tbls[tbl];
}
/* Initialize DC predictions to 0 */
m_saved.last_dc_val[ci] = 0;
}
/* Initialize private state variables */
m_saved.EOBRUN = 0;
}
else
{
/* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
* This ought to be an error condition, but we make it a warning because
* there are some baseline files out there with all zeroes in these bytes.
*/
if (m_cinfo.m_Ss != 0 || m_cinfo.m_Ah != 0 || m_cinfo.m_Al != 0 ||
((m_cinfo.is_baseline || m_cinfo.m_Se < JpegConstants.DCTSIZE2) &&
m_cinfo.m_Se != m_cinfo.lim_Se))
{
m_cinfo.WARNMS(J_MESSAGE_CODE.JWRN_NOT_SEQUENTIAL);
}
/* Select MCU decoding routine */
/* We retain the hard-coded case for full-size blocks.
* This is not necessary, but it appears that this version is slightly
* more performant in the given implementation.
* With an improved implementation we would prefer a single optimized
* function.
*/
if (m_cinfo.lim_Se != JpegConstants.DCTSIZE2 - 1)
decode_mcu = decode_mcu_sub;
else
decode_mcu = decode_mcu_full;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
jpeg_component_info componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Compute derived values for Huffman tables */
/* We may do this more than once for a table, but it's not expensive */
int tbl = componentInfo.Dc_tbl_no;
jpeg_make_d_derived_tbl(true, tbl, ref m_dc_derived_tbls[tbl]);
if (m_cinfo.lim_Se != 0)
{
/* AC needs no table when not present */
tbl = componentInfo.Ac_tbl_no;
jpeg_make_d_derived_tbl(false, tbl, ref m_ac_derived_tbls[tbl]);
}
/* Initialize DC predictions to 0 */
m_saved.last_dc_val[ci] = 0;
}
/* Precalculate decoding info for each block in an MCU of this scan */
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int ci = m_cinfo.m_MCU_membership[blkn];
jpeg_component_info componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Precalculate which table to use for each block */
m_dc_cur_tbls[blkn] = m_dc_derived_tbls[componentInfo.Dc_tbl_no];
m_ac_cur_tbls[blkn] = m_ac_derived_tbls[componentInfo.Ac_tbl_no];
/* Decide whether we really care about the coefficient values */
if (componentInfo.component_needed)
{
ci = componentInfo.DCT_v_scaled_size;
int i = componentInfo.DCT_h_scaled_size;
switch (m_cinfo.lim_Se)
{
case (1 * 1 - 1):
coef_limit[blkn] = 1;
break;
case (2 * 2 - 1):
if (ci <= 0 || ci > 2)
ci = 2;
if (i <= 0 || i > 2)
i = 2;
coef_limit[blkn] = 1 + jpeg_zigzag_order2[ci - 1][i - 1];
break;
case (3 * 3 - 1):
if (ci <= 0 || ci > 3)
ci = 3;
if (i <= 0 || i > 3)
i = 3;
coef_limit[blkn] = 1 + jpeg_zigzag_order3[ci - 1][i - 1];
break;
case (4 * 4 - 1):
if (ci <= 0 || ci > 4)
ci = 4;
if (i <= 0 || i > 4)
i = 4;
coef_limit[blkn] = 1 + jpeg_zigzag_order4[ci - 1][i - 1];
break;
case (5 * 5 - 1):
if (ci <= 0 || ci > 5)
ci = 5;
if (i <= 0 || i > 5)
i = 5;
coef_limit[blkn] = 1 + jpeg_zigzag_order5[ci - 1][i - 1];
break;
case (6 * 6 - 1):
if (ci <= 0 || ci > 6)
ci = 6;
if (i <= 0 || i > 6)
i = 6;
coef_limit[blkn] = 1 + jpeg_zigzag_order6[ci - 1][i - 1];
break;
case (7 * 7 - 1):
if (ci <= 0 || ci > 7)
ci = 7;
if (i <= 0 || i > 7)
i = 7;
coef_limit[blkn] = 1 + jpeg_zigzag_order7[ci - 1][i - 1];
break;
default:
if (ci <= 0 || ci > 8)
ci = 8;
if (i <= 0 || i > 8)
i = 8;
coef_limit[blkn] = 1 + jpeg_zigzag_order[ci - 1][i - 1];
break;
}
}
else
{
coef_limit[blkn] = 0;
}
}
/* Initialize bitread state variables */
m_bitstate.bits_left = 0;
m_bitstate.get_buffer = 0;
m_insufficient_data = false;
/* Initialize restart counter */
m_restarts_to_go = m_cinfo.m_restart_interval;
}
}
