view release on metacpan or  search on metacpan

zxing.xs  view on Meta::CPAN

    i_addcolors(img, &m_fg, 1);
    std::vector<i_palidx> row;
    row.resize(matrix.width());
    for (i_img_dim y = 0; y < matrix.height(); ++y) {
      auto out = begin(row);
      for (i_img_dim x = 0; x < matrix.width(); ++x) {
        *out++ = matrix.get(x, y) ? 1 : 0;
      }
      assert(out == row.end());
      i_ppal(img, 0, matrix.width(), y, row.data());
    }

    return img;
  }
};

#define Q_(x) #x
#define Q(x) Q_(x)

#define zx_version() \
  Q(ZXING_VERSION_MAJOR) "." Q(ZXING_VERSION_MINOR) "." Q(ZXING_VERSION_PATCH)

enum bool_options {
  bo_tryHarder = 1,
  bo_tryDownscale,
  bo_isPure,
  bo_tryCode39ExtendedMode,
  bo_validateCode39CheckSum,
  bo_validateITFCheckSum,
  bo_returnCodabarStartEnd,
  bo_returnErrors,
  bo_tryRotate,
  bo_tryInvert
};

DEFINE_IMAGER_CALLBACKS;

MODULE = Imager::zxing PACKAGE = Imager::zxing PREFIX=zx_
PROTOTYPES: DISABLE

const char *
zx_version(...)
  C_ARGS:

MODULE = Imager::zxing PACKAGE = Imager::zxing::Decoder PREFIX=ZXingDecoder::

ZXingDecoder *
ZXingDecoder::new()

void
ZXingDecoder::DESTROY()

std_string
ZXingDecoder::formats() const

bool
ZXingDecoder::setFormats(std_string formats)

void
ZXingDecoder::decode(Imager im) const
  PPCODE:
    auto results = THIS->decode(im);
    EXTEND(SP, results.size());
    for (auto &&r : results) {
      auto pr = new ZXingDecoderResult(std::move(r));
      SV *sv_r = sv_newmortal();
      sv_setref_pv(sv_r, "Imager::zxing::Decoder::Result", pr);
      PUSHs(sv_r);
    }

std_string
ZXingDecoder::error() const

static void
ZXingDecoder::availFormats()
  PPCODE:
    const auto &v = ZXingDecoder::availFormats();
    EXTEND(SP, v.size());
    for (auto &f : v) {
      PUSHs(string_to_SV(f, SVs_TEMP));
    }

void
ZXingDecoder::setTryHarder(bool val)
  ALIAS:
    setTryHarder = bo_tryHarder
    setTryDownscale = bo_tryDownscale
    setIsPure = bo_isPure
    setTryCode39ExtendedMode = bo_tryCode39ExtendedMode
    setValidateCode39CheckSum = bo_validateCode39CheckSum
    setValidateITFCheckSum = bo_validateITFCheckSum
    setReturnCodabarStartEnd = bo_returnCodabarStartEnd
    setReturnErrors = bo_returnErrors
    setTryRotate = bo_tryRotate
    setTryInvert = bo_tryInvert
  CODE:
    switch (static_cast<bool_options>(ix)) {
    case bo_tryHarder:
      THIS->hints.setTryHarder(val);
      break;
    case bo_tryDownscale:
      THIS->hints.setTryDownscale(val);
      break;
    case bo_isPure:
      THIS->hints.setIsPure(val);
      break;
    case bo_tryCode39ExtendedMode:
      THIS->hints.setTryCode39ExtendedMode(val);
      break;
    case bo_validateCode39CheckSum:
      THIS->hints.setValidateCode39CheckSum(val);
      break;
    case bo_validateITFCheckSum:
      THIS->hints.setValidateITFCheckSum(val);
      break;
    case bo_returnCodabarStartEnd:
      THIS->hints.setReturnCodabarStartEnd(val);
      break;
    case bo_returnErrors:
      THIS->hints.setReturnErrors(val);
      break;
    case bo_tryRotate:
      THIS->hints.setTryRotate(val);
      break;
    case bo_tryInvert:
#if ZXING_VERSION_MAJOR >= 2
      THIS->hints.setTryInvert(val);
#else
      Perl_croak(aTHX_ "setTryInvert requires zxing-cpp 2.0.0 or later");
#endif
      break;
    }

bool
ZXingDecoder::tryHarder()
  ALIAS:

zxing.xs  view on Meta::CPAN

      break;
    case bo_tryDownscale:
      RETVAL = THIS->hints.tryDownscale();
      break;
    case bo_isPure:
      RETVAL = THIS->hints.isPure();
      break;
    case bo_tryCode39ExtendedMode:
      RETVAL = THIS->hints.tryCode39ExtendedMode();
      break;
    case bo_validateCode39CheckSum:
      RETVAL = THIS->hints.validateCode39CheckSum();
      break;
    case bo_validateITFCheckSum:
      RETVAL = THIS->hints.validateITFCheckSum();
      break;
    case bo_returnCodabarStartEnd:
      RETVAL = THIS->hints.returnCodabarStartEnd();
      break;
    case bo_returnErrors:
      RETVAL = THIS->hints.returnErrors();
      break;
    case bo_tryRotate:
      RETVAL = THIS->hints.tryRotate();
      break;
    case bo_tryInvert:
#if ZXING_VERSION_MAJOR >= 2
      RETVAL = THIS->hints.tryInvert();
#else
      Perl_croak(aTHX_ "try_invert requires zxing-cpp 2.0.0 or later");
#endif
      break;
    }
  OUTPUT: RETVAL

MODULE = Imager::zxing PACKAGE = Imager::zxing::Decoder::Result PREFIX = ZXingDecoderResult::

std_string
ZXingDecoderResult::text() const

void
ZXingDecoderResult::DESTROY()

bool
ZXingDecoderResult::isValid() const

bool
ZXingDecoderResult::isMirrored() const

bool
ZXingDecoderResult::isInverted() const

std_string
ZXingDecoderResult::format() const

std_string
ZXingDecoderResult::contentType() const

void
ZXingDecoderResult::position() const
  PPCODE:
    auto pos = THIS->position();
    EXTEND(SP, 8);
    for (auto &f : pos) {
      PUSHs(sv_2mortal(newSViv(f.x)));
      PUSHs(sv_2mortal(newSViv(f.y)));
    }

int
ZXingDecoderResult::orientation() const

MODULE = Imager::zxing PACKAGE = Imager::zxing::Encoder PREFIX = ZXingEncoder::

ZXingEncoder *
ZXingEncoder::new(BarcodeFormat fmt)

void
ZXingEncoder::DESTROY()

void
ZXingEncoder::setEccLevel(int level)

void
ZXingEncoder::setIsBytes(bool is_bytes)

void
ZXingEncoder::setHasQuietZone(bool has_qz)

void
ZXingEncoder::setFormat(ImagerFormat fmt)

void
ZXingEncoder::setForeground_(Imager::Color c)
  C_ARGS: *c

void
ZXingEncoder::setBackground_(Imager::Color c)
  C_ARGS: *c

Imager
ZXingEncoder::encode_(SV *text_sv, int width, int height) const
  CODE:
    std::string_view text = SV_to_utf8_bytes_string_view(aTHX_ text_sv, THIS->isBytes());
    RETVAL = THIS->encode(text, width, height);
    if (!RETVAL)
      XSRETURN_EMPTY;
    OUTPUT : RETVAL

static void
ZXingEncoder::availFormats()
  PPCODE:
    const auto &v = ZXingEncoder::availFormats();
    EXTEND(SP, v.size());
    for (auto &f : v) {
      PUSHs(string_to_SV(f, SVs_TEMP));
    }
    

BOOT:
        PERL_INITIALIZE_IMAGER_CALLBACKS;