encoder.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//    Copyright (c) 2001-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "precomp.h"

#include <stdio.h>
#include <string.h>

#ifndef __JPEGBASE_H__
#include "jpegbase.h"
#endif
#ifndef __ENCODER_H__
#include "encoder.h"
#endif




CJPEGEncoder::CJPEGEncoder(void)
{
  m_src.p.Data8u   = 0;
  m_src.width      = 0;
  m_src.height     = 0;
  m_src.nChannels  = 0;
  m_src.lineStep   = 0;

  m_dst.pData      = 0;
  m_dst.DataLen    = 0;
  m_dst.currPos    = 0;

  m_jpeg_ncomp            = 0;
  m_jpeg_precision        = 8;
  m_jpeg_sampling         = JS_444;
  m_jpeg_color            = JC_UNKNOWN;
  m_jpeg_quality          = 100;
  m_jpeg_restart_interval = 0;
  m_jpeg_mode             = JPEG_BASELINE;

  m_numxMCU   = 0;
  m_numyMCU   = 0;
  m_mcuWidth  = 0;
  m_mcuHeight = 0;

  m_ccWidth  = 0;
  m_ccHeight = 0;
  m_xPadding = 0;
  m_yPadding = 0;

  m_restarts_to_go   = 0;
  m_next_restart_num = 0;

  m_scan_count  = 0;
  m_scan_script = 0;
  m_coefbuf     = 0;

  m_ss = 0;
  m_se = 63;
  m_ah = 0;
  m_al = 0;

  m_predictor = 1;
  m_pt = 0;

  m_ccomp[0] = 0;
  m_ccomp[1] = 0;
  m_ccomp[2] = 0;
  m_ccomp[3] = 0;

  return;
} // ctor


CJPEGEncoder::~CJPEGEncoder(void)
{
  Clean();
  return;
} // dtor


JERRCODE CJPEGEncoder::Clean(void)
{
  int i;

  for(i = 0; i < m_jpeg_ncomp; i++)
  {
    if(0 != m_ccomp[i])
    {
      if(0 != m_ccomp[i]->m_cc_buffer)
      {
        ippFree(m_ccomp[i]->m_cc_buffer);
        m_ccomp[i]->m_cc_buffer = 0;
      }

      if(0 != m_ccomp[i]->m_ss_buffer)
      {
        ippFree(m_ccomp[i]->m_ss_buffer);
        m_ccomp[i]->m_ss_buffer = 0;
      }
    }
    delete m_ccomp[i];
    m_ccomp[i] = 0;
  }

  for(i = 0; i < MAX_HUFF_TABLES; i++)
  {
    m_dctbl[i].Destroy();
    m_actbl[i].Destroy();
  }

  if(0 != m_scan_script)
  {
    delete[] m_scan_script;
    m_scan_script = 0;
  }

  if(0 != m_coefbuf)
  {
    ippFree(m_coefbuf);
    m_coefbuf = 0;
  }

  m_src.p.Data8u  = 0;
  m_src.width     = 0;
  m_src.height    = 0;
  m_src.nChannels = 0;
  m_src.lineStep  = 0;

  m_dst.pData     = 0;
  m_dst.DataLen   = 0;
  m_dst.currPos   = 0;

  m_jpeg_ncomp            = 0;
  m_jpeg_sampling         = JS_444;
  m_jpeg_color            = JC_UNKNOWN;
  m_jpeg_quality          = 100;
  m_jpeg_restart_interval = 0;
  m_jpeg_mode             = JPEG_BASELINE;

  m_numxMCU = 0;
  m_numyMCU = 0;
  m_mcuWidth  = 0;
  m_mcuHeight = 0;

  m_ccWidth  = 0;
  m_ccHeight = 0;
  m_xPadding = 0;
  m_yPadding = 0;

  m_restarts_to_go   = 0;
  m_next_restart_num = 0;

  m_scan_count = 0;

  m_state.Destroy();

  return JPEG_OK;
} // CJPEGEncoder::Clean()


JERRCODE CJPEGEncoder::SetSource(
  Ipp8u*   pSrc,
  int      srcStep,
  IppiSize srcSize,
  int      srcChannels,
  JCOLOR   srcColor)
{
  m_src.p.Data8u  = pSrc;
  m_src.lineStep  = srcStep;
  m_src.width     = srcSize.width;
  m_src.height    = srcSize.height;
  m_src.nChannels = srcChannels;
  m_src.color     = srcColor;

  return JPEG_OK;
} // CJPEGEncoder::SetSource()


