public DecodedJpeg Decode() { // The frames in this jpeg are loaded into a list. There is // usually just one frame except in heirarchial progression where // there are multiple frames. JPEGFrame frame = null; // The restart interval defines how many MCU's we should have // between the 8-modulo restart marker. The restart markers allow // us to tell whether or not our decoding process is working // correctly, also if there is corruption in the image we can // recover with these restart intervals. (See RSTm DRI). int resetInterval = 0; bool haveMarker = false; bool foundJFIF = false; List <JpegHeader> headers = new List <JpegHeader>(); // Loop through until there are no more markers to read in, at // that point everything is loaded into the jpegFrames array and // can be processed. while (true) { #region Switch over marker types switch (marker) { case JPEGMarker.APP0: // APP1 is used for EXIF data case JPEGMarker.APP1: // Seldomly, APP2 gets used for extended EXIF, too case JPEGMarker.APP2: case JPEGMarker.APP3: case JPEGMarker.APP4: case JPEGMarker.APP5: case JPEGMarker.APP6: case JPEGMarker.APP7: case JPEGMarker.APP8: case JPEGMarker.APP9: case JPEGMarker.APP10: case JPEGMarker.APP11: case JPEGMarker.APP12: case JPEGMarker.APP13: case JPEGMarker.APP14: case JPEGMarker.APP15: // COM: Comment case JPEGMarker.COM: // Debug.WriteLine(string.Format("Extracting Header, Type={0:X}", marker)); JpegHeader header = ExtractHeader(); #region Check explicitly for Exif Data if (header.Marker == JPEGMarker.APP1 && header.Data.Length >= 6) { byte[] d = header.Data; if (d[0] == 'E' && d[1] == 'x' && d[2] == 'i' && d[3] == 'f' && d[4] == 0 && d[5] == 0) { // Exif. Do something? } } #endregion #region Check for Adobe header if (header.Data.Length >= 5 && header.Marker == JPEGMarker.APP14) { string asText = UTF8Encoding.UTF8.GetString(header.Data, 0, 5); if (asText == "Adobe") { // ADOBE HEADER. Do anything? } } #endregion headers.Add(header); if (!foundJFIF && marker == JPEGMarker.APP0) { foundJFIF = TryParseJFIF(header.Data); if (foundJFIF) // Found JFIF... do JFIF extension follow? { header.IsJFIF = true; marker = jpegReader.GetNextMarker(); // Yes, they do. if (marker == JPEGMarker.APP0) { header = ExtractHeader(); headers.Add(header); } else // No. Delay processing this one. { haveMarker = true; } } } break; case JPEGMarker.SOF0: case JPEGMarker.SOF2: // SOFn Start of Frame Marker, Baseline DCT - This is the start // of the frame header that defines certain variables that will // be carried out through the rest of the encoding. Multiple // frames are used in a hierarchical system, however most JPEG's // only contain a single frame. // Progressive or baseline? progressive = marker == JPEGMarker.SOF2; jpegFrames.Add(new JPEGFrame()); frame = (JPEGFrame)jpegFrames[jpegFrames.Count - 1]; frame.ProgressUpdateMethod = new Action <long>(UpdateStreamProgress); // Skip the frame length. jpegReader.ReadShort(); // Bits percision, either 8 or 12. frame.setPrecision(jpegReader.ReadByte()); // Scan lines (height) frame.ScanLines = jpegReader.ReadShort(); // Scan samples per line (width) frame.SamplesPerLine = jpegReader.ReadShort(); // Number of Color Components (channels). frame.ComponentCount = jpegReader.ReadByte(); DecodeProgress.Height = frame.Height; DecodeProgress.Width = frame.Width; DecodeProgress.SizeReady = true; if (DecodeProgressChanged != null) { DecodeProgressChanged(this, DecodeProgress); } // Add all of the necessary components to the frame. for (int i = 0; i < frame.ComponentCount; i++) { byte compId = jpegReader.ReadByte(); byte sampleFactors = jpegReader.ReadByte(); byte qTableId = jpegReader.ReadByte(); byte sampleHFactor = (byte)(sampleFactors >> 4); byte sampleVFactor = (byte)(sampleFactors & 0x0f); frame.AddComponent(compId, sampleHFactor, sampleVFactor, qTableId); } break; case JPEGMarker.DHT: // DHT non-SOF Marker - Huffman Table is required for decoding // the JPEG stream, when we receive a marker we load in first // the table length (16 bits), the table class (4 bits), table // identifier (4 bits), then we load in 16 bytes and each byte // represents the count of bytes to load in for each of the 16 // bytes. We load this into an array to use later and move on 4 // huffman tables can only be used in an image. int huffmanLength = (jpegReader.ReadShort() - 2); // Keep looping until we are out of length. int index = huffmanLength; // Multiple tables may be defined within a DHT marker. This // will keep reading until there are no tables left, most // of the time there are just one tables. while (index > 0) { // Read the identifier information and class // information about the Huffman table, then read the // 16 byte codelength in and read in the Huffman values // and put it into table info. byte huffmanInfo = jpegReader.ReadByte(); byte tableClass = (byte)(huffmanInfo >> 4); byte huffmanIndex = (byte)(huffmanInfo & 0x0f); short[] codeLength = new short[16]; for (int i = 0; i < codeLength.Length; i++) { codeLength[i] = jpegReader.ReadByte(); } int huffmanValueLen = 0; for (int i = 0; i < 16; i++) { huffmanValueLen += codeLength[i]; } index -= (huffmanValueLen + 17); short[] huffmanVal = new short[huffmanValueLen]; for (int i = 0; i < huffmanVal.Length; i++) { huffmanVal[i] = jpegReader.ReadByte(); } // Assign DC Huffman Table. if (tableClass == HuffmanTable.JPEG_DC_TABLE) { dcTables[(int)huffmanIndex] = new JpegHuffmanTable(codeLength, huffmanVal); } // Assign AC Huffman Table. else if (tableClass == HuffmanTable.JPEG_AC_TABLE) { acTables[(int)huffmanIndex] = new JpegHuffmanTable(codeLength, huffmanVal); } } break; case JPEGMarker.DQT: // DQT non-SOF Marker - This defines the quantization // coeffecients, this allows us to figure out the quality of // compression and unencode the data. The data is loaded and // then stored in to an array. short quantizationLength = (short)(jpegReader.ReadShort() - 2); for (int j = 0; j < quantizationLength / 65; j++) { byte quantSpecs = jpegReader.ReadByte(); int[] quantData = new int[64]; if ((byte)(quantSpecs >> 4) == 0) // Precision 8 bit. { for (int i = 0; i < 64; i++) { quantData[i] = jpegReader.ReadByte(); } } else if ((byte)(quantSpecs >> 4) == 1) // Precision 16 bit. { for (int i = 0; i < 64; i++) { quantData[i] = jpegReader.ReadShort(); } } qTables[(int)(quantSpecs & 0x0f)] = new JpegQuantizationTable(quantData); } break; case JPEGMarker.SOS: Debug.WriteLine("Start of Scan (SOS)"); // SOS non-SOF Marker - Start Of Scan Marker, this is where the // actual data is stored in a interlaced or non-interlaced with // from 1-4 components of color data, if three components most // likely a YCrCb model, this is a fairly complex process. // Read in the scan length. //ushort scanLen = jpegReader.ReadShort(); // Number of components in the scan. byte numberOfComponents = jpegReader.ReadByte(); byte[] componentSelector = new byte[numberOfComponents]; for (int i = 0; i < numberOfComponents; i++) { // Component ID, packed byte containing the Id for the // AC table and DC table. byte componentID = jpegReader.ReadByte(); byte tableInfo = jpegReader.ReadByte(); int DC = (tableInfo >> 4) & 0x0f; int AC = (tableInfo) & 0x0f; frame.setHuffmanTables(componentID, acTables[(byte)AC], dcTables[(byte)DC]); componentSelector[i] = componentID; } byte startSpectralSelection = jpegReader.ReadByte(); byte endSpectralSelection = jpegReader.ReadByte(); byte successiveApproximation = jpegReader.ReadByte(); #region Baseline JPEG Scan Decoding if (!progressive) { frame.DecodeScanBaseline(numberOfComponents, componentSelector, resetInterval, jpegReader, ref marker); haveMarker = true; // use resultant marker for the next switch(..) } #endregion #region Progressive JPEG Scan Decoding if (progressive) { frame.DecodeScanProgressive( successiveApproximation, startSpectralSelection, endSpectralSelection, numberOfComponents, componentSelector, resetInterval, jpegReader, ref marker); haveMarker = true; // use resultant marker for the next switch(..) } #endregion break; case JPEGMarker.DRI: jpegReader.BaseStream.Seek(2, System.IO.SeekOrigin.Current); resetInterval = jpegReader.ReadShort(); break; // Defines the number of lines. (Not usually present) case JPEGMarker.DNL: frame.ScanLines = jpegReader.ReadShort(); break; // End of Image. Finish the decode. case JPEGMarker.EOI: if (jpegFrames.Count == 0) { throw new NotSupportedException("No JPEG frames could be located."); } else if (jpegFrames.Count == 1) { // Only one frame, JPEG Non-Heirarchial Frame. byte[][,] raster = Image.CreateRaster(frame.Width, frame.Height, frame.ComponentCount); IList <JpegComponent> components = frame.Scan.Components; int totalSteps = components.Count * 3; // Three steps per loop int stepsFinished = 0; for (int i = 0; i < components.Count; i++) { JpegComponent comp = components[i]; comp.QuantizationTable = qTables[comp.quant_id].Table; // 1. Quantize comp.quantizeData(); UpdateProgress(++stepsFinished, totalSteps); // 2. Run iDCT (expensive) comp.idctData(); UpdateProgress(++stepsFinished, totalSteps); // 3. Scale the image and write the data to the raster. comp.writeDataScaled(raster, i, BlockUpsamplingMode); UpdateProgress(++stepsFinished, totalSteps); // Ensure garbage collection. comp = null; GC.Collect(); } // Grayscale Color Image (1 Component). if (frame.ComponentCount == 1) { ColorModel cm = new ColorModel() { ColorSpace = ColorSpace.Gray, Opaque = true }; image = new Image(cm, raster); } // YCbCr Color Image (3 Components). else if (frame.ComponentCount == 3) { ColorModel cm = new ColorModel() { ColorSpace = ColorSpace.YCbCr, Opaque = true }; image = new Image(cm, raster); } // Possibly CMYK or RGBA ? else { throw new NotSupportedException("Unsupported Color Mode: 4 Component Color Mode found."); } // If needed, convert centimeters to inches. Func <double, double> conv = x => Units == UnitType.Inches ? x : x / 2.54; image.DensityX = conv(XDensity); image.DensityY = conv(YDensity); //height = frame.Height; //width = frame.Width; } else { // JPEG Heirarchial Frame throw new NotSupportedException("Unsupported Codec Type: Hierarchial JPEG"); } break; // Only SOF0 (baseline) and SOF2 (progressive) are supported by FJCore case JPEGMarker.SOF1: case JPEGMarker.SOF3: case JPEGMarker.SOF5: case JPEGMarker.SOF6: case JPEGMarker.SOF7: case JPEGMarker.SOF9: case JPEGMarker.SOF10: case JPEGMarker.SOF11: case JPEGMarker.SOF13: case JPEGMarker.SOF14: case JPEGMarker.SOF15: throw new NotSupportedException("Unsupported codec type."); default: break; // ignore } #endregion switch over markers if (haveMarker) { haveMarker = false; } else { try { marker = jpegReader.GetNextMarker(); } catch (System.IO.EndOfStreamException) { break; /* done reading the file */ } } } DecodedJpeg result = new DecodedJpeg(image, headers); return(result); }
public DecodedJpeg Decode() { JPEGFrame jPEGFrame = null; int resetInterval = 0; bool flag = false; bool flag2 = false; List <JpegHeader> list = new List <JpegHeader>(); while (true) { if (DecodeProgress.Abort) { return(null); } switch (marker) { case 224: case 225: case 226: case 227: case 228: case 229: case 230: case 231: case 232: case 233: case 234: case 235: case 236: case 237: case 238: case 239: case 254: { JpegHeader jpegHeader = ExtractHeader(); if (jpegHeader.Marker == 225 && jpegHeader.Data.Length >= 6) { byte[] data = jpegHeader.Data; if (data[0] == 69 && data[1] == 120 && data[2] == 105 && data[3] == 102 && data[4] == 0) { _ = data[5]; } } if (jpegHeader.Data.Length >= 5 && jpegHeader.Marker == 238) { _ = (Encoding.UTF8.GetString(jpegHeader.Data, 0, 5) == "Adobe"); } list.Add(jpegHeader); if (flag2 || marker != 224) { break; } flag2 = TryParseJFIF(jpegHeader.Data); if (flag2) { jpegHeader.IsJFIF = true; marker = jpegReader.GetNextMarker(); if (marker == 224) { jpegHeader = ExtractHeader(); list.Add(jpegHeader); } else { flag = true; } } break; } case 192: case 194: { progressive = (marker == 194); jpegFrames.Add(new JPEGFrame()); jPEGFrame = jpegFrames[jpegFrames.Count - 1]; jPEGFrame.ProgressUpdateMethod = UpdateStreamProgress; jpegReader.ReadShort(); jPEGFrame.setPrecision(jpegReader.ReadByte()); jPEGFrame.ScanLines = jpegReader.ReadShort(); jPEGFrame.SamplesPerLine = jpegReader.ReadShort(); jPEGFrame.ComponentCount = jpegReader.ReadByte(); DecodeProgress.Height = jPEGFrame.Height; DecodeProgress.Width = jPEGFrame.Width; DecodeProgress.SizeReady = true; if (this.DecodeProgressChanged != null) { this.DecodeProgressChanged(this, DecodeProgress); if (DecodeProgress.Abort) { return(null); } } for (int m = 0; m < jPEGFrame.ComponentCount; m++) { byte componentID = jpegReader.ReadByte(); byte num5 = jpegReader.ReadByte(); byte quantizationTableID = jpegReader.ReadByte(); byte sampleHFactor = (byte)(num5 >> 4); byte sampleVFactor = (byte)(num5 & 0xF); jPEGFrame.AddComponent(componentID, sampleHFactor, sampleVFactor, quantizationTableID); } break; } case 196: { int num2 = jpegReader.ReadShort() - 2; while (num2 > 0) { byte num3 = jpegReader.ReadByte(); byte b = (byte)(num3 >> 4); byte b2 = (byte)(num3 & 0xF); short[] array = new short[16]; for (int j = 0; j < array.Length; j++) { array[j] = jpegReader.ReadByte(); } int num4 = 0; for (int k = 0; k < 16; k++) { num4 += array[k]; } num2 -= num4 + 17; short[] array2 = new short[num4]; for (int l = 0; l < array2.Length; l++) { array2[l] = jpegReader.ReadByte(); } if (b == HuffmanTable.JPEG_DC_TABLE) { dcTables[b2] = new JpegHuffmanTable(array, array2); } else if (b == HuffmanTable.JPEG_AC_TABLE) { acTables[b2] = new JpegHuffmanTable(array, array2); } } break; } case 219: { short num9 = (short)(jpegReader.ReadShort() - 2); for (int num10 = 0; num10 < num9 / 65; num10++) { byte b5 = jpegReader.ReadByte(); int[] array4 = new int[64]; if ((byte)(b5 >> 4) == 0) { for (int num11 = 0; num11 < 64; num11++) { array4[num11] = jpegReader.ReadByte(); } } else if ((byte)(b5 >> 4) == 1) { for (int num12 = 0; num12 < 64; num12++) { array4[num12] = jpegReader.ReadShort(); } } qTables[b5 & 0xF] = new JpegQuantizationTable(array4); } break; } case 218: { jpegReader.ReadShort(); byte b3 = jpegReader.ReadByte(); byte[] array3 = new byte[b3]; for (int n = 0; n < b3; n++) { byte b4 = jpegReader.ReadByte(); byte num6 = jpegReader.ReadByte(); int num7 = (num6 >> 4) & 0xF; int num8 = num6 & 0xF; jPEGFrame.setHuffmanTables(b4, acTables[(byte)num8], dcTables[(byte)num7]); array3[n] = b4; } byte startSpectralSelection = jpegReader.ReadByte(); byte endSpectralSelection = jpegReader.ReadByte(); byte successiveApproximation = jpegReader.ReadByte(); if (!progressive) { jPEGFrame.DecodeScanBaseline(b3, array3, resetInterval, jpegReader, ref marker); flag = true; } if (progressive) { jPEGFrame.DecodeScanProgressive(successiveApproximation, startSpectralSelection, endSpectralSelection, b3, array3, resetInterval, jpegReader, ref marker); flag = true; } break; } case 221: jpegReader.BaseStream.Seek(2L, SeekOrigin.Current); resetInterval = jpegReader.ReadShort(); break; case 220: jPEGFrame.ScanLines = jpegReader.ReadShort(); break; case 217: { if (jpegFrames.Count == 0) { throw new NotSupportedException("No JPEG frames could be located."); } if (jpegFrames.Count > 1) { jPEGFrame = jpegFrames.OrderByDescending((JPEGFrame f) => f.Width * f.Height).FirstOrDefault(); } byte[][,] raster = Image.CreateRaster(jPEGFrame.Width, jPEGFrame.Height, jPEGFrame.ComponentCount); IList <JpegComponent> components = jPEGFrame.Scan.Components; int stepsTotal = components.Count * 3; int num = 0; for (int i = 0; i < components.Count; i++) { JpegComponent jpegComponent = components[i]; jpegComponent.QuantizationTable = qTables[jpegComponent.quant_id].Table; jpegComponent.quantizeData(); UpdateProgress(++num, stepsTotal); jpegComponent.idctData(); UpdateProgress(++num, stepsTotal); jpegComponent.writeDataScaled(raster, i, BlockUpsamplingMode); UpdateProgress(++num, stepsTotal); jpegComponent = null; GC.Collect(); } ColorModel colorModel; if (jPEGFrame.ComponentCount == 1) { colorModel = default(ColorModel); colorModel.colorspace = ColorSpace.Gray; colorModel.Opaque = true; ColorModel cm = colorModel; image = new Image(cm, raster); } else { if (jPEGFrame.ComponentCount != 3) { throw new NotSupportedException("Unsupported Color Mode: 4 Component Color Mode found."); } colorModel = default(ColorModel); colorModel.colorspace = ColorSpace.YCbCr; colorModel.Opaque = true; ColorModel cm2 = colorModel; image = new Image(cm2, raster); } Func <double, double> func = (double x) => (Units != UnitType.Inches) ? (x / 2.54) : x; image.DensityX = func((int)XDensity); image.DensityY = func((int)YDensity); break; } case 193: case 195: case 197: case 198: case 199: case 201: case 202: case 203: case 205: case 206: case 207: throw new NotSupportedException("Unsupported codec type."); } if (flag) { flag = false; } else { try { marker = jpegReader.GetNextMarker(); } catch (EndOfStreamException) { break; } } } return(new DecodedJpeg(image, list)); }