diff --git a/common/rfb/IrixDMIC_RawToJpeg.cxx b/common/rfb/IrixDMIC_RawToJpeg.cxx
new file mode 100644
index 0000000..6b76304
--- /dev/null
+++ b/common/rfb/IrixDMIC_RawToJpeg.cxx
@@ -0,0 +1,423 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/poll.h>
+
+#include <rfb/IrixDMIC_RawToJpeg.h>
+
+using namespace rfb;
+
+//
+// Constructor. Find a converter and create a context. Also, create
+// DMparams structures for using with dmICSetSrcParams,
+// dmICSetDstParams and dmICSetConvParams.
+//
+
+IrixDMIC_RawToJpeg::IrixDMIC_RawToJpeg(bool needRealtime)
+  : m_valid_ic(false),
+    m_srcParams(0),
+    m_dstParams(0),
+    m_convParams(0)
+{
+  if ( dmParamsCreate(&m_srcParams) != DM_SUCCESS ||
+       dmParamsCreate(&m_dstParams) != DM_SUCCESS ||
+       dmParamsCreate(&m_convParams) != DM_SUCCESS ) {
+    reportError("dmParamsCreate");
+    return;
+  }
+
+  DMparams *p;
+  const int JPEG_ID = 0x6A706567; // same as 'jpeg'
+  int id, direction, speed;
+
+  int n = dmICGetNum();
+  while (n--) {
+    if (dmParamsCreate(&p) != DM_SUCCESS) {
+      reportError("dmParamsCreate");
+      return;
+    }
+    if (dmICGetDescription(n, p) != DM_SUCCESS)
+      continue;
+    id = dmParamsGetInt(p, DM_IC_ID);
+    direction = dmParamsGetEnum(p, DM_IC_CODE_DIRECTION);
+    speed = dmParamsGetEnum(p, DM_IC_SPEED);
+    if ( id == JPEG_ID && direction == DM_IC_CODE_DIRECTION_ENCODE &&
+	 (!needRealtime || speed == DM_IC_SPEED_REALTIME) ) {
+
+      // FIXME: Just save the engine name and make x0vncserver print it.
+      const char *engine = dmParamsGetString(p, DM_IC_ENGINE);
+      printf("Found JPEG encoder: \"%s\" (%d)\n", engine, n);
+
+      dmParamsDestroy(p);
+      break;
+    }
+    dmParamsDestroy(p);
+  }
+  if (n < 0) {
+    // FIXME: Unify error handling.
+    fprintf (stderr, "Error: No matching JPEG encoder found\n");
+    return;
+  }
+  if (dmICCreate(n, &m_ic) != DM_SUCCESS) {
+    reportError("dmICCreate");
+    return;
+  }
+
+  m_valid_ic = true;
+}
+
+//
+// Destructor.
+//
+
+IrixDMIC_RawToJpeg::~IrixDMIC_RawToJpeg()
+{
+  if (m_valid_ic)
+    dmICDestroy(m_ic);
+
+  if (m_convParams)
+    dmParamsDestroy(m_convParams);
+  if (m_dstParams)
+    dmParamsDestroy(m_dstParams);
+  if (m_srcParams)
+    dmParamsDestroy(m_srcParams);
+}
+
+//
+// Configure the source and destination formats.
+//
+// FIXME: Remember image size that was previously set, do not set the
+//        same size again.
+//
+
+bool
+IrixDMIC_RawToJpeg::setImageParams(int w, int h)
+{
+  if (!m_valid_ic) {
+    reportErrorNotInited();
+    return false;
+  }
+
+  // Set source image parameters.
+  DMpacking packing = DM_IMAGE_PACKING_XBGR;
+  int orient = DM_IMAGE_TOP_TO_BOTTOM;
+  if (dmSetImageDefaults(m_srcParams, w, h, packing) != DM_SUCCESS) {
+    reportError("dmSetImageDefaults");
+    return false;
+  }
+  DMstatus err = dmParamsSetEnum(m_srcParams, DM_IMAGE_ORIENTATION, orient);
+  if (err != DM_SUCCESS) {
+    reportError("dmParamsSetEnum");
+    return false;
+  }
+  if (dmICSetSrcParams(m_ic, m_srcParams) != DM_SUCCESS) {
+    reportError("dmICSetSrcParams");
+    return false;
+  }
+
+  // Set destination image parameters.
+  packing = DM_IMAGE_PACKING_CbYCrY;
+  const char *compression = DM_IMAGE_JPEG;
+  if (dmSetImageDefaults(m_dstParams, w, h, packing) != DM_SUCCESS) {
+    reportError("dmSetImageDefaults");
+    return false;
+  }
+  err = dmParamsSetEnum(m_dstParams, DM_IMAGE_ORIENTATION, orient);
+  if (err != DM_SUCCESS) {
+    reportError("dmParamsSetEnum");
+    return false;
+  }
+  err = dmParamsSetString(m_dstParams, DM_IMAGE_COMPRESSION, compression);
+  if (err != DM_SUCCESS) {
+    reportError("dmParamsSetString");
+    return false;
+  }
+  if (dmICSetDstParams(m_ic, m_dstParams) != DM_SUCCESS) {
+    reportError("dmICSetDstParams");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Set JPEG image quality level (an integer in the range 0..99).
+//
+// FIXME: Remember image quality that was previously set, do not set
+//        the same quality again.
+//
+
+bool
+IrixDMIC_RawToJpeg::setImageQuality(int quality)
+{
+  if (!m_valid_ic) {
+    reportErrorNotInited();
+    return false;
+  }
+
+  double qf = (double)quality / 100.0;
+
+  DMstatus err = dmParamsSetFloat(m_convParams, DM_IMAGE_QUALITY_SPATIAL, qf);
+  if (err != DM_SUCCESS) {
+    reportError("dmParamsSetFloat");
+    return false;
+  }
+  if (dmICSetConvParams(m_ic, m_convParams) != DM_SUCCESS) {
+    reportError("dmICSetConvParams");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Set up source buffer pool.
+//
+// NOTE: Both setImageParams() and setImageQuality() functions should
+//       be called prior to creating and registering buffer pools.
+//
+
+bool
+IrixDMIC_RawToJpeg::createSrcBufferPool(DMbufferpool *pool,
+                                        int bufCount, int bufSize)
+{
+  if (!m_valid_ic) {
+    reportErrorNotInited();
+    return false;
+  }
+
+  DMparams *p;
+  if (dmParamsCreate(&p) != DM_SUCCESS) {
+    reportError("dmParamsCreate");
+    return false;
+  }
+
+  if (dmBufferSetPoolDefaults(p, bufCount, bufSize, DM_FALSE, DM_TRUE) !=
+      DM_SUCCESS) {
+    reportError("dmBufferSetPoolDefaults");
+    dmParamsDestroy(p);
+    return false;
+  }
+  if (dmICGetSrcPoolParams(m_ic, p) != DM_SUCCESS) {
+    reportError("dmICGetSrcPoolParams");
+    dmParamsDestroy(p);
+    return false;
+  }
+  if (dmBufferCreatePool(p, pool) != DM_SUCCESS) {
+    reportError("dmBufferCreatePool");
+    dmParamsDestroy(p);
+    return false;
+  }
+
+  dmParamsDestroy(p);
+  return true;
+}
+
+//
+// Set up and register destination buffer pool.
+//
+// NOTE: Both setImageParams() and setImageQuality() functions should
+//       be called prior to creating and registering buffer pools.
+//
+
+bool
+IrixDMIC_RawToJpeg::registerDstBufferPool(DMbufferpool *pool,
+                                          int bufCount, int bufSize)
+{
+  if (!m_valid_ic) {
+    reportErrorNotInited();
+    return false;
+  }
+
+  DMparams *p;
+  if (dmParamsCreate(&p) != DM_SUCCESS) {
+    reportError("dmParamsCreate");
+    return false;
+  }
+
+  if (dmBufferSetPoolDefaults(p, bufCount, bufSize, DM_FALSE, DM_TRUE) !=
+      DM_SUCCESS) {
+    reportError("dmBufferSetPoolDefaults");
+    dmParamsDestroy(p);
+    return false;
+  }
+  if (dmICGetDstPoolParams(m_ic, p) != DM_SUCCESS) {
+    reportError("dmICGetDstPoolParams");
+    dmParamsDestroy(p);
+    return false;
+  }
+  if (dmBufferCreatePool(p, pool) != DM_SUCCESS) {
+    reportError("dmBufferCreatePool");
+    dmParamsDestroy(p);
+    return false;
+  }
+
+  dmParamsDestroy(p);
+
+  if (dmICSetDstPool(m_ic, *pool) != DM_SUCCESS) {
+    reportError("dmICSetDstPool");
+    destroyBufferPool(*pool);
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Destroy buffer pool created with either createSrcBufferPool() or
+// registerDstBufferPool().
+//
+
+void
+IrixDMIC_RawToJpeg::destroyBufferPool(DMbufferpool pool)
+{
+  if (dmBufferDestroyPool(pool) != DM_SUCCESS)
+    reportError("dmBufferDestroyPool");
+}
+
+//
+// Allocate a buffer from the specified pool.
+//
+
+bool
+IrixDMIC_RawToJpeg::allocBuffer(DMbuffer *pbuf, DMbufferpool pool)
+{
+  if (dmBufferAllocate(pool, pbuf) != DM_SUCCESS) {
+    reportError("dmBufferAllocate");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Fill in a DMbuffer with data.
+//
+// NOTE: The caller must make sure that the buffer size is no less
+//       than dataSize.
+//
+
+bool
+IrixDMIC_RawToJpeg::copyToBuffer(DMbuffer buf, const void *data, int dataSize)
+{
+  void *bufPtr = dmBufferMapData(buf);
+  memcpy(bufPtr, data, dataSize);
+
+  if (dmBufferSetSize(buf, dataSize) != DM_SUCCESS) {
+    reportError("dmBufferSetSize");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Map DMbuffer to physical memory.
+//
+
+void *
+IrixDMIC_RawToJpeg::mapBufferData(DMbuffer buf)
+{
+  return dmBufferMapData(buf);
+}
+
+//
+// Get the number of valid bytes in DMbuffer.
+//
+
+int
+IrixDMIC_RawToJpeg::getBufferSize(DMbuffer buf)
+{
+  return dmBufferGetSize(buf);
+}
+
+//
+// Free DMbuffer.
+//
+
+void
+IrixDMIC_RawToJpeg::freeBuffer(DMbuffer buf)
+{
+  if (dmBufferFree(buf) != DM_SUCCESS)
+    reportError("dmBufferFree");
+}
+
+//
+// Send input data (raw pixels) to the converter.
+//
+
+bool
+IrixDMIC_RawToJpeg::sendData(DMbuffer buf)
+{
+  if (dmICSend(m_ic, buf, 0, NULL) != DM_SUCCESS) {
+    reportError("dmICSend");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Wait until compression is finished (infinite timeout!).
+// This function should be called after sendData() and before receiveData().
+//
+// FIXME: Report errors.
+//
+
+bool
+IrixDMIC_RawToJpeg::waitConversion()
+{
+  struct pollfd ps;
+  ps.fd = dmICGetDstQueueFD(m_ic);
+  ps.events = POLLIN;
+
+  int result = poll(&ps, 1, -1);
+  if (result != 1)
+    return false;
+
+  if ((ps.revents & POLLIN) != 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+//
+// Receive output (JPEG data) from the converter.
+// Call waitConversion() function first.
+//
+
+bool
+IrixDMIC_RawToJpeg::receiveData(DMbuffer *pbuf)
+{
+  if (dmICReceive(m_ic, pbuf) != DM_SUCCESS) {
+    reportError("dmICReceive");
+    return false;
+  }
+
+  return true;
+}
+
+//
+// Report an error when a function returns DM_FAILURE.
+//
+
+void
+IrixDMIC_RawToJpeg::reportError(const char *funcName)
+{
+  char errorDetail[DM_MAX_ERROR_DETAIL];
+  const char *errorCategory = dmGetError(NULL, errorDetail);
+  fprintf(stderr, "%s() failed: %s: %s\n",
+	  funcName, errorCategory, errorDetail);
+}
+
+//
+// Report an error when (m_valid_ic == false).
+//
+
+void
+IrixDMIC_RawToJpeg::reportErrorNotInited()
+{
+  fprintf(stderr, "Internal error: Image converter not initialized\n");
+}
+