JERRCODE CJPEGEncoder::SetDestination(
  Ipp8u* pDst,
  int    dstSize,
  int    dstQuality,
  JSS    dstSampling,
  JCOLOR dstColor,
  JMODE  dstMode,
  int    dstRestartInt)
{
  m_dst.pData   = pDst;
  m_dst.DataLen = dstSize;
  m_dst.currPos = 0;

  m_jpeg_quality          = dstQuality;
  m_jpeg_sampling         = dstSampling;
  m_jpeg_color            = dstColor;
  m_jpeg_mode             = dstMode;
  m_jpeg_restart_interval = dstRestartInt;

  m_restarts_to_go = m_jpeg_restart_interval;

  if(JPEG_LOSSLESS == m_jpeg_mode)
  {
    m_mcuWidth  = 1;
    m_mcuHeight = 1;
  }
  else
  {
    m_mcuWidth  = (m_jpeg_sampling == JS_444) ?  8 : 16;
    m_mcuHeight = (m_jpeg_sampling == JS_411) ? 16 :  8;
  }

  m_numxMCU = (m_src.width  + (m_mcuWidth  - 1)) / m_mcuWidth;
  m_numyMCU = (m_src.height + (m_mcuHeight - 1)) / m_mcuHeight;

  return JPEG_OK;
} // CJPEGEncoder::SetDestination()


JERRCODE CJPEGEncoder::WriteSOI(void)
{
  TRC0("-> WriteSOI");

  if(m_dst.currPos + 2 >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOI);

  m_dst._WRITE_WORD(0xff00 | JM_SOI);

  return JPEG_OK;
} // CJPEGEncoder::WriteSOI()


JERRCODE CJPEGEncoder::WriteEOI(void)
{
  TRC0("-> WriteEOI");

  if(m_dst.currPos + 2 >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("emit marker ",JM_EOI);

  m_dst._WRITE_WORD(0xff00 | JM_EOI);

  return JPEG_OK;
} // CJPEGEncoder::WriteEOI()


JERRCODE CJPEGEncoder::WriteAPP0(void)
{
  int len;

  TRC0("-> WriteAPP0");

  len = 2 + 5 + 2 + 1 + 2 + 2 + 1 + 1;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_APP0);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_APP0);
  m_dst._WRITE_WORD(len);

  // identificator JFIF
  m_dst._WRITE_BYTE('J');
  m_dst._WRITE_BYTE('F');
  m_dst._WRITE_BYTE('I');
  m_dst._WRITE_BYTE('F');
  m_dst._WRITE_BYTE(0);

  // version
  m_dst._WRITE_WORD(0x0102);

  // units: 0 - none, 1 - dot per inch, 2 - dot per cm
  m_dst._WRITE_BYTE(0);

  // xDensity
  m_dst._WRITE_WORD(1);

  // yDensity
  m_dst._WRITE_WORD(1);

  // xThumbnails, yThumbnails
  m_dst._WRITE_BYTE(0);
  m_dst._WRITE_BYTE(0);

  return JPEG_OK;
} // CJPEGEncoder::WriteAPP0()


JERRCODE CJPEGEncoder::WriteAPP14(void)
{
  int len;

  TRC0("-> WriteAPP14");

  len = 2 + 5 + 2 + 2 + 2 + 1;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_APP14);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_APP14);
  m_dst._WRITE_WORD(len);

  // identificator Adobe
  m_dst._WRITE_BYTE('A');
  m_dst._WRITE_BYTE('d');
  m_dst._WRITE_BYTE('o');
  m_dst._WRITE_BYTE('b');
  m_dst._WRITE_BYTE('e');

  // version
  m_dst._WRITE_WORD(100);

  // Flags 0
  m_dst._WRITE_WORD(0);

  // Flags 1
  m_dst._WRITE_WORD(0);

  switch(m_jpeg_color)
  {
  case JC_YCBCR:
    m_dst._WRITE_BYTE(1);
    break;
  case JC_YCCK:
    m_dst._WRITE_BYTE(2);
    break;
  default:
    m_dst._WRITE_BYTE(0);
    break;
  }

  return JPEG_OK;
} // CJPEGEncoder::WriteAPP14()


