// Progressive jpeg: need to keep all of the data units.		dataUnits = new int[nComponents][][];	} else {		// Sequential jpeg: only need one data unit.		dataUnit = new int[8 * 8];	}	for (int i = 0; i < nComponents; i++) {		int[] frameComponent = frameComponents[componentIds[i]];		int bufferSize = frameComponent[CW] * frameComponent[CH];		imageComponents[i] = new byte[bufferSize];		if (progressive) {			dataUnits[i] = new int[bufferSize][];		}	}	/* Process the tables preceding the scan header. */	processTables();		/* Start of Scan. */	scanHeader = new JPEGScanHeader(inputStream);	if (!scanHeader.verify()) SWT.error(SWT.ERROR_INVALID_IMAGE);		/* Process scan(s) and further tables until EOI. */	int progressiveScanCount = 0;	boolean done = false;	while(!done) {		resetInputBuffer();		precedingDCs = new int[4];		decodeScan();		if (progressive && loader.hasListeners()) {			ImageData imageData = createImageData();			loader.notifyListeners(new ImageLoaderEvent(loader, imageData, progressiveScanCount, false));			progressiveScanCount++;		}		/* Unread any buffered data before looking for tables again. */		int delta = 512 - bufferCurrentPosition - 1;		if (delta > 0) {			byte[] unreadBuffer = new byte[delta];			System.arraycopy(dataBuffer, bufferCurrentPosition + 1, unreadBuffer, 0, delta);			try {				inputStream.unread(unreadBuffer);			} catch (IOException e) {				SWT.error(SWT.ERROR_IO, e);			}		}				/* Process the tables preceding the next scan header. */		JPEGSegment jpegSegment = processTables();		if (jpegSegment == null || jpegSegment.getSegmentMarker() == EOI) {			done = true;		} else {			scanHeader = new JPEGScanHeader(inputStream);			if (!scanHeader.verify()) SWT.error(SWT.ERROR_INVALID_IMAGE);		}	}		if (progressive) {		for (int ymcu = 0; ymcu < interleavedMcuRows; ymcu++) {			for (int xmcu = 0; xmcu < interleavedMcuCols; xmcu++) {				for (int iComp = 0; iComp < nComponents; iComp++) {					int[] frameComponent = frameComponents[componentIds[iComp]];					int hi = frameComponent[HI];					int vi = frameComponent[VI];					int compWidth = frameComponent[CW];					for (int ivi = 0; ivi < vi; ivi++) {						for (int ihi = 0; ihi < hi; ihi++) {							int index = (ymcu * vi + ivi) * compWidth + xmcu * hi + ihi;							dataUnit = dataUnits[iComp][index];							dequantize(dataUnit, iComp);							inverseDCT(dataUnit);							storeData(dataUnit, iComp, xmcu, ymcu, hi, ihi, vi, ivi);						}					}				}			}		}	}	ImageData imageData = createImageData();	if (progressive && loader.hasListeners()) {		loader.notifyListeners(new ImageLoaderEvent(loader, imageData, progressiveScanCount, true));	}	return new ImageData[] {imageData};}ImageData createImageData() {	return ImageData.internal_new(		imageWidth,		imageHeight, 		nComponents * samplePrecision,		setUpPalette(),		nComponents == 1 ? 4 : 1,		decodeImageComponents(),		0,		null,		null,		-1,		-1,		SWT.IMAGE_JPEG,		0,		0,		0,		0);}int nextBit() {	if (currentBitCount != 0) {		currentBitCount--;		currentByte *= 2;		if (currentByte > 255) {			currentByte -= 256;			return 1;		} else {			return 0;		}	}	bufferCurrentPosition++;	if (bufferCurrentPosition >= 512) {		resetInputBuffer();		bufferCurrentPosition = 0;	}	currentByte = dataBuffer[bufferCurrentPosition] & 0xFF;	currentBitCount = 8;	byte nextByte;	if (bufferCurrentPosition == 511) {		resetInputBuffer();		currentBitCount = 8;		nextByte = dataBuffer[0];	} else {		nextByte = dataBuffer[bufferCurrentPosition + 1];	}	if (currentByte == 0xFF) {		if (nextByte == 0) {			bufferCurrentPosition ++;			currentBitCount--;			currentByte *= 2;			if (currentByte > 255) {				currentByte -= 256;				return 1;			} else {				return 0;			}		} else {			if ((nextByte & 0xFF) + 0xFF00 == DNL) {				getDNL();				return 0;			} else {				SWT.error(SWT.ERROR_INVALID_IMAGE);				return 0;			}		}	} else {		currentBitCount--;		currentByte *= 2;		if (currentByte > 255) {			currentByte -= 256;			return 1;		} else {			return 0;		}	}}void processRestartInterval() {	do {		bufferCurrentPosition++;		if (bufferCurrentPosition > 511) {			resetInputBuffer();			bufferCurrentPosition = 0;		}		currentByte = dataBuffer[bufferCurrentPosition] & 0xFF;	} while (currentByte != 0xFF);	while (currentByte == 0xFF) {		bufferCurrentPosition++;		if (bufferCurrentPosition > 511) {			resetInputBuffer();			bufferCurrentPosition = 0;		}		currentByte = dataBuffer[bufferCurrentPosition] & 0xFF;	}	if (currentByte != ((RST0 + nextRestartNumber) % 256)) {		SWT.error(SWT.ERROR_INVALID_IMAGE);	}	bufferCurrentPosition++;	if (bufferCurrentPosition > 511) {		resetInputBuffer();		bufferCurrentPosition = 0;	}	currentByte = dataBuffer[bufferCurrentPosition] & 0xFF;	currentBitCount = 8;	restartsToGo = restartInterval;	nextRestartNumber = (nextRestartNumber + 1) % 8;	precedingDCs = new int[4];	eobrun = 0;}/* Process all markers until a frame header, scan header, or EOI is found. */JPEGSegment processTables() {	while (true) {		JPEGSegment jpegSegment = seekUnspecifiedMarker(inputStream);		if (jpegSegment == null) return null;		JPEGFrameHeader sof = new JPEGFrameHeader(jpegSegment.reference);		if (sof.verify()) {			return jpegSegment;		}		int marker = jpegSegment.getSegmentMarker();		switch (marker) {			case SOI: // there should only be one SOI per file				SWT.error(SWT.ERROR_INVALID_IMAGE);			case EOI:			case SOS:				return jpegSegment;			case DQT:				getDQT();				break;			case DHT:				getDHT();				break;			case DAC:				getDAC();				break;			case DRI:				getDRI();				break;			case APP0:				getAPP0();				break;			case COM:				getCOM();				break;			default:				skipSegmentFrom(inputStream);					}	}}void quantizeData(int[] dataUnit, int iComp) {	int[] qTable = quantizationTables[frameComponents[componentIds[iComp]][TQI]];	for (int i = 0; i < dataUnit.length; i++) {		int zzIndex = ZigZag8x8[i];		int data = dataUnit[zzIndex];		int absData = data < 0 ? 0 - data : data;		int qValue = qTable[i];		int q2 = qValue / 2;		absData += q2;		if (absData < qValue) {			dataUnit[zzIndex] = 0;		} else {			absData /= qValue;			if (data >= 0) {				dataUnit[zzIndex] = absData;			} else {				dataUnit[zzIndex] = 0 - absData;			}		}	}}int receive(int nBits) {	int v = 0;	for (int i = 0; i < nBits; i++) {		v = v * 2 + nextBit();	}	return v;}void resetInputBuffer() {	if (dataBuffer == null) {		dataBuffer = new byte[512];	}	try {		inputStream.read(dataBuffer);	} catch (IOException e) {		SWT.error(SWT.ERROR_IO, e);	}	currentBitCount = 0;	bufferCurrentPosition = -1;}void resetOutputBuffer() {	if (dataBuffer == null) {		dataBuffer = new byte[512];	} else {		try {			outputStream.write(dataBuffer, 0, bufferCurrentPosition);		} catch (IOException e) {			SWT.error(SWT.ERROR_IO, e);		}	}	bufferCurrentPosition = 0;}static JPEGSegment seekUnspecifiedMarker(LEDataInputStream byteStream) {	byte[] byteArray = new byte[2];	try {		while (true) {			if (byteStream.read(byteArray, 0, 1) != 1) return null;			if (byteArray[0] == (byte) 0xFF) {				if (byteStream.read(byteArray, 1, 1) != 1) return null;				if (byteArray[1] != (byte) 0xFF && byteArray[1] != 0) {					byteStream.unread(byteArray);					return new JPEGSegment(byteArray);				}			}		}	} catch (IOException e) {		SWT.error(SWT.ERROR_IO, e);	}	return null;}PaletteData setUpPalette() {	if (nComponents == 1) {		RGB[] entries = new RGB[256];		for (int i = 0; i < 256; i++) {			entries[i] = new RGB(i, i, i);		}		return new PaletteData(entries);	}	return new PaletteData(0xFF, 0xFF00, 0xFF0000);}static void skipSegmentFrom(LEDataInputStream byteStream) {	try {		byte[] byteArray = new byte[4];		JPEGSegment jpegSegment = new JPEGSegment(byteArray);			if (byteStream.read(byteArray) != byteArray.length) {			SWT.error(SWT.ERROR_INVALID_IMAGE);		}		if (!(byteArray[0] == -1 && byteArray[1] != 0 && byteArray[1] != -1)) {			SWT.error(SWT.ERROR_INVALID_IMAGE);		}		int delta = jpegSegment.getSegmentLength() - 2;		byteStream.skip(delta);	} catch (Exception e) {		SWT.error(SWT.ERROR_IO, e);	}}void storeData(int[] dataUnit, int iComp, int xmcu, int ymcu, int hi, int ihi, int vi, int ivi) {	byte[] compImage = imageComponents[iComp];	int[] frameComponent = frameComponents[componentIds[iComp]];	int compWidth = frameComponent[CW];	int destIndex = ((ymcu * vi + ivi) * compWidth * DCTSIZE) + ((xmcu * hi + ihi) * DCTSIZE);	int srcIndex = 0;	for (int i = 0; i < DCTSIZE; i++) {		for (int col = 0; col < DCTSIZE; col++) {			int x = dataUnit[srcIndex] + 128;			if (x < 0) {				x = 0;			} else {				if (x > 255) x = 255;			}			compImage[destIndex + col] = (byte)x;			srcIndex++;		}		destIndex += compWidth;	}}void unloadIntoByteStream(ImageData image) {	if (!new JPEGStartOfImage().writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	JPEGAppn appn = new JPEGAppn(new byte[] {(byte)0xFF, (byte)0xE0, 0, 0x10, 0x4A, 0x46, 0x49, 0x46, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0});	if (!appn.writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	quantizationTables = new int[4][];	JPEGQuantizationTable chromDQT = JPEGQuantizationTable.defaultChrominanceTable();	chromDQT.scaleBy(encoderQFactor);	int[] jpegDQTKeys = chromDQT.getQuantizationTablesKeys();	int[][] jpegDQTValues = chromDQT.getQuantizationTablesValues();	for (int i = 0; i < jpegDQTKeys.length; i++) {		quantizationTables[jpegDQTKeys[i]] = jpegDQTValues[i];	}	JPEGQuantizationTable lumDQT = JPEGQuantizationTable.defaultLuminanceTable();	lumDQT.scaleBy(encoderQFactor);	jpegDQTKeys = lumDQT.getQuantizationTablesKeys();	jpegDQTValues = lumDQT.getQuantizationTablesValues();	for (int i = 0; i < jpegDQTKeys.length; i++) {		quantizationTables[jpegDQTKeys[i]] = jpegDQTValues[i];	}	if (!lumDQT.writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	if (!chromDQT.writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	int frameLength, scanLength, precision;	int[][] frameParams, scanParams;	if (image.depth == 1) {		frameLength = 11;		frameParams = new int[1][];		frameParams[0] = new int[] {1, 1, 1, 0, 0};		scanParams = new int[1][];		scanParams[0] = new int[] {0, 0};		scanLength = 8;		nComponents = 1;		precision = 1;	} else {		frameLength = 17;		frameParams = new int[3][];		frameParams[0] = new int[] {0, 2, 2, 0, 0};		frameParams[1] = new int[] {1, 1, 1, 0, 0};		frameParams[2] = new int[] {1, 1, 1, 0, 0};		scanParams = new int[3][];		scanParams[0] = new int[] {0, 0};		scanParams[1] = new int[] {1, 1};		scanParams[2] = new int[] {1, 1};		scanLength = 12;		nComponents = 3;		precision = 8;	}	imageWidth = image.width;	imageHeight = image.height;	frameHeader = new JPEGFrameHeader(new byte[19]);	frameHeader.setSegmentMarker(SOF0);	frameHeader.setSegmentLength(frameLength);	frameHeader.setSamplePrecision(precision);	frameHeader.setSamplesPerLine(imageWidth);	frameHeader.setNumberOfLines(imageHeight);	frameHeader.setNumberOfImageComponents(nComponents);	frameHeader.componentParameters = frameParams;	frameHeader.componentIdentifiers = new int[] {0, 1, 2};	frameHeader.initializeContents();	if (!frameHeader.writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	frameComponents = frameParams;	componentIds = frameHeader.componentIdentifiers;	maxH = frameHeader.getMaxHFactor();	maxV = frameHeader.getMaxVFactor();	int mcuWidth = maxH * DCTSIZE;	int mcuHeight = maxV * DCTSIZE;	interleavedMcuCols = (imageWidth + mcuWidth - 1) / mcuWidth;	interleavedMcuRows = (imageHeight + mcuHeight - 1) / mcuHeight;	acHuffmanTables = new JPEGHuffmanTable[4];	dcHuffmanTables = new JPEGHuffmanTable[4];	JPEGHuffmanTable[] dhtTables = new JPEGHuffmanTable[] {		JPEGHuffmanTable.getDefaultDCLuminanceTable(),		JPEGHuffmanTable.getDefaultDCChrominanceTable(),		JPEGHuffmanTable.getDefaultACLuminanceTable(),		JPEGHuffmanTable.getDefaultACChrominanceTable()	};	for (int i = 0; i < dhtTables.length; i++) {		JPEGHuffmanTable dhtTable = dhtTables[i];		if (!dhtTable.writeToStream(outputStream)) {			SWT.error(SWT.ERROR_IO);		}		JPEGHuffmanTable[] allTables = dhtTable.getAllTables();		for (int j = 0; j < allTables.length; j++) {			JPEGHuffmanTable huffmanTable = allTables[j];			if (huffmanTable.getTableClass() == 0) {				dcHuffmanTables[huffmanTable.getTableIdentifier()] = huffmanTable;			} else {				acHuffmanTables[huffmanTable.getTableIdentifier()] = huffmanTable;			}		}	}	precedingDCs = new int[4];	scanHeader = new JPEGScanHeader(new byte[14]);	scanHeader.setSegmentMarker(SOS);	scanHeader.setSegmentLength(scanLength);	scanHeader.setNumberOfImageComponents(nComponents);	scanHeader.setStartOfSpectralSelection(0);	scanHeader.setEndOfSpectralSelection(63);	scanHeader.componentParameters = scanParams;	scanHeader.initializeContents();	if (!scanHeader.writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}	convertImageToYCbCr(image);	resetOutputBuffer();	currentByte = 0;	currentBitCount = 0;	encodeScan();	if (!new JPEGEndOfImage().writeToStream(outputStream)) {		SWT.error(SWT.ERROR_IO);	}}}