AddComponent() public method

public AddComponent ( byte componentID, byte sampleHFactor, byte sampleVFactor, byte quantizationTableID ) : void
componentID byte
sampleHFactor byte
sampleVFactor byte
quantizationTableID byte
return void
示例#1
0
        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);
        }
示例#2
0
        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));
        }