MCL/sf/mw/qt: comparison src/plugins/imageformats/jpeg/qjpeghandler.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:3b1da2848fc7
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the plugins of the Qt Toolkit.
 **
 class QImageSmoothScaler
 {
 public:
 QImageSmoothScaler(const int w, const int h, const QImage &src);
 QImageSmoothScaler(const int srcWidth, const int srcHeight,
-const char *parameters);
+const int dstWidth, const int dstHeight);
 virtual ~QImageSmoothScaler(void);
 QImage  scale();
-protected:
-int scaledWidth(void) const;
 private:
 QImageSmoothScalerPrivate	*d;
 virtual QRgb *scanLine(const int line = 0, const QImage *src = 0);
 };
 d->setup(src.width(), src.height(), w, h, src.hasAlphaChannel() );
 this->d->src = &src;
 }
 QImageSmoothScaler::QImageSmoothScaler(const int srcWidth, const int srcHeight,
-const char *parameters)
+const int dstWidth, const int dstHeight)
 {
-char    sModeStr[1024];
-int	    t1;
-int	    t2;
-int	    dstWidth;
-int	    dstHeight;
-sModeStr[0] = '\0';
 d = new QImageSmoothScalerPrivate;
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
-sscanf_s(parameters, "Scale( %i, %i, %1023s )", &dstWidth, &dstHeight, sModeStr, sizeof(sModeStr));
-#else
-sscanf(parameters, "Scale( %i, %i, %s )", &dstWidth, &dstHeight, sModeStr);
-#endif
-QString sModeQStr = QString::fromLatin1(sModeStr);
-t1 = srcWidth * dstHeight;
-t2 = srcHeight * dstWidth;
-if (((sModeQStr == QLatin1String("ScaleMin")) && (t1 > t2)) || ((sModeQStr == QLatin1String("ScaleMax")) && (t2 < t2))) {
-	dstHeight = t2 / srcWidth;
-} else if (sModeQStr != QLatin1String("ScaleFree")) {
-	dstWidth = t1 / srcHeight;
-}
 d->setup(srcWidth, srcHeight, dstWidth, dstHeight, 0);
 }
 void QImageSmoothScalerPrivate::setup(const int srcWidth, const int srcHeight,
 const int dstWidth, const int dstHeight,
 cols = srcWidth;
 rows = srcHeight;
 newcols = dstWidth;
 newrows = dstHeight;
 hasAlpha = hasAlphaChannel;
-}
-int QImageSmoothScaler::scaledWidth() const
-{
-return d->cols;
 }
 QImageSmoothScaler::~QImageSmoothScaler()
 {
 delete d;
 }
 class jpegSmoothScaler : public QImageSmoothScaler
 {
 public:
-jpegSmoothScaler(struct jpeg_decompress_struct *info, const char *params):
+jpegSmoothScaler(struct jpeg_decompress_struct *info, const QSize& dstSize, const QRect& clipRect)
-	QImageSmoothScaler(info->output_width, info->output_height, params)
+: QImageSmoothScaler(clipRect.width(), clipRect.height(),
+dstSize.width(), dstSize.height())
 {
-	cinfo = info;
+cinfo = info;
-	cols24Bit = scaledWidth() * 3;
+clip = clipRect;
+imageCache = QImage(info->output_width, 1, QImage::Format_RGB32);
-	cacheHeight = 1;
-	imageCache = QImage( info->output_width, cacheHeight, QImage::Format_RGB32 );
 }
 private:
-int	    cols24Bit;
+QRect   clip;
 QImage  imageCache;
-int	    cacheHeight;
 struct jpeg_decompress_struct *cinfo;
 QRgb *scanLine(const int line = 0, const QImage *src = 0)
 {
 	QRgb    *out;
 	Q_UNUSED(line);
 	Q_UNUSED(src);
 uchar* data = imageCache.bits();
+// Read ahead if we haven't reached the first clipped scanline yet.
+while (int(cinfo->output_scanline) < clip.y() &&
+cinfo->output_scanline < cinfo->output_height)
+	    jpeg_read_scanlines(cinfo, &data, 1);
+// Read the next scanline.  We assume that "line"
+// will never be >= clip.height().
 	jpeg_read_scanlines(cinfo, &data, 1);
-	out = (QRgb*)imageCache.scanLine(0);
+if (cinfo->output_scanline == cinfo->output_height)
+jpeg_finish_decompress(cinfo);
+	out = ((QRgb*)data) + clip.x();
 	//
 	// The smooth scale algorithm only works on 32-bit images;
 	// convert from (8|24) bits to 32.
 	//
 	if (cinfo->output_components == 1) {
-	    in = (uchar*)out + scaledWidth();
+	    in = data + clip.right();
-	    for (uint i = scaledWidth(); i--; ) {
+	    for (int i = clip.width(); i--; ) {
+		out[i] = qRgb(*in, *in, *in);
 		in--;
-		out[i] = qRgb(*in, *in, *in);
 	    }
 } else if (cinfo->out_color_space == JCS_CMYK) {
-int cols32Bit = scaledWidth() * 4;
+in = data + clip.right() * 4;
-in = (uchar*)out + cols32Bit;
+for (int i = clip.width(); i--; ) {
-for (uint i = scaledWidth(); i--; ) {
+int k = in[3];
-in -= 4;
+out[i] = qRgb(k * in[0] / 255, k * in[1] / 255, k * in[2] / 255);
-int k = in[3];
+in -= 4;
-out[i] = qRgb(k * in[0] / 255, k * in[1] / 255, k * in[2] / 255);
+}
-//out[i] = qRgb(in[0], in[1], in[2]);
+} else {
-}
+	    in = data + clip.right() * 3;
-} else {
+	    for (int i = clip.width(); i--; ) {
-	    in = (uchar*)out + cols24Bit;
+		out[i] = qRgb(in[0], in[1], in[2]);
-	    for (uint i = scaledWidth(); i--; ) {
 		in -= 3;
-		out[i] = qRgb(in[0], in[1], in[2]);
 	    }
 	}
 	return out;
 }
 this->device = device;
 bytes_in_buffer = 0;
 next_input_byte = buffer;
 }
-static void scaleSize(int &reqW, int &reqH, int imgW, int imgH, Qt::AspectRatioMode mode)
-{
-if (mode == Qt::IgnoreAspectRatio)
-return;
-int t1 = imgW * reqH;
-int t2 = reqW * imgH;
-if ((mode == Qt::KeepAspectRatio && (t1 > t2)) || (mode == Qt::KeepAspectRatioByExpanding && (t1 < t2)))
-reqH = t2 / imgW;
-else
-reqW = t1 / imgH;
-}
 static bool read_jpeg_size(QIODevice *device, int &w, int &h)
 {
 bool rt = false;
 struct jpeg_decompress_struct cinfo;
 delete iod_src;
 return result;
 }
 static bool ensureValidImage(QImage *dest, struct jpeg_decompress_struct *info,
-bool dummy = false)
+const QSize& size)
 {
 QImage::Format format;
 switch (info->output_components) {
 case 1:
 format = QImage::Format_Indexed8;
 break;
 default:
 return false; // unsupported format
 }
-const QSize size(info->output_width, info->output_height);
 if (dest->size() != size || dest->format() != format) {
-static uchar dummyImage[1];
+*dest = QImage(size, format);
-if (dummy) // Create QImage but don't read the pixels
-*dest = QImage(dummyImage, size.width(), size.height(), format);
-else
-*dest = QImage(size, format);
 if (format == QImage::Format_Indexed8) {
 dest->setColorCount(256);
 for (int i = 0; i < 256; i++)
 dest->setColor(i, qRgb(i,i,i));
 return !dest->isNull();
 }
 static bool read_jpeg_image(QIODevice *device, QImage *outImage,
-const QByteArray &parameters, QSize scaledSize,
+QSize scaledSize, QRect scaledClipRect,
-int inQuality )
+QRect clipRect, int inQuality )
 {
-#ifdef QT_NO_IMAGE_SMOOTHSCALE
-Q_UNUSED( scaledSize );
-#endif
 struct jpeg_decompress_struct cinfo;
 struct my_jpeg_source_mgr *iod_src = new my_jpeg_source_mgr(device);
 struct my_error_mgr jerr;
 // -1 means default quality.
 int quality = inQuality;
 if (quality < 0)
 quality = 75;
-QString params = QString::fromLatin1(parameters);
+// If possible, merge the scaledClipRect into either scaledSize
-params.simplified();
+// or clipRect to avoid doing a separate scaled clipping pass.
-int sWidth = 0, sHeight = 0;
+// Best results are achieved by clipping before scaling, not after.
-char sModeStr[1024] = "";
+if (!scaledClipRect.isEmpty()) {
-Qt::AspectRatioMode sMode;
+if (scaledSize.isEmpty() && clipRect.isEmpty()) {
+// No clipping or scaling before final clip.
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
+clipRect = scaledClipRect;
-// If high quality not required, shrink image during decompression
+scaledClipRect = QRect();
-if (scaledSize.isValid() && !scaledSize.isEmpty() && quality < HIGH_QUALITY_THRESHOLD
+} else if (scaledSize.isEmpty()) {
-&& !params.contains(QLatin1String("GetHeaderInformation")) ) {
+// Clipping, but no scaling: combine the clip regions.
-cinfo.scale_denom = qMin(cinfo.image_width / scaledSize.width(),
+scaledClipRect.translate(clipRect.topLeft());
-cinfo.image_width / scaledSize.height());
+clipRect = scaledClipRect.intersected(clipRect);
+scaledClipRect = QRect();
+} else if (clipRect.isEmpty()) {
+// No clipping, but scaling: if we can map back to an
+// integer pixel boundary, then clip before scaling.
+if ((cinfo.image_width % scaledSize.width()) == 0 &&
+(cinfo.image_height % scaledSize.height()) == 0) {
+int x = scaledClipRect.x() * cinfo.image_width /
+scaledSize.width();
+int y = scaledClipRect.y() * cinfo.image_height /
+scaledSize.height();
+int width = (scaledClipRect.right() + 1) *
+cinfo.image_width / scaledSize.width() - x;
+int height = (scaledClipRect.bottom() + 1) *
+cinfo.image_height / scaledSize.height() - y;
+clipRect = QRect(x, y, width, height);
+scaledSize = scaledClipRect.size();
+scaledClipRect = QRect();
+}
+} else {
+// Clipping and scaling: too difficult to figure out,
+// and not a likely use case, so do it the long way.
+}
+}
+// Determine the scale factor to pass to libjpeg for quick downscaling.
+if (!scaledSize.isEmpty()) {
+if (clipRect.isEmpty()) {
+cinfo.scale_denom =
+qMin(cinfo.image_width / scaledSize.width(),
+cinfo.image_height / scaledSize.height());
+} else {
+cinfo.scale_denom =
+qMin(clipRect.width() / scaledSize.width(),
+clipRect.height() / scaledSize.height());
+}
 if (cinfo.scale_denom < 2) {
 cinfo.scale_denom = 1;
 } else if (cinfo.scale_denom < 4) {
 cinfo.scale_denom = 2;
 } else if (cinfo.scale_denom < 8) {
 cinfo.scale_denom = 4;
 } else {
 cinfo.scale_denom = 8;
 }
 cinfo.scale_num = 1;
-}
+if (!clipRect.isEmpty()) {
-#endif
+// Correct the scale factor so that we clip accurately.
+// It is recommended that the clip rectangle be aligned
+// on an 8-pixel boundary for best performance.
+while (cinfo.scale_denom > 1 &&
+((clipRect.x() % cinfo.scale_denom) != 0 ||
+(clipRect.y() % cinfo.scale_denom) != 0 ||
+(clipRect.width() % cinfo.scale_denom) != 0 ||
+(clipRect.height() % cinfo.scale_denom) != 0)) {
+cinfo.scale_denom /= 2;
+}
+}
+}
 // If high quality not required, use fast decompression
 if( quality < HIGH_QUALITY_THRESHOLD ) {
 cinfo.dct_method = JDCT_IFAST;
 cinfo.do_fancy_upsampling = FALSE;
 }
+(void) jpeg_calc_output_dimensions(&cinfo);
-(void) jpeg_start_decompress(&cinfo);
+// Determine the clip region to extract.
-if (params.contains(QLatin1String("GetHeaderInformation"))) {
+QRect imageRect(0, 0, cinfo.output_width, cinfo.output_height);
-if (!ensureValidImage(outImage, &cinfo, true))
+QRect clip;
+if (clipRect.isEmpty()) {
+clip = imageRect;
+} else if (cinfo.scale_denom == 1) {
+clip = clipRect.intersected(imageRect);
+} else {
+// The scale factor was corrected above to ensure that
+// we don't miss pixels when we scale the clip rectangle.
+clip = QRect(clipRect.x() / int(cinfo.scale_denom),
+clipRect.y() / int(cinfo.scale_denom),
+clipRect.width() / int(cinfo.scale_denom),
+clipRect.height() / int(cinfo.scale_denom));
+clip = clip.intersected(imageRect);
+}
+#ifndef QT_NO_IMAGE_SMOOTHSCALE
+if (scaledSize.isValid() && scaledSize != clip.size()
+&& quality >= HIGH_QUALITY_THRESHOLD) {
+(void) jpeg_start_decompress(&cinfo);
+jpegSmoothScaler scaler(&cinfo, scaledSize, clip);
+*outImage = scaler.scale();
+} else
+#endif
+{
+// Allocate memory for the clipped QImage.
+if (!ensureValidImage(outImage, &cinfo, clip.size()))
 longjmp(jerr.setjmp_buffer, 1);
-} else if (params.contains(QLatin1String("Scale"))) {
-#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(Q_OS_WINCE)
+// Avoid memcpy() overhead if grayscale with no clipping.
-sscanf_s(params.toLatin1().data(), "Scale(%i, %i, %1023s)",
+bool quickGray = (cinfo.output_components == 1 &&
-&sWidth, &sHeight, sModeStr, sizeof(sModeStr));
+clip == imageRect);
-#else
+if (!quickGray) {
-sscanf(params.toLatin1().data(), "Scale(%i, %i, %1023s)",
+// Ask the jpeg library to allocate a temporary row.
-&sWidth, &sHeight, sModeStr);
+// The library will automatically delete it for us later.
-#endif
+// The libjpeg docs say we should do this before calling
+// jpeg_start_decompress().  We can't use "new" here
-QString sModeQStr(QString::fromLatin1(sModeStr));
+// because we are inside the setjmp() block and an error
-if (sModeQStr == QLatin1String("IgnoreAspectRatio")) {
+// in the jpeg input stream would cause a memory leak.
-sMode = Qt::IgnoreAspectRatio;
+JSAMPARRAY rows = (cinfo.mem->alloc_sarray)
-} else if (sModeQStr == QLatin1String("KeepAspectRatio")) {
+((j_common_ptr)&cinfo, JPOOL_IMAGE,
-sMode = Qt::KeepAspectRatio;
+cinfo.output_width * cinfo.output_components, 1);
-} else if (sModeQStr == QLatin1String("KeepAspectRatioByExpanding")) {
-sMode = Qt::KeepAspectRatioByExpanding;
+(void) jpeg_start_decompress(&cinfo);
-} else {
-qDebug("read_jpeg_image: invalid aspect ratio mode \"%s\", see QImage::AspectRatioMode documentation", sModeStr);
-sMode = Qt::KeepAspectRatio;
-}
-//            qDebug("Parameters ask to scale the image to %i x %i AspectRatioMode: %s", sWidth, sHeight, sModeStr);
-scaleSize(sWidth, sHeight, cinfo.output_width, cinfo.output_height, sMode);
-//            qDebug("Scaling the jpeg to %i x %i", sWidth, sHeight, sModeStr);
-if (cinfo.output_components == 3 || cinfo.output_components == 4) {
-if (outImage->size() != QSize(sWidth, sHeight) || outImage->format() != QImage::Format_RGB32)
-*outImage = QImage(sWidth, sHeight, QImage::Format_RGB32);
-} else if (cinfo.output_components == 1) {
-if (outImage->size() != QSize(sWidth, sHeight) || outImage->format() != QImage::Format_Indexed8)
-*outImage = QImage(sWidth, sHeight, QImage::Format_Indexed8);
-outImage->setColorCount(256);
-for (int i = 0; i < 256; ++i)
-outImage->setColor(i, qRgb(i,i,i));
-} else {
-// Unsupported format
-}
-if (outImage->isNull())
-longjmp(jerr.setjmp_buffer, 1);
-if (!outImage->isNull()) {
-QImage tmpImage(cinfo.output_width, 1, QImage::Format_RGB32);
-uchar* inData = tmpImage.bits();
-uchar* outData = outImage->bits();
-int out_bpl = outImage->bytesPerLine();
 while (cinfo.output_scanline < cinfo.output_height) {
-int outputLine = sHeight * cinfo.output_scanline / cinfo.output_height;
+int y = int(cinfo.output_scanline) - clip.y();
-(void) jpeg_read_scanlines(&cinfo, &inData, 1);
+if (y >= clip.height())
+break;      // We've read the entire clip region, so abort.
+(void) jpeg_read_scanlines(&cinfo, rows, 1);
+if (y < 0)
+continue;   // Haven't reached the starting line yet.
 if (cinfo.output_components == 3) {
-uchar *in = inData;
+// Expand 24->32 bpp.
-QRgb *out = (QRgb*)outData + outputLine * out_bpl;
+uchar *in = rows[0] + clip.x() * 3;
-for (uint i=0; i<cinfo.output_width; i++) {
+QRgb *out = (QRgb*)outImage->scanLine(y);
-// ### Only scaling down an image works, I don't think scaling up will work at the moment
+for (int i = 0; i < clip.width(); ++i) {
-// ### An idea I have to make this a smooth scale is to progressively add the pixel values up
+*out++ = qRgb(in[0], in[1], in[2]);
-// When scaling down, multiple values are being over drawn in to the output buffer.
-// Instead, a weighting based on the distance the line or pixel is from the output pixel determines
-// the weight of it when added to the output buffer. At present it is a non-smooth scale which is
-// inefficently implemented, it still uncompresses all the jpeg, an optimization for progressive
-// jpegs could be made if scaling by say 50% or some other special cases
-out[sWidth * i / cinfo.output_width] = qRgb(in[0], in[1], in[2]);
 in += 3;
 }
-} else {
+} else if (cinfo.out_color_space == JCS_CMYK) {
-// ### Need to test the case where the jpeg is grayscale, need some black and white jpegs to test
+// Convert CMYK->RGB.
-// this code. (also only scales down and probably won't scale to a larger size)
+uchar *in = rows[0] + clip.x() * 4;
-uchar *in = inData;
+QRgb *out = (QRgb*)outImage->scanLine(y);
-uchar *out = outData + outputLine*out_bpl;
+for (int i = 0; i < clip.width(); ++i) {
-for (uint i=0; i<cinfo.output_width; i++) {
+int k = in[3];
-out[sWidth * i / cinfo.output_width] = in[i];
+*out++ = qRgb(k * in[0] / 255, k * in[1] / 255,
+k * in[2] / 255);
+in += 4;
 }
+} else if (cinfo.output_components == 1) {
+// Grayscale.
+memcpy(outImage->scanLine(y),
+rows[0] + clip.x(), clip.width());
 }
 }
+} else {
+// Load unclipped grayscale data directly into the QImage.
+(void) jpeg_start_decompress(&cinfo);
+while (cinfo.output_scanline < cinfo.output_height) {
+uchar *row = outImage->scanLine(cinfo.output_scanline);
+(void) jpeg_read_scanlines(&cinfo, &row, 1);
+}
+}
+if (cinfo.output_scanline == cinfo.output_height)
 (void) jpeg_finish_decompress(&cinfo);
-}
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
-} else if (scaledSize.isValid() && scaledSize != QSize(cinfo.output_width, cinfo.output_height)
-&& quality >= HIGH_QUALITY_THRESHOLD) {
-jpegSmoothScaler scaler(&cinfo, QString().sprintf("Scale( %d, %d, ScaleFree )",
-scaledSize.width(),
-scaledSize.height()).toLatin1().data());
-*outImage = scaler.scale();
-#endif
-} else {
-if (!ensureValidImage(outImage, &cinfo))
-longjmp(jerr.setjmp_buffer, 1);
-uchar* data = outImage->bits();
-int bpl = outImage->bytesPerLine();
-while (cinfo.output_scanline < cinfo.output_height) {
-uchar *d = data + cinfo.output_scanline * bpl;
-(void) jpeg_read_scanlines(&cinfo,
-&d,
-1);
-}
-(void) jpeg_finish_decompress(&cinfo);
-if (cinfo.output_components == 3) {
-// Expand 24->32 bpp.
-for (uint j=0; j<cinfo.output_height; j++) {
-uchar *in = outImage->scanLine(j) + cinfo.output_width * 3;
-QRgb *out = (QRgb*)outImage->scanLine(j);
-for (uint i=cinfo.output_width; i--;) {
-in-=3;
-out[i] = qRgb(in[0], in[1], in[2]);
-}
-}
-} else if (cinfo.out_color_space == JCS_CMYK) {
-for (uint j = 0; j < cinfo.output_height; ++j) {
-uchar *in = outImage->scanLine(j) + cinfo.output_width * 4;
-QRgb *out = (QRgb*)outImage->scanLine(j);
-for (uint i = cinfo.output_width; i--; ) {
-in-=4;
-int k = in[3];
-out[i] = qRgb(k * in[0] / 255, k * in[1] / 255, k * in[2] / 255);
-}
-}
-}
 if (cinfo.density_unit == 1) {
 outImage->setDotsPerMeterX(int(100. * cinfo.X_density / 2.54));
 outImage->setDotsPerMeterY(int(100. * cinfo.Y_density / 2.54));
 } else if (cinfo.density_unit == 2) {
 outImage->setDotsPerMeterX(int(100. * cinfo.X_density));
 outImage->setDotsPerMeterY(int(100. * cinfo.Y_density));
 }
-if (scaledSize.isValid() && scaledSize != QSize(cinfo.output_width, cinfo.output_height))
+if (scaledSize.isValid() && scaledSize != clip.size())
 *outImage = outImage->scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::FastTransformation);
 }
 }
 jpeg_destroy_decompress(&cinfo);
 delete iod_src;
+if (!scaledClipRect.isEmpty())
+*outImage = outImage->copy(scaledClipRect);
 return !outImage->isNull();
 }
 struct my_jpeg_destination_mgr : public jpeg_destination_mgr {
 bool QJpegHandler::read(QImage *image)
 {
 if (!canRead())
 return false;
-return read_jpeg_image(device(), image, parameters, scaledSize, quality);
+return read_jpeg_image(device(), image, scaledSize, scaledClipRect, clipRect, quality);
 }
 bool QJpegHandler::write(const QImage &image)
 {
 return write_jpeg_image(image, device(), quality);
 }
 bool QJpegHandler::supportsOption(ImageOption option) const
 {
 return option == Quality
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
 || option == ScaledSize
-#endif
+|| option == ScaledClipRect
+|| option == ClipRect
 || option == Size
 || option == ImageFormat;
 }
 QVariant QJpegHandler::option(ImageOption option) const
 {
 if (option == Quality) {
 return quality;
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
 } else if  (option == ScaledSize) {
 return scaledSize;
-#endif
+} else if  (option == ScaledClipRect) {
+return scaledClipRect;
+} else if  (option == ClipRect) {
+return clipRect;
 } else if (option == Size) {
 if (canRead() && !device()->isSequential()) {
 qint64 pos = device()->pos();
 int width = 0;
 int height = 0;
 void QJpegHandler::setOption(ImageOption option, const QVariant &value)
 {
 if (option == Quality)
 quality = value.toInt();
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
 else if ( option == ScaledSize )
 scaledSize = value.toSize();
-#endif
+else if ( option == ScaledClipRect )
+scaledClipRect = value.toRect();
+else if ( option == ClipRect )
+clipRect = value.toRect();
 }
 QByteArray QJpegHandler::name() const
 {
 return "jpeg";

branch	RCL_3
changeset 4	3b1da2848fc7
parent 3	41300fa6a67c
child 7	3f74d0d4af4c