JERRCODE CJPEGEncoder::WriteCOM(
  char*  comment)
{
  int   len;
  char* ptr;

  TRC0("-> WriteCOM");

  if(comment != 0)
  {
    len = (int)strlen(comment) + 1;
    ptr = comment;
  }
  else
  {
    char buf[64];
    ptr = &buf[0];
    const IppLibraryVersion* jv = ippjGetLibVersion();
    sprintf(ptr,"JPEG encoder based on ippJP [%d.%d.%d] - %s",
      jv->major,
      jv->minor,
      jv->build,
      jv->BuildDate);

    len = (int)strlen(ptr) + 1;
  }

  len += 2;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_COM);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_COM);
  m_dst._WRITE_WORD(len);

  for(int i = 0; i < len - 2; i++)
  {
    m_dst._WRITE_BYTE(ptr[i]);
  }

  return JPEG_OK;
} // CJPEGEncoder::WriteCOM()


JERRCODE CJPEGEncoder::WriteDQT(
  CJPEGEncoderQuantTable* qtbl)
{
  int i;
  int len;

  TRC0("-> WriteDQT");

  len = DCTSIZE2 + 2 + 1;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_DQT);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_DQT);
  m_dst._WRITE_WORD(len);

  // precision/id
  m_dst._WRITE_BYTE((qtbl->m_precision << 4) | qtbl->m_id);

  TRC1("  id ",qtbl->m_id);
  TRC1("  precision ",qtbl->m_precision);

  TRC(endl);
  for(i = 0; i < DCTSIZE2; i++)
  {
    TRC(" ");
    TRC((int)qtbl->m_raw[i]);
    if(i % 8 == 7)
    {
      TRC(endl);
    }
  }
  TRC(endl);

  for(i = 0; i < DCTSIZE2; i++)
  {
    m_dst._WRITE_BYTE(qtbl->m_raw[i]);
  }

  return JPEG_OK;
} // CJPEGEncoder::WriteDQT()


JERRCODE CJPEGEncoder::WriteDHT(
  CJPEGEncoderHuffmanTable* htbl)
{
  int i;
  int len;
  int htbl_len;

  TRC0("-> WriteDHT");

  for(htbl_len = 0, i = 0; i < 16; i++)
  {
    htbl_len += htbl->m_bits[i];
  }

  len = 16 + htbl_len + 2 + 1;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_DHT);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_DHT);
  m_dst._WRITE_WORD(len);

  m_dst._WRITE_BYTE((htbl->m_hclass << 4) | htbl->m_id);

  TRC1("  id ",htbl->m_id);
  TRC1("  class ",htbl->m_hclass);

  for(i = 0; i < 16; i++)
  {
    m_dst._WRITE_BYTE(htbl->m_bits[i]);
  }

  for(i = 0; i < htbl_len; i++)
  {
    m_dst._WRITE_BYTE(htbl->m_vals[i]);
  }

  return JPEG_OK;
} // CJPEGEncoder::WriteDHT()


JERRCODE CJPEGEncoder::WriteSOF0(void)
{
  int len;

  TRC0("-> WriteSOF0");

  len = 8 + m_jpeg_ncomp * 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOF0);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_SOF0);
  m_dst._WRITE_WORD(len);

  // sample precision
  m_dst._WRITE_BYTE(8);

  m_dst._WRITE_WORD(m_src.height);
  m_dst._WRITE_WORD(m_src.width);

  m_dst._WRITE_BYTE(m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    m_dst._WRITE_BYTE(i);
    m_dst._WRITE_BYTE((m_ccomp[i]->m_hsampling << 4) | m_ccomp[i]->m_vsampling);
    m_dst._WRITE_BYTE(m_ccomp[i]->m_q_selector);
  }

  return JPEG_OK;
} // CJPEGEncoder::WriteSOF0()


JERRCODE CJPEGEncoder::WriteSOF1(void)
{
  int len;

  TRC0("-> WriteSOF1");

  len = 8 + m_jpeg_ncomp * 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOF1);
  TRC1("    length ",sof1_len);

  m_dst._WRITE_WORD(0xff00 | JM_SOF1);
  m_dst._WRITE_WORD(len);

  // sample precision
  m_dst._WRITE_BYTE(8);