Example #1
0
 private void OJPEGWriteStreamRst(out byte[] mem, out uint len)
 {
     Debug.Assert(OJPEG_BUFFER >= 2);
     m_out_buffer[0] = 255;
     m_out_buffer[1] = (byte)((byte)JpegMarkerType.RST0 + m_restart_index);
     m_restart_index++;
     if (m_restart_index == 8)
         m_restart_index = 0;
     len = 2;
     mem = m_out_buffer;
     m_out_state = OJPEGStateOutState.ososCompressed;
 }
Example #2
0
        private bool OJPEGWriteHeaderInfo()
        {
            Debug.Assert(!m_libjpeg_session_active);

            m_out_state = OJPEGStateOutState.ososSoi;
            m_restart_index = 0;

            if (!jpeg_create_decompress_encap())
                return false;

            m_libjpeg_session_active = true;
            m_libjpeg_jpeg_source_mgr = new OJpegSrcManager(this);
            m_libjpeg_jpeg_decompress_struct.Src = m_libjpeg_jpeg_source_mgr;

            if (jpeg_read_header_encap(true) == ReadResult.Suspended)
                return false;

            if (!m_subsampling_force_desubsampling_inside_decompression && (m_samples_per_pixel_per_plane > 1))
            {
                m_libjpeg_jpeg_decompress_struct.Raw_data_out = true;
                //#if JPEG_LIB_VERSION >= 70
                //    libjpeg_jpeg_decompress_struct.do_fancy_upsampling=FALSE;
                //#endif
                m_libjpeg_jpeg_query_style = 0;
                if (!m_subsampling_convert_log)
                {
                    Debug.Assert(m_subsampling_convert_ybuf == null);
                    Debug.Assert(m_subsampling_convert_cbbuf == null);
                    Debug.Assert(m_subsampling_convert_crbuf == null);
                    Debug.Assert(m_subsampling_convert_ycbcrimage == null);

                    m_subsampling_convert_ylinelen = (uint)((m_strile_width + m_subsampling_hor * 8 - 1) / (m_subsampling_hor * 8) * m_subsampling_hor * 8);
                    m_subsampling_convert_ylines = (uint)(m_subsampling_ver * 8);
                    m_subsampling_convert_clinelen = m_subsampling_convert_ylinelen / m_subsampling_hor;
                    m_subsampling_convert_clines = 8;

                    m_subsampling_convert_ybuf = new byte[m_subsampling_convert_ylines][];
                    for (int i = 0; i < m_subsampling_convert_ylines; i++)
                        m_subsampling_convert_ybuf[i] = new byte[m_subsampling_convert_ylinelen];

                    m_subsampling_convert_cbbuf = new byte[m_subsampling_convert_clines][];
                    m_subsampling_convert_crbuf = new byte[m_subsampling_convert_clines][];
                    for (int i = 0; i < m_subsampling_convert_clines; i++)
                    {
                        m_subsampling_convert_cbbuf[i] = new byte[m_subsampling_convert_clinelen];
                        m_subsampling_convert_crbuf[i] = new byte[m_subsampling_convert_clinelen];
                    }

                    m_subsampling_convert_ycbcrimage = new byte[3][][];
                    m_subsampling_convert_ycbcrimage[0] = new byte[m_subsampling_convert_ylines][];
                    for (uint n = 0; n < m_subsampling_convert_ylines; n++)
                        m_subsampling_convert_ycbcrimage[0][n] = m_subsampling_convert_ybuf[n];

                    m_subsampling_convert_ycbcrimage[1] = new byte[m_subsampling_convert_clines][];
                    for (uint n = 0; n < m_subsampling_convert_clines; n++)
                        m_subsampling_convert_ycbcrimage[1][n] = m_subsampling_convert_cbbuf[n];

                    m_subsampling_convert_ycbcrimage[2] = new byte[m_subsampling_convert_clines][];
                    for (uint n = 0; n < m_subsampling_convert_clines; n++)
                        m_subsampling_convert_ycbcrimage[2][n] = m_subsampling_convert_crbuf[n];

                    m_subsampling_convert_clinelenout = ((m_strile_width + m_subsampling_hor - 1) / m_subsampling_hor);
                    m_subsampling_convert_state = 0;
                    m_bytes_per_line = (uint)(m_subsampling_convert_clinelenout * (m_subsampling_ver * m_subsampling_hor + 2));
                    m_lines_per_strile = ((m_strile_length + m_subsampling_ver - 1) / m_subsampling_ver);
                    m_subsampling_convert_log = true;
                }
            }
            else
            {
                m_libjpeg_jpeg_decompress_struct.Jpeg_color_space = ColorSpace.Unknown;
                m_libjpeg_jpeg_decompress_struct.Out_color_space = ColorSpace.Unknown;
                m_libjpeg_jpeg_query_style = 1;
                m_bytes_per_line = m_samples_per_pixel_per_plane * m_strile_width;
                m_lines_per_strile = m_strile_length;
            }

            if (!jpeg_start_decompress_encap())
                return false;

            m_writeheader_done = true;
            return true;
        }
Example #3
0
        private bool OJPEGWriteStreamCompressed(out byte[] mem, out uint len)
        {
            mem = null;
            len = 0;

            if (m_in_buffer_togo == 0)
            {
                if (!OJPEGReadBufferFill())
                    return false;
                Debug.Assert(m_in_buffer_togo > 0);
            }
            len = m_in_buffer_togo;

            if (m_in_buffer_cur == 0)
            {
                mem = m_in_buffer;
            }
            else
            {
                mem = new byte[len];
                Buffer.BlockCopy(m_in_buffer, m_in_buffer_cur, mem, 0, (int)len);
            }

            m_in_buffer_togo = 0;
            if (m_in_buffer_file_togo == 0)
            {
                switch (m_in_buffer_source)
                {
                    case OJPEGStateInBufferSource.osibsStrile:
                        if (m_in_buffer_next_strile < m_in_buffer_strile_count)
                            m_out_state = OJPEGStateOutState.ososRst;
                        else
                            m_out_state = OJPEGStateOutState.ososEoi;
                        break;
                    case OJPEGStateInBufferSource.osibsEof:
                        m_out_state = OJPEGStateOutState.ososEoi;
                        break;
                    default:
                        break;
                }
            }
            return true;
        }
Example #4
0
        private void cleanState()
        {
            m_jpeg_interchange_format = 0;
            m_jpeg_interchange_format_length = 0;
            m_jpeg_proc = 0;

            m_subsamplingcorrect_done = false;
            m_subsampling_tag = false;
            m_subsampling_hor = 0;
            m_subsampling_ver = 0;

            m_qtable_offset_count = 0;
            m_dctable_offset_count = 0;
            m_actable_offset_count = 0;
            m_qtable_offset = new uint[3];
            m_dctable_offset = new uint[3];
            m_actable_offset = new uint[3];

            m_restart_interval = 0;

            m_libjpeg_jpeg_decompress_struct = null;

            m_file_size = 0;
            m_image_width = 0;
            m_image_length = 0;
            m_strile_width = 0;
            m_strile_length = 0;
            m_strile_length_total = 0;
            m_samples_per_pixel = 0;
            m_plane_sample_offset = 0;
            m_samples_per_pixel_per_plane = 0;
            m_subsamplingcorrect = false;
            m_subsampling_force_desubsampling_inside_decompression = false;
            m_qtable = new byte[4][];
            m_dctable = new byte[4][];
            m_actable = new byte[4][];
            m_restart_index = 0;
            m_sof_log = false;
            m_sof_marker_id = 0;
            m_sof_x = 0;
            m_sof_y = 0;
            m_sof_c = new byte[3];
            m_sof_hv = new byte[3];
            m_sof_tq = new byte[3];
            m_sos_cs = new byte[3];
            m_sos_tda = new byte[3];
            m_sos_end = new SosEnd[3];
            m_readheader_done = false;
            m_writeheader_done = false;
            m_write_cursample = 0;
            m_write_curstrile = 0;
            m_libjpeg_session_active = false;
            m_libjpeg_jpeg_query_style = 0;
            m_libjpeg_jpeg_error_mgr = null;
            m_libjpeg_jpeg_source_mgr = null;
            m_subsampling_convert_log = false;
            m_subsampling_convert_ylinelen = 0;
            m_subsampling_convert_ylines = 0;
            m_subsampling_convert_clinelen = 0;
            m_subsampling_convert_clines = 0;
            m_subsampling_convert_ybuf = null;
            m_subsampling_convert_cbbuf = null;
            m_subsampling_convert_crbuf = null;
            m_subsampling_convert_ycbcrimage = null;
            m_subsampling_convert_clinelenout = 0;
            m_subsampling_convert_state = 0;
            m_bytes_per_line = 0;
            m_lines_per_strile = 0;
            m_in_buffer_source = OJPEGStateInBufferSource.osibsNotSetYet;
            m_in_buffer_next_strile = 0;
            m_in_buffer_strile_count = 0;
            m_in_buffer_file_pos = 0;
            m_in_buffer_file_pos_log = false;
            m_in_buffer_file_togo = 0;
            m_in_buffer_togo = 0;
            m_in_buffer_cur = 0; // index into m_in_buffer
            m_in_buffer = new byte[OJPEG_BUFFER];
            m_out_state = 0;
            m_out_buffer = new byte[OJPEG_BUFFER];
            m_skip_buffer = null;
            m_forceProcessedRgbOutput = false;
        }