Files
mono/mcs/class/System.Drawing/System.Drawing.Imaging/JPEGCodec.cs
T
Alexandre Pigolkine 6492840010 small fix
svn path=/trunk/mcs/; revision=15467
2003-06-17 22:48:20 +00:00

533 lines
17 KiB
C#

//
// System.Drawing.Imaging.JPEGCodec.cs
//
// Author:
// Alexandre Pigolkine ([email protected])
//
// (C) 2002/2003 Ximian, Inc.
#if DECLARE_CDECL_DELEGATES
namespace cdeclCallback {
using System;
internal class cdeclRedirector {
internal delegate void MethodVoidIntPtr(IntPtr param);
internal delegate int MethodIntIntPtr(IntPtr param);
internal delegate void MethodVoidIntPtrInt(IntPtr param, int param1);
internal delegate int MethodIntIntPtrInt(IntPtr param,int param1);
}
}
#endif
namespace System.Drawing.Imaging
{
using System;
using System.IO;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using cdeclCallback;
/// <summary>
/// Summary description for JPEGCodec.
/// </summary>
internal class JPEGCodec
{
enum J_COLOR_SPACE : int {
JCS_UNKNOWN = 0, /* error/unspecified */
JCS_GRAYSCALE = 1, /* monochrome */
JCS_RGB = 2, /* red/green/blue */
JCS_YCbCr = 3, /* Y/Cb/Cr (also known as YUV) */
JCS_CMYK = 4, /* C/M/Y/K */
JCS_YCCK = 5 /* Y/Cb/Cr/K */
}
[StructLayout(LayoutKind.Sequential)]
internal struct jpeg_error_mgr_get {
public IntPtr a1;
public IntPtr a2;
public IntPtr a3;
public IntPtr a4;
public IntPtr a5;
public int msg_code;
[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=20)]
public int[] array;
public int trace_level;
public int num_warnings;
public int jpeg_message_table;
public int last_jpeg_message;
public int addon_message_table;
public int first_addon_message;
public int last_addon_message;
};
[StructLayout(LayoutKind.Sequential)]
internal struct jpeg_error_mgr {
public cdeclRedirector.MethodVoidIntPtr error_exit;
public IntPtr a2;
public IntPtr a3;
public IntPtr a4;
public IntPtr a5;
public int msg_code;
[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=20)]
public int[] array;
public int trace_level;
public int num_warnings;
public int jpeg_message_table;
public int last_jpeg_message;
public int addon_message_table;
public int first_addon_message;
public int last_addon_message;
};
[StructLayout(LayoutKind.Sequential)]
struct jpeg_source_mgr {
public IntPtr next_input_byte; /* => next byte to read from buffer */
public uint bytes_in_buffer; /* # of bytes remaining in buffer */
//[MarshalAs(UnmanagedType.FunctionPtr)]
public cdeclRedirector.MethodVoidIntPtr init_source;
//[MarshalAs(UnmanagedType.FunctionPtr)]
public cdeclRedirector.MethodIntIntPtr fill_input_buffer;
//[MarshalAs(UnmanagedType.FunctionPtr)]
public cdeclRedirector.MethodVoidIntPtrInt skip_input_data;
//[MarshalAs(UnmanagedType.FunctionPtr)]
public cdeclRedirector.MethodIntIntPtrInt resync_to_restart;
//[MarshalAs(UnmanagedType.FunctionPtr)]
public cdeclRedirector.MethodVoidIntPtr term_source;
};
class jpeg_decompress_struct {
byte[] raw_struct;
IntPtr raw_error_mgr = IntPtr.Zero;
IntPtr raw_source_mgr = IntPtr.Zero;
internal struct decompress_fields {
internal int structure_size;
internal int QUANTIZE_COLORS;
internal int ACTUAL_NUMBER_OF_COLORS;
internal int OUT_COLOR_SPACE;
internal int OUTPUT_WIDTH;
internal int OUTPUT_HEIGHT;
internal int OUT_COLOR_COMPONENT;
internal int OUTPUT_COMPONENTS;
internal int OUTPUT_SCANLINE;
internal int OUT_COLORMAP;
};
const int GNU_JPEG_DLL_WINDOWS = 0;
const int LINUX_LIBJPEG = 1;
const int KNOWN_JPEG_LINRARIES = 2;
static bool offsets_initialized;
static decompress_fields[] know_jpeg_libraries;
static int current_library_index = LINUX_LIBJPEG;
static void initialize_jpeg_decompress_structs() {
if (!offsets_initialized) {
know_jpeg_libraries = new decompress_fields[KNOWN_JPEG_LINRARIES];
// GNU JPEG Windows version
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].structure_size = 432;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].QUANTIZE_COLORS = 74;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].ACTUAL_NUMBER_OF_COLORS = 112;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUT_COLOR_SPACE = 44;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUTPUT_WIDTH = 92;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUTPUT_HEIGHT = 96;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUT_COLOR_COMPONENT = 100;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUTPUT_COMPONENTS = 104;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUTPUT_SCANLINE = 120;
know_jpeg_libraries[GNU_JPEG_DLL_WINDOWS].OUT_COLORMAP = 116;
// libjpeg Linux version
know_jpeg_libraries[LINUX_LIBJPEG].structure_size = 464;
know_jpeg_libraries[LINUX_LIBJPEG].QUANTIZE_COLORS = 84;
know_jpeg_libraries[LINUX_LIBJPEG].ACTUAL_NUMBER_OF_COLORS = 132;
know_jpeg_libraries[LINUX_LIBJPEG].OUT_COLOR_SPACE = 44;
know_jpeg_libraries[LINUX_LIBJPEG].OUTPUT_WIDTH = 112;
know_jpeg_libraries[LINUX_LIBJPEG].OUTPUT_HEIGHT = 116;
know_jpeg_libraries[LINUX_LIBJPEG].OUT_COLOR_COMPONENT = 120;
know_jpeg_libraries[LINUX_LIBJPEG].OUTPUT_COMPONENTS = 124;
know_jpeg_libraries[LINUX_LIBJPEG].OUTPUT_SCANLINE = 140;
know_jpeg_libraries[LINUX_LIBJPEG].OUT_COLORMAP = 136;
offsets_initialized = true;
}
}
static jpeg_decompress_struct() {
initialize_jpeg_decompress_structs();
}
public jpeg_decompress_struct() {
raw_struct = new byte[know_jpeg_libraries[current_library_index].structure_size];
}
public void switch_to_struct_size(int size) {
if (raw_struct.Length == size) return;
bool structureFound = false;
for( int i = 0; i < KNOWN_JPEG_LINRARIES; i++) {
if( know_jpeg_libraries[i].structure_size == size) {
current_library_index = i;
raw_struct = new byte[know_jpeg_libraries[current_library_index].structure_size];
structureFound = true;
break;
}
}
if (!structureFound) throw new Exception("JPEG Codec cannot work with existing libjpeg");
}
public byte[] raw_decompress_struct {
get {
return raw_struct;
}
}
unsafe protected void copyToStruct( int value, int offset) {
fixed( byte* pd = raw_struct) {
*((int*)(pd + offset)) = value;
}
}
unsafe protected int copyFromStruct( int offset) {
int result = 0;
fixed( byte* pd = raw_struct) {
result = *((int*)(pd + offset));
}
return result;
}
public jpeg_error_mgr jpeg_error_mgr {
set {
raw_error_mgr = Marshal.AllocHGlobal(Marshal.SizeOf(value));
Marshal.StructureToPtr(value, raw_error_mgr, false);
copyToStruct(raw_error_mgr.ToInt32(), 0);
}
}
public jpeg_source_mgr jpeg_source_mgr {
set {
raw_source_mgr = Marshal.AllocHGlobal( Marshal.SizeOf(value));
Marshal.StructureToPtr( value, raw_source_mgr, false);
copyToStruct(raw_source_mgr.ToInt32(), 24);
}
}
public int Stride {
get {
return OutputWidth * OutputComponents;
}
}
public Color[] ColorMap {
get {
int actual_number_of_colors = copyFromStruct(know_jpeg_libraries[current_library_index].ACTUAL_NUMBER_OF_COLORS);
IntPtr nativeMap = (IntPtr)copyFromStruct(know_jpeg_libraries[current_library_index].OUT_COLORMAP);
Color[] map = new Color[actual_number_of_colors];
if (nativeMap != IntPtr.Zero) {
byte[] byteMap = new byte[OutColorComponents * actual_number_of_colors];
Marshal.Copy( (IntPtr)Marshal.ReadInt32(nativeMap), byteMap, 0, byteMap.Length);
}
return map;
}
}
public J_COLOR_SPACE OutColorSpace {
get {
return (J_COLOR_SPACE)copyFromStruct(know_jpeg_libraries[current_library_index].OUT_COLOR_SPACE);
}
set {
copyToStruct((int)value,know_jpeg_libraries[current_library_index].OUT_COLOR_SPACE);
}
}
public bool QuantizeColors {
get {
return raw_struct[know_jpeg_libraries[current_library_index].QUANTIZE_COLORS] != (byte)0 ? true : false;
}
set {
raw_struct[know_jpeg_libraries[current_library_index].QUANTIZE_COLORS] = value ? (byte)1 : (byte)0;
}
}
public int OutputWidth {
get {
return copyFromStruct(know_jpeg_libraries[current_library_index].OUTPUT_WIDTH);
}
}
public int OutputHeight {
get {
return copyFromStruct(know_jpeg_libraries[current_library_index].OUTPUT_HEIGHT);
}
}
public int OutColorComponents {
get {
return copyFromStruct(know_jpeg_libraries[current_library_index].OUT_COLOR_COMPONENT);
}
}
public int OutputComponents {
get {
return copyFromStruct(know_jpeg_libraries[current_library_index].OUTPUT_COMPONENTS);
}
}
public int OutputScanLine {
get {
return copyFromStruct(know_jpeg_libraries[current_library_index].OUTPUT_SCANLINE);
}
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct JSAMPARRAY {
// FIXME: This code is not working on Mono(** ERROR **: Invalid IL code at...). Report a bug and change it later.
//const int MAX_SCAN_LINES = 10;
//[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=MAX_SCAN_LINES)]
//internal IntPtr[] JSAMPLES;
internal IntPtr JSAMPLE0;
internal IntPtr JSAMPLE1;
internal JSAMPARRAY(int len) {
/*
JSAMPLES = new IntPtr[MAX_SCAN_LINES];
for (int i = 0; i < MAX_SCAN_LINES; i++) {
JSAMPLES[i] = Marshal.AllocHGlobal(len);
}
*/
JSAMPLE0 = Marshal.AllocHGlobal(len);
JSAMPLE1 = Marshal.AllocHGlobal(len);
}
internal void Dispose() {
/*
for (int i = 0; i < MAX_SCAN_LINES; i++) {
Marshal.FreeHGlobal(JSAMPLES[i]);
}
*/
Marshal.FreeHGlobal(JSAMPLE0);
Marshal.FreeHGlobal(JSAMPLE1);
}
}
const string JPEGLibrary = "jpeg";
[DllImport(JPEGLibrary, EntryPoint="jpeg_CreateDecompress", CallingConvention=CallingConvention.Cdecl)]
internal static extern void jpeg_create_decompress(byte[] info, int version, int structure_size);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern void jpeg_std_error(ref jpeg_error_mgr_get err_mgr);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern int jpeg_read_header(byte[] cinfo, int condition);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern void jpeg_calc_output_dimensions(byte[] cinfo);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern int jpeg_start_decompress(byte[] cinfo);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern int jpeg_read_scanlines(byte[] cinfo, ref JSAMPARRAY buffer, int num);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern int jpeg_finish_decompress(byte[] cinfo);
[DllImport(JPEGLibrary, CallingConvention=CallingConvention.Cdecl)]
internal static extern void jpeg_destroy_decompress(byte[] cinfo);
Stream fs;
IntPtr buffer;
int readSize = 4096;
void init_source( IntPtr cinfo) {
buffer = Marshal.AllocHGlobal(readSize);
}
int fill_input_buffer( IntPtr cinfo) {
byte[] result = new byte[readSize];
int readed = fs.Read(result, 0, readSize);
Marshal.Copy(result, 0, buffer, readed);
IntPtr srcAddr = (IntPtr)Marshal.ReadInt32(cinfo, 24);
Marshal.WriteInt32(srcAddr, 0, buffer.ToInt32());
Marshal.WriteInt32(srcAddr, 4, readed);
return 1;
}
void skip_input_data( IntPtr cinfo, int num_bytes) {
//byte[] result = new byte[num_bytes];
//fs.Read(result, 0, num_bytes);
fs.Seek(num_bytes, SeekOrigin.Current);
}
int resync_to_restart( IntPtr cinfo, int desired){
return 0;
}
void term_source( IntPtr cinfo) {
Marshal.AllocHGlobal(buffer);
fs.Close();
}
class RetryInitializationException : Exception {
int libraryStructureSize;
public RetryInitializationException(int structureSize) {
this.libraryStructureSize = structureSize;
}
public int LibraryStructureSize {
get {
return libraryStructureSize;
}
}
}
enum JPEGErrorCodes : int {
JERR_BAD_STRUCT_SIZE = 21
}
void error_exit( IntPtr cinfo) {
jpeg_error_mgr mgr = new jpeg_error_mgr();
IntPtr err_raw = (IntPtr)Marshal.ReadInt32(cinfo, 0);
mgr = (jpeg_error_mgr)Marshal.PtrToStructure(err_raw, mgr.GetType());
if ( mgr.msg_code == (int)JPEGErrorCodes.JERR_BAD_STRUCT_SIZE) {
throw new RetryInitializationException(mgr.array[0]);
}
throw new Exception();
}
internal JPEGCodec() {
}
internal static ImageCodecInfo CodecInfo {
get {
ImageCodecInfo info = new ImageCodecInfo();
info.Flags = /*ImageCodecFlags.Encoder | */ ImageCodecFlags.Decoder | ImageCodecFlags.Builtin | ImageCodecFlags.SupportBitmap;
info.FormatDescription = "JPEG file format";
info.FormatID = System.Drawing.Imaging.ImageFormat.Jpeg.Guid;
info.MimeType = "image/jpeg";
info.Version = 1;
byte[][] signaturePatterns = new byte[1][];
signaturePatterns[0] = new byte[]{0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00};
info.SignaturePatterns = signaturePatterns;
byte[][] signatureMasks = new byte[1][];
signatureMasks[0] = new byte[]{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
info.SignatureMasks = signatureMasks;
info.decode += new ImageCodecInfo.DecodeFromStream(JPEGCodec.DecodeDelegate);
info.encode += new ImageCodecInfo.EncodeToStream(JPEGCodec.EncodeDelegate);
return info;
}
}
internal static void DecodeDelegate (Stream stream, InternalImageInfo info) {
JPEGCodec jpeg = new JPEGCodec();
jpeg.Decode (stream, info);
}
internal static void EncodeDelegate (Stream stream, InternalImageInfo info) {
JPEGCodec jpeg = new JPEGCodec();
jpeg.Encode (stream, info);
}
internal unsafe void switch_color_bytes( byte[] image) {
fixed(byte* start = image) {
byte *pb = start;
byte t1;
for( int ic = 0; ic < image.Length; ic +=3) {
t1 = *pb;
*(pb) = *(pb+2);
*(pb+2) = t1;
pb += 3;
}
}
}
internal bool Decode( Stream stream, InternalImageInfo info) {
fs = stream;
jpeg_error_mgr_get mgr = new jpeg_error_mgr_get();
mgr.array = new int[20];
jpeg_std_error( ref mgr);
jpeg_error_mgr mgr_real = new jpeg_error_mgr();
mgr_real.array = new int[20];
mgr_real.error_exit = new cdeclCallback.cdeclRedirector.MethodVoidIntPtr(this.error_exit);
mgr_real.msg_code = mgr.msg_code;
mgr_real.a2 = mgr.a2;
mgr_real.a3 = mgr.a3;
mgr_real.a4 = mgr.a4;
mgr_real.a5 = mgr.a5;
mgr_real.trace_level = mgr.trace_level;
mgr_real.num_warnings = mgr.num_warnings;
mgr_real.last_jpeg_message = mgr.last_jpeg_message;
mgr_real.first_addon_message = mgr.first_addon_message;
mgr_real.last_addon_message = mgr.last_addon_message;
mgr_real.jpeg_message_table = mgr.jpeg_message_table;
jpeg_decompress_struct cinfo = new jpeg_decompress_struct();
cinfo.jpeg_error_mgr = mgr_real;
bool initializedOk = false;
do {
try {
jpeg_create_decompress(cinfo.raw_decompress_struct, 62, cinfo.raw_decompress_struct.Length);
initializedOk = true;
}
catch( RetryInitializationException ex) {
initializedOk = false;
cinfo.switch_to_struct_size(ex.LibraryStructureSize);
cinfo.jpeg_error_mgr = mgr_real;
}
}while( !initializedOk);
jpeg_source_mgr smgr = new jpeg_source_mgr();
smgr.next_input_byte = IntPtr.Zero;
smgr.bytes_in_buffer = 0;
smgr.init_source = new cdeclRedirector.MethodVoidIntPtr(this.init_source);
smgr.fill_input_buffer = new cdeclRedirector.MethodIntIntPtr(this.fill_input_buffer);
smgr.skip_input_data = new cdeclRedirector.MethodVoidIntPtrInt(this.skip_input_data);
smgr.resync_to_restart = new cdeclRedirector.MethodIntIntPtrInt(this.resync_to_restart);
smgr.term_source = new cdeclRedirector.MethodVoidIntPtr(this.term_source);
cinfo.jpeg_source_mgr = smgr;
jpeg_read_header( cinfo.raw_decompress_struct, 1);
jpeg_calc_output_dimensions(cinfo.raw_decompress_struct);
jpeg_start_decompress(cinfo.raw_decompress_struct);
int row_width = cinfo.Stride;
while ((row_width & 3) != 0) row_width++;
int pad_bytes = (row_width - cinfo.Stride);
if (cinfo.OutColorSpace == J_COLOR_SPACE.JCS_RGB) {
if (cinfo.QuantizeColors) {
info.Format = PixelFormat.Format8bppIndexed;
}
else {
info.Format = PixelFormat.Format24bppRgb;
}
}
else {
info.Format = PixelFormat.Format8bppIndexed;
}
info.Size = new Size(cinfo.OutputWidth,cinfo.OutputHeight);
info.Stride = cinfo.Stride + pad_bytes;
info.Palette = new ColorPalette(1, cinfo.ColorMap);
info.RawImageBytes = new byte[(cinfo.OutputHeight) * (cinfo.Stride + pad_bytes)];
JSAMPARRAY outbuf = new JSAMPARRAY(cinfo.Stride);
int outputRow = 0;
int outputIndex = info.RawImageBytes.Length - cinfo.Stride - pad_bytes;
while (cinfo.OutputScanLine < cinfo.OutputHeight) {
// FIXME: switch to the Length after fixing a run-time error
int readed = jpeg_read_scanlines(cinfo.raw_decompress_struct, ref outbuf, 1 /*outbuf.JSAMPLES.Length*/);
for (int i = 0; i < readed; i++) {
// FIXME: switch to .JSAMPLES[i] after fixing a run-time error
//Marshal.Copy(outbuf.JSAMPLES[i], info.RawImageBytes, outputIndex, cinfo.Stride);
Marshal.Copy(outbuf.JSAMPLE0, info.RawImageBytes, outputIndex, cinfo.Stride);
outputIndex -= cinfo.Stride + pad_bytes;
outputRow++;
}
}
// FIXME: analise count of color components here
switch_color_bytes(info.RawImageBytes);
jpeg_finish_decompress(cinfo.raw_decompress_struct);
jpeg_destroy_decompress(cinfo.raw_decompress_struct);
return true;
}
internal bool Encode( Stream stream, InternalImageInfo info) {
return false;
}
}
}