rhodes 3.0.2 → 3.1.0.beta.1

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/qrcode/binarize.h

@@ -1,17 +0,0 @@
-/*Copyright (C) 2008-2009  Timothy B. Terriberry (tterribe@xiph.org)
-  You can redistribute this library and/or modify it under the terms of the
-   GNU Lesser General Public License as published by the Free Software
-   Foundation; either version 2.1 of the License, or (at your option) any later
-   version.*/
-#if !defined(_qrcode_binarize_H)
-# define _qrcode_binarize_H (1)
-
-void qr_image_cross_masking_median_filter(unsigned char *_img,
- int _width,int _height);
-
-void qr_wiener_filter(unsigned char *_img,int _width,int _height);
-
-/*Binarizes a grayscale image.*/
-unsigned char *qr_binarize(const unsigned char *_img,int _width,int _height);
-
-#endif

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/qrcode/isaac.c

@@ -1,139 +0,0 @@
-/*Written by Timothy B. Terriberry (tterribe@xiph.org) 1999-2009 public domain.
-  Based on the public domain implementation by Robert J. Jenkins Jr.*/
-#include <float.h>
-#include <math.h>
-#include <string.h>
-#include "isaac.h"
-
-
-
-#define ISAAC_MASK        (0xFFFFFFFFU)
-
-
-
-static void isaac_update(isaac_ctx *_ctx){
-  unsigned *m;
-  unsigned *r;
-  unsigned  a;
-  unsigned  b;
-  unsigned  x;
-  unsigned  y;
-  int       i;
-  m=_ctx->m;
-  r=_ctx->r;
-  a=_ctx->a;
-  b=_ctx->b+(++_ctx->c)&ISAAC_MASK;
-  for(i=0;i<ISAAC_SZ/2;i++){
-    x=m[i];
-    a=(a^a<<13)+m[i+ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a>>6)+m[i+ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a<<2)+m[i+ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a>>16)+m[i+ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-  }
-  for(i=ISAAC_SZ/2;i<ISAAC_SZ;i++){
-    x=m[i];
-    a=(a^a<<13)+m[i-ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a>>6)+m[i-ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a<<2)+m[i-ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-    x=m[++i];
-    a=(a^a>>16)+m[i-ISAAC_SZ/2]&ISAAC_MASK;
-    m[i]=y=m[(x&ISAAC_SZ-1<<2)>>2]+a+b&ISAAC_MASK;
-    r[i]=b=m[y>>ISAAC_SZ_LOG+2&ISAAC_SZ-1]+x&ISAAC_MASK;
-  }
-  _ctx->b=b;
-  _ctx->a=a;
-  _ctx->n=ISAAC_SZ;
-}
-
-static void isaac_mix(unsigned _x[8]){
-  static const unsigned char SHIFT[8]={11,2,8,16,10,4,8,9};
-  int i;
-  for(i=0;i<8;i++){
-    _x[i]^=_x[i+1&7]<<SHIFT[i];
-    _x[i+3&7]+=_x[i];
-    _x[i+1&7]+=_x[i+2&7];
-    i++;
-    _x[i]^=_x[i+1&7]>>SHIFT[i];
-    _x[i+3&7]+=_x[i];
-    _x[i+1&7]+=_x[i+2&7];
-  }
-}
-
-
-void isaac_init(isaac_ctx *_ctx,const void *_seed,int _nseed){
-  const unsigned char *seed;
-  unsigned            *m;
-  unsigned            *r;
-  unsigned             x[8];
-  int                  i;
-  int                  j;
-  _ctx->a=_ctx->b=_ctx->c=0;
-  m=_ctx->m;
-  r=_ctx->r;
-  x[0]=x[1]=x[2]=x[3]=x[4]=x[5]=x[6]=x[7]=0x9E3779B9;
-  for(i=0;i<4;i++)isaac_mix(x);
-  if(_nseed>ISAAC_SEED_SZ_MAX)_nseed=ISAAC_SEED_SZ_MAX;
-  seed=(const unsigned char *)_seed;
-  for(i=0;i<_nseed>>2;i++){
-    r[i]=seed[i<<2|3]<<24|seed[i<<2|2]<<16|seed[i<<2|1]<<8|seed[i<<2];
-  }
-  if(_nseed&3){
-    r[i]=seed[i<<2];
-    for(j=1;j<(_nseed&3);j++)r[i]+=seed[i<<2|j]<<(j<<3);
-    i++;
-  }
-  memset(r+i,0,(ISAAC_SZ-i)*sizeof(*r));
-  for(i=0;i<ISAAC_SZ;i+=8){
-    for(j=0;j<8;j++)x[j]+=r[i+j];
-    isaac_mix(x);
-    memcpy(m+i,x,sizeof(x));
-  }
-  for(i=0;i<ISAAC_SZ;i+=8){
-    for(j=0;j<8;j++)x[j]+=m[i+j];
-    isaac_mix(x);
-    memcpy(m+i,x,sizeof(x));
-  }
-  isaac_update(_ctx);
-}
-
-unsigned isaac_next_uint32(isaac_ctx *_ctx){
-  if(!_ctx->n)isaac_update(_ctx);
-  return _ctx->r[--_ctx->n];
-}
-
-/*Returns a uniform random integer less than the given maximum value.
-  _n: The upper bound on the range of numbers returned (not inclusive).
-      This must be strictly less than 2**32.
-  Return: An integer uniformly distributed between 0 (inclusive) and _n
-           (exclusive).*/
-unsigned isaac_next_uint(isaac_ctx *_ctx,unsigned _n){
-  unsigned r;
-  unsigned v;
-  unsigned d;
-  do{
-    r=isaac_next_uint32(_ctx);
-    v=r%_n;
-    d=r-v;
-  }
-  while((d+_n-1&ISAAC_MASK)<d);
-  return v;
-}

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/qrcode/isaac.h

@@ -1,41 +0,0 @@
-/*Written by Timothy B. Terriberry (tterribe@xiph.org) 1999-2009 public domain.
-  Based on the public domain implementation by Robert J. Jenkins Jr.*/
-#if !defined(_isaac_H)
-# define _isaac_H (1)
-
-
-
-typedef struct isaac_ctx isaac_ctx;
-
-
-
-#define ISAAC_SZ_LOG      (8)
-#define ISAAC_SZ          (1<<ISAAC_SZ_LOG)
-#define ISAAC_SEED_SZ_MAX (ISAAC_SZ<<2)
-
-
-
-/*ISAAC is the most advanced of a series of Pseudo-Random Number Generators
-   designed by Robert J. Jenkins Jr. in 1996.
-  http://www.burtleburtle.net/bob/rand/isaac.html
-  To quote:
-    No efficient method is known for deducing their internal states.
-    ISAAC requires an amortized 18.75 instructions to produce a 32-bit value.
-    There are no cycles in ISAAC shorter than 2**40 values.
-    The expected cycle length is 2**8295 values.*/
-struct isaac_ctx{
-  unsigned n;
-  unsigned r[ISAAC_SZ];
-  unsigned m[ISAAC_SZ];
-  unsigned a;
-  unsigned b;
-  unsigned c;
-};
-
-
-void isaac_init(isaac_ctx *_ctx,const void *_seed,int _nseed);
-
-unsigned isaac_next_uint32(isaac_ctx *_ctx);
-unsigned isaac_next_uint(isaac_ctx *_ctx,unsigned _n);
-
-#endif

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/qrcode/qrdec.c

@@ -1,3957 +0,0 @@
-/*Copyright (C) 2008-2009  Timothy B. Terriberry (tterribe@xiph.org)
-  You can redistribute this library and/or modify it under the terms of the
-   GNU Lesser General Public License as published by the Free Software
-   Foundation; either version 2.1 of the License, or (at your option) any later
-   version.*/
-#include <config.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-#include <time.h>
-#include "qrcode.h"
-#include "qrdec.h"
-#include "bch15_5.h"
-#include "rs.h"
-#include "isaac.h"
-#include "util.h"
-#include "binarize.h"
-#include "image.h"
-#include "error.h"
-#include "svg.h"
-
-typedef int qr_line[3];
-
-typedef struct qr_finder_cluster qr_finder_cluster;
-typedef struct qr_finder_edge_pt  qr_finder_edge_pt;
-typedef struct qr_finder_center   qr_finder_center;
-
-typedef struct qr_aff qr_aff;
-typedef struct qr_hom qr_hom;
-
-typedef struct qr_finder qr_finder;
-
-typedef struct qr_hom_cell      qr_hom_cell;
-typedef struct qr_sampling_grid qr_sampling_grid;
-typedef struct qr_pack_buf      qr_pack_buf;
-
-/*The number of bits in an int.
-  Note the cast to (int): this prevents this value from "promoting" whole
-   expressions to an (unsigned) size_t.*/
-#define QR_INT_BITS    ((int)sizeof(int)*CHAR_BIT)
-#define QR_INT_LOGBITS (QR_ILOG(QR_INT_BITS))
-
-/*A 14 bit resolution for a homography ensures that the ideal module size for a
-   version 40 code differs from that of a version 39 code by at least 2.*/
-#define QR_HOM_BITS (14)
-
-/*The number of bits of sub-module precision to use when searching for
-   alignment patterns.
-  Two bits allows an alignment pattern to be found even if the modules have
-   been eroded by up to 50% (due to blurring, etc.).
-  This must be at least one, since it affects the dynamic range of the
-   transforms, and we sample at half-module resolution to compute a bounding
-   quadrilateral for the code.*/
-#define QR_ALIGN_SUBPREC (2)
-
-
-/* collection of finder lines */
-typedef struct qr_finder_lines {
-    qr_finder_line *lines;
-    int nlines, clines;
-} qr_finder_lines;
-
-
-struct qr_reader {
-    /*The GF(256) representation used in Reed-Solomon decoding.*/
-    rs_gf256  gf;
-    /*The random number generator used by RANSAC.*/
-    isaac_ctx isaac;
-    /* current finder state, horizontal and vertical lines */
-    qr_finder_lines finder_lines[2];
-};
-
-
-/*Initializes a client reader handle.*/
-static void qr_reader_init (qr_reader *reader)
-{
-    /*time_t now;
-      now=time(NULL);
-      isaac_init(&_reader->isaac,&now,sizeof(now));*/
-    isaac_init(&reader->isaac, NULL, 0);
-    rs_gf256_init(&reader->gf, QR_PPOLY);
-}
-
-/*Allocates a client reader handle.*/
-qr_reader *_zbar_qr_create (void)
-{
-    qr_reader *reader = (qr_reader*)calloc(1, sizeof(*reader));
-    qr_reader_init(reader);
-    return(reader);
-}
-
-/*Frees a client reader handle.*/
-void _zbar_qr_destroy (qr_reader *reader)
-{
-    zprintf(1, "max finder lines = %dx%d\n",
-            reader->finder_lines[0].clines,
-            reader->finder_lines[1].clines);
-    if(reader->finder_lines[0].lines)
-        free(reader->finder_lines[0].lines);
-    if(reader->finder_lines[1].lines)
-        free(reader->finder_lines[1].lines);
-    free(reader);
-}
-
-/* reset finder state between scans */
-void _zbar_qr_reset (qr_reader *reader)
-{
-    reader->finder_lines[0].nlines = 0;
-    reader->finder_lines[1].nlines = 0;
-}
-
-
-/*A cluster of lines crossing a finder pattern (all in the same direction).*/
-struct qr_finder_cluster{
-  /*Pointers to the lines crossing the pattern.*/
-  qr_finder_line **lines;
-  /*The number of lines in the cluster.*/
-  int              nlines;
-};
-
-
-/*A point on the edge of a finder pattern.
-  These are obtained from the endpoints of the lines crossing this particular
-   pattern.*/
-struct qr_finder_edge_pt{
-  /*The location of the edge point.*/
-  qr_point pos;
-  /*A label classifying which edge this belongs to:
-    0: negative u edge (left)
-    1: positive u edge (right)
-    2: negative v edge (top)
-    3: positive v edge (bottom)*/
-  int      edge;
-  /*The (signed) perpendicular distance of the edge point from a line parallel
-     to the edge passing through the finder center, in (u,v) coordinates.
-    This is also re-used by RANSAC to store inlier flags.*/
-  int      extent;
-};
-
-
-/*The center of a finder pattern obtained from the crossing of one or more
-   clusters of horizontal finder lines with one or more clusters of vertical
-   finder lines.*/
-struct qr_finder_center{
-  /*The estimated location of the finder center.*/
-  qr_point           pos;
-  /*The list of edge points from the crossing lines.*/
-  qr_finder_edge_pt *edge_pts;
-  /*The number of edge points from the crossing lines.*/
-  int                nedge_pts;
-};
-
-
-static int qr_finder_vline_cmp(const void *_a,const void *_b){
-  const qr_finder_line *a;
-  const qr_finder_line *b;
-  a=(const qr_finder_line *)_a;
-  b=(const qr_finder_line *)_b;
-  return ((a->pos[0]>b->pos[0])-(a->pos[0]<b->pos[0])<<1)+
-   (a->pos[1]>b->pos[1])-(a->pos[1]<b->pos[1]);
-}
-
-/*Clusters adjacent lines into groups that are large enough to be crossing a
-   finder pattern (relative to their length).
-  _clusters:  The buffer in which to store the clusters found.
-  _neighbors: The buffer used to store the lists of lines in each cluster.
-  _lines:     The list of lines to cluster.
-              Horizontal lines must be sorted in ascending order by Y
-               coordinate, with ties broken by X coordinate.
-              Vertical lines must be sorted in ascending order by X coordinate,
-               with ties broken by Y coordinate.
-  _nlines:    The number of lines in the set of lines to cluster.
-  _v:         0 for horizontal lines, or 1 for vertical lines.
-  Return: The number of clusters.*/
-static int qr_finder_cluster_lines(qr_finder_cluster *_clusters,
- qr_finder_line **_neighbors,qr_finder_line *_lines,int _nlines,int _v){
-  unsigned char   *mark;
-  qr_finder_line **neighbors;
-  int              nneighbors;
-  int              nclusters;
-  int              i;
-  /*TODO: Kalman filters!*/
-  mark=(unsigned char *)calloc(_nlines,sizeof(*mark));
-  neighbors=_neighbors;
-  nclusters=0;
-  for(i=0;i<_nlines-1;i++)if(!mark[i]){
-    int len;
-    int j;
-    nneighbors=1;
-    neighbors[0]=_lines+i;
-    len=_lines[i].len;
-    for(j=i+1;j<_nlines;j++)if(!mark[j]){
-      const qr_finder_line *a;
-      const qr_finder_line *b;
-      int                   thresh;
-      a=neighbors[nneighbors-1];
-      b=_lines+j;
-      /*The clustering threshold is proportional to the size of the lines,
-         since minor noise in large areas can interrupt patterns more easily
-         at high resolutions.*/
-      thresh=a->len+7>>2;
-      if(abs(a->pos[1-_v]-b->pos[1-_v])>thresh)break;
-      if(abs(a->pos[_v]-b->pos[_v])>thresh)continue;
-      if(abs(a->pos[_v]+a->len-b->pos[_v]-b->len)>thresh)continue;
-      if(a->boffs>0&&b->boffs>0&&
-       abs(a->pos[_v]-a->boffs-b->pos[_v]+b->boffs)>thresh){
-        continue;
-      }
-      if(a->eoffs>0&&b->eoffs>0&&
-       abs(a->pos[_v]+a->len+a->eoffs-b->pos[_v]-b->len-b->eoffs)>thresh){
-        continue;
-      }
-      neighbors[nneighbors++]=_lines+j;
-      len+=b->len;
-    }
-    /*We require at least three lines to form a cluster, which eliminates a
-       large number of false positives, saving considerable decoding time.
-      This should still be sufficient for 1-pixel codes with no noise.*/
-    if(nneighbors<3)continue;
-    /*The expected number of lines crossing a finder pattern is equal to their
-       average length.
-      We accept the cluster if size is at least 1/3 their average length (this
-       is a very small threshold, but was needed for some test images).*/
-    len=((len<<1)+nneighbors)/(nneighbors<<1);
-    if(nneighbors*(5<<QR_FINDER_SUBPREC)>=len){
-      _clusters[nclusters].lines=neighbors;
-      _clusters[nclusters].nlines=nneighbors;
-      for(j=0;j<nneighbors;j++)mark[neighbors[j]-_lines]=1;
-      neighbors+=nneighbors;
-      nclusters++;
-    }
-  }
-  free(mark);
-  return nclusters;
-}
-
-/*Adds the coordinates of the edge points from the lines contained in the
-   given list of clusters to the list of edge points for a finder center.
-  Only the edge point position is initialized.
-  The edge label and extent are set by qr_finder_edge_pts_aff_classify()
-   or qr_finder_edge_pts_hom_classify().
-  _edge_pts:   The buffer in which to store the edge points.
-  _nedge_pts:  The current number of edge points in the buffer.
-  _neighbors:  The list of lines in the cluster.
-  _nneighbors: The number of lines in the list of lines in the cluster.
-  _v:          0 for horizontal lines and 1 for vertical lines.
-  Return: The new total number of edge points.*/
-static int qr_finder_edge_pts_fill(qr_finder_edge_pt *_edge_pts,int _nedge_pts,
- qr_finder_cluster **_neighbors,int _nneighbors,int _v){
-  int i;
-  for(i=0;i<_nneighbors;i++){
-    qr_finder_cluster *c;
-    int                j;
-    c=_neighbors[i];
-    for(j=0;j<c->nlines;j++){
-      qr_finder_line *l;
-      l=c->lines[j];
-      if(l->boffs>0){
-        _edge_pts[_nedge_pts].pos[0]=l->pos[0];
-        _edge_pts[_nedge_pts].pos[1]=l->pos[1];
-        _edge_pts[_nedge_pts].pos[_v]-=l->boffs;
-        _nedge_pts++;
-      }
-      if(l->eoffs>0){
-        _edge_pts[_nedge_pts].pos[0]=l->pos[0];
-        _edge_pts[_nedge_pts].pos[1]=l->pos[1];
-        _edge_pts[_nedge_pts].pos[_v]+=l->len+l->eoffs;
-        _nedge_pts++;
-      }
-    }
-  }
-  return _nedge_pts;
-}
-
-static int qr_finder_center_cmp(const void *_a,const void *_b){
-  const qr_finder_center *a;
-  const qr_finder_center *b;
-  a=(const qr_finder_center *)_a;
-  b=(const qr_finder_center *)_b;
-  return ((b->nedge_pts>a->nedge_pts)-(b->nedge_pts<a->nedge_pts)<<2)+
-   ((a->pos[1]>b->pos[1])-(a->pos[1]<b->pos[1])<<1)+
-   (a->pos[0]>b->pos[0])-(a->pos[0]<b->pos[0]);
-}
-
-/*Determine if a horizontal line crosses a vertical line.
-  _hline: The horizontal line.
-  _vline: The vertical line.
-  Return: A non-zero value if the lines cross, or zero if they do not.*/
-static int qr_finder_lines_are_crossing(const qr_finder_line *_hline,
- const qr_finder_line *_vline){
-  return
-   _hline->pos[0]<=_vline->pos[0]&&_vline->pos[0]<_hline->pos[0]+_hline->len&&
-   _vline->pos[1]<=_hline->pos[1]&&_hline->pos[1]<_vline->pos[1]+_vline->len;
-}
-
-/*Finds horizontal clusters that cross corresponding vertical clusters,
-   presumably corresponding to a finder center.
-  _center:     The buffer in which to store putative finder centers.
-  _edge_pts:   The buffer to use for the edge point lists for each finder
-                center.
-  _hclusters:  The clusters of horizontal lines crossing finder patterns.
-  _nhclusters: The number of horizontal line clusters.
-  _vclusters:  The clusters of vertical lines crossing finder patterns.
-  _nvclusters: The number of vertical line clusters.
-  Return: The number of putative finder centers.*/
-static int qr_finder_find_crossings(qr_finder_center *_centers,
- qr_finder_edge_pt *_edge_pts,qr_finder_cluster *_hclusters,int _nhclusters,
- qr_finder_cluster *_vclusters,int _nvclusters){
-  qr_finder_cluster **hneighbors;
-  qr_finder_cluster **vneighbors;
-  unsigned char      *hmark;
-  unsigned char      *vmark;
-  int                 ncenters;
-  int                 i;
-  int                 j;
-  hneighbors=(qr_finder_cluster **)malloc(_nhclusters*sizeof(*hneighbors));
-  vneighbors=(qr_finder_cluster **)malloc(_nvclusters*sizeof(*vneighbors));
-  hmark=(unsigned char *)calloc(_nhclusters,sizeof(*hmark));
-  vmark=(unsigned char *)calloc(_nvclusters,sizeof(*vmark));
-  ncenters=0;
-  /*TODO: This may need some re-working.
-    We should be finding groups of clusters such that _all_ horizontal lines in
-     _all_ horizontal clusters in the group cross _all_ vertical lines in _all_
-     vertical clusters in the group.
-    This is equivalent to finding the maximum bipartite clique in the
-     connectivity graph, which requires linear progamming to solve efficiently.
-    In principle, that is easy to do, but a realistic implementation without
-     floating point is a lot of work (and computationally expensive).
-    Right now we are relying on a sufficient border around the finder patterns
-     to prevent false positives.*/
-  for(i=0;i<_nhclusters;i++)if(!hmark[i]){
-    qr_finder_line *a;
-    qr_finder_line *b;
-    int             nvneighbors;
-    int             nedge_pts;
-    int             y;
-    a=_hclusters[i].lines[_hclusters[i].nlines>>1];
-    y=nvneighbors=0;
-    for(j=0;j<_nvclusters;j++)if(!vmark[j]){
-      b=_vclusters[j].lines[_vclusters[j].nlines>>1];
-      if(qr_finder_lines_are_crossing(a,b)){
-        vmark[j]=1;
-        y+=(b->pos[1]<<1)+b->len;
-        if(b->boffs>0&&b->eoffs>0)y+=b->eoffs-b->boffs;
-        vneighbors[nvneighbors++]=_vclusters+j;
-      }
-    }
-    if(nvneighbors>0){
-      qr_finder_center *c;
-      int               nhneighbors;
-      int               x;
-      x=(a->pos[0]<<1)+a->len;
-      if(a->boffs>0&&a->eoffs>0)x+=a->eoffs-a->boffs;
-      hneighbors[0]=_hclusters+i;
-      nhneighbors=1;
-      j=nvneighbors>>1;
-      b=vneighbors[j]->lines[vneighbors[j]->nlines>>1];
-      for(j=i+1;j<_nhclusters;j++)if(!hmark[j]){
-        a=_hclusters[j].lines[_hclusters[j].nlines>>1];
-        if(qr_finder_lines_are_crossing(a,b)){
-          hmark[j]=1;
-          x+=(a->pos[0]<<1)+a->len;
-          if(a->boffs>0&&a->eoffs>0)x+=a->eoffs-a->boffs;
-          hneighbors[nhneighbors++]=_hclusters+j;
-        }
-      }
-      c=_centers+ncenters++;
-      c->pos[0]=(x+nhneighbors)/(nhneighbors<<1);
-      c->pos[1]=(y+nvneighbors)/(nvneighbors<<1);
-      c->edge_pts=_edge_pts;
-      nedge_pts=qr_finder_edge_pts_fill(_edge_pts,0,
-       hneighbors,nhneighbors,0);
-      nedge_pts=qr_finder_edge_pts_fill(_edge_pts,nedge_pts,
-       vneighbors,nvneighbors,1);
-      c->nedge_pts=nedge_pts;
-      _edge_pts+=nedge_pts;
-    }
-  }
-  free(vmark);
-  free(hmark);
-  free(vneighbors);
-  free(hneighbors);
-  /*Sort the centers by decreasing numbers of edge points.*/
-  qsort(_centers,ncenters,sizeof(*_centers),qr_finder_center_cmp);
-  return ncenters;
-}
-
-/*Locates a set of putative finder centers in the image.
-  First we search for horizontal and vertical lines that have
-   (dark:light:dark:light:dark) runs with size ratios of roughly (1:1:3:1:1).
-  Then we cluster them into groups such that each subsequent pair of endpoints
-   is close to the line before it in the cluster.
-  This will locate many line clusters that don't cross a finder pattern, but
-   qr_finder_find_crossings() will filter most of them out.
-  Where horizontal and vertical clusters cross, a prospective finder center is
-   returned.
-  _centers:  Returns a pointer to a freshly-allocated list of finder centers.
-             This must be freed by the caller.
-  _edge_pts: Returns a pointer to a freshly-allocated list of edge points
-              around those centers.
-             This must be freed by the caller.
-  _img:      The binary image to search.
-  _width:    The width of the image.
-  _height:   The height of the image.
-  Return: The number of putative finder centers located.*/
-static int qr_finder_centers_locate(qr_finder_center **_centers,
- qr_finder_edge_pt **_edge_pts, qr_reader *reader,
- int _width,int _height){
-  qr_finder_line     *hlines = reader->finder_lines[0].lines;
-  int                 nhlines = reader->finder_lines[0].nlines;
-  qr_finder_line     *vlines = reader->finder_lines[1].lines;
-  int                 nvlines = reader->finder_lines[1].nlines;
-
-  qr_finder_line    **hneighbors;
-  qr_finder_cluster  *hclusters;
-  int                 nhclusters;
-  qr_finder_line    **vneighbors;
-  qr_finder_cluster  *vclusters;
-  int                 nvclusters;
-  int                 ncenters;
-
-  /*Cluster the detected lines.*/
-  hneighbors=(qr_finder_line **)malloc(nhlines*sizeof(*hneighbors));
-  /*We require more than one line per cluster, so there are at most nhlines/2.*/
-  hclusters=(qr_finder_cluster *)malloc((nhlines>>1)*sizeof(*hclusters));
-  nhclusters=qr_finder_cluster_lines(hclusters,hneighbors,hlines,nhlines,0);
-  /*We need vertical lines to be sorted by X coordinate, with ties broken by Y
-     coordinate, for clustering purposes.
-    We scan the image in the opposite order for cache efficiency, so sort the
-     lines we found here.*/
-  qsort(vlines,nvlines,sizeof(*vlines),qr_finder_vline_cmp);
-  vneighbors=(qr_finder_line **)malloc(nvlines*sizeof(*vneighbors));
-  /*We require more than one line per cluster, so there are at most nvlines/2.*/
-  vclusters=(qr_finder_cluster *)malloc((nvlines>>1)*sizeof(*vclusters));
-  nvclusters=qr_finder_cluster_lines(vclusters,vneighbors,vlines,nvlines,1);
-  /*Find line crossings among the clusters.*/
-  if(nhclusters>=3&&nvclusters>=3){
-    qr_finder_edge_pt  *edge_pts;
-    qr_finder_center   *centers;
-    int                 nedge_pts;
-    int                 i;
-    nedge_pts=0;
-    for(i=0;i<nhclusters;i++)nedge_pts+=hclusters[i].nlines;
-    for(i=0;i<nvclusters;i++)nedge_pts+=vclusters[i].nlines;
-    nedge_pts<<=1;
-    edge_pts=(qr_finder_edge_pt *)malloc(nedge_pts*sizeof(*edge_pts));
-    centers=(qr_finder_center *)malloc(
-     QR_MINI(nhclusters,nvclusters)*sizeof(*centers));
-    ncenters=qr_finder_find_crossings(centers,edge_pts,
-     hclusters,nhclusters,vclusters,nvclusters);
-    *_centers=centers;
-    *_edge_pts=edge_pts;
-  }
-  else ncenters=0;
-  free(vclusters);
-  free(vneighbors);
-  free(hclusters);
-  free(hneighbors);
-  return ncenters;
-}
-
-
-
-static void qr_point_translate(qr_point _point,int _dx,int _dy){
-  _point[0]+=_dx;
-  _point[1]+=_dy;
-}
-
-static unsigned qr_point_distance2(const qr_point _p1,const qr_point _p2){
-  return (_p1[0]-_p2[0])*(_p1[0]-_p2[0])+(_p1[1]-_p2[1])*(_p1[1]-_p2[1]);
-}
-
-/*Returns the cross product of the three points, which is positive if they are
-   in CCW order (in a right-handed coordinate system), and 0 if they're
-   colinear.*/
-static int qr_point_ccw(const qr_point _p0,
- const qr_point _p1,const qr_point _p2){
-  return (_p1[0]-_p0[0])*(_p2[1]-_p0[1])-(_p1[1]-_p0[1])*(_p2[0]-_p0[0]);
-}
-
-
-
-/*Evaluates a line equation at a point.
-  _line: The line to evaluate.
-  _x:    The X coordinate of the point.
-  _y:    The y coordinate of the point.
-  Return: The value of the line equation _line[0]*_x+_line[1]*_y+_line[2].*/
-static int qr_line_eval(qr_line _line,int _x,int _y){
-  return _line[0]*_x+_line[1]*_y+_line[2];
-}
-
-/*Computes a line passing through the given point using the specified second
-   order statistics.
-  Given a line defined by the equation
-    A*x+B*y+C = 0 ,
-   the least squares fit to n points (x_i,y_i) must satisfy the two equations
-    A^2 + (Syy - Sxx)/Sxy*A*B - B^2 = 0 ,
-    C = -(xbar*A+ybar*B) ,
-   where
-    xbar = sum(x_i)/n ,
-    ybar = sum(y_i)/n ,
-    Sxx = sum((x_i-xbar)**2) ,
-    Sxy = sum((x_i-xbar)*(y_i-ybar)) ,
-    Syy = sum((y_i-ybar)**2) .
-  The quadratic can be solved for the ratio (A/B) or (B/A):
-    A/B = (Syy + sqrt((Sxx-Syy)**2 + 4*Sxy**2) - Sxx)/(-2*Sxy) ,
-    B/A = (Sxx + sqrt((Sxx-Syy)**2 + 4*Sxy**2) - Syy)/(-2*Sxy) .
-  We pick the one that leads to the larger ratio to avoid destructive
-   cancellation (and e.g., 0/0 for horizontal or vertical lines).
-  The above solutions correspond to the actual minimum.
-  The other solution of the quadratic corresponds to a saddle point of the
-   least squares objective function.
-  _l:   Returns the fitted line values A, B, and C.
-  _x0:  The X coordinate of the point the line is supposed to pass through.
-  _y0:  The Y coordinate of the point the line is supposed to pass through.
-  _sxx: The sum Sxx.
-  _sxy: The sum Sxy.
-  _syy: The sum Syy.
-  _res: The maximum number of bits occupied by the product of any two of
-         _l[0] or _l[1].
-        Smaller numbers give less angular resolution, but allow more overhead
-         room for computations.*/
-static void qr_line_fit(qr_line _l,int _x0,int _y0,
- int _sxx,int _sxy,int _syy,int _res){
-  int dshift;
-  int dround;
-  int u;
-  int v;
-  int w;
-  u=abs(_sxx-_syy);
-  v=-_sxy<<1;
-  w=qr_ihypot(u,v);
-  /*Computations in later stages can easily overflow with moderate sizes, so we
-     compute a shift factor to scale things down into a managable range.
-    We ensure that the product of any two of _l[0] and _l[1] fits within _res
-     bits, which allows computation of line intersections without overflow.*/
-  dshift=QR_MAXI(0,QR_MAXI(qr_ilog(u),qr_ilog(abs(v)))+1-(_res+1>>1));
-  dround=(1<<dshift)>>1;
-  if(_sxx>_syy){
-    _l[0]=v+dround>>dshift;
-    _l[1]=u+w+dround>>dshift;
-  }
-  else{
-    _l[0]=u+w+dround>>dshift;
-    _l[1]=v+dround>>dshift;
-  }
-  _l[2]=-(_x0*_l[0]+_y0*_l[1]);
-}
-
-/*Perform a least-squares line fit to a list of points.
-  At least two points are required.*/
-static void qr_line_fit_points(qr_line _l,qr_point *_p,int _np,int _res){
-  int sx;
-  int sy;
-  int xmin;
-  int xmax;
-  int ymin;
-  int ymax;
-  int xbar;
-  int ybar;
-  int dx;
-  int dy;
-  int sxx;
-  int sxy;
-  int syy;
-  int sshift;
-  int sround;
-  int i;
-  sx=sy=0;
-  ymax=xmax=INT_MIN;
-  ymin=xmin=INT_MAX;
-  for(i=0;i<_np;i++){
-    sx+=_p[i][0];
-    xmin=QR_MINI(xmin,_p[i][0]);
-    xmax=QR_MAXI(xmax,_p[i][0]);
-    sy+=_p[i][1];
-    ymin=QR_MINI(ymin,_p[i][1]);
-    ymax=QR_MAXI(ymax,_p[i][1]);
-  }
-  xbar=(sx+(_np>>1))/_np;
-  ybar=(sy+(_np>>1))/_np;
-  sshift=QR_MAXI(0,qr_ilog(_np*QR_MAXI(QR_MAXI(xmax-xbar,xbar-xmin),
-   QR_MAXI(ymax-ybar,ybar-ymin)))-(QR_INT_BITS-1>>1));
-  sround=(1<<sshift)>>1;
-  sxx=sxy=syy=0;
-  for(i=0;i<_np;i++){
-    dx=_p[i][0]-xbar+sround>>sshift;
-    dy=_p[i][1]-ybar+sround>>sshift;
-    sxx+=dx*dx;
-    sxy+=dx*dy;
-    syy+=dy*dy;
-  }
-  qr_line_fit(_l,xbar,ybar,sxx,sxy,syy,_res);
-}
-
-static void qr_line_orient(qr_line _l,int _x,int _y){
-  if(qr_line_eval(_l,_x,_y)<0){
-    _l[0]=-_l[0];
-    _l[1]=-_l[1];
-    _l[2]=-_l[2];
-  }
-}
-
-static int qr_line_isect(qr_point _p,const qr_line _l0,const qr_line _l1){
-  int d;
-  int x;
-  int y;
-  d=_l0[0]*_l1[1]-_l0[1]*_l1[0];
-  if(d==0)return -1;
-  x=_l0[1]*_l1[2]-_l1[1]*_l0[2];
-  y=_l1[0]*_l0[2]-_l0[0]*_l1[2];
-  if(d<0){
-    x=-x;
-    y=-y;
-    d=-d;
-  }
-  _p[0]=QR_DIVROUND(x,d);
-  _p[1]=QR_DIVROUND(y,d);
-  return 0;
-}
-
-
-
-/*An affine homography.
-  This maps from the image (at subpel resolution) to a square domain with
-   power-of-two sides (of res bits) and back.*/
-struct qr_aff{
-  int fwd[2][2];
-  int inv[2][2];
-  int x0;
-  int y0;
-  int res;
-};
-
-
-static void qr_aff_init(qr_aff *_aff,
- const qr_point _p0,const qr_point _p1,const qr_point _p2,int _res){
-  int det;
-  int dx1;
-  int dy1;
-  int dx2;
-  int dy2;
-  /*det is ensured to be positive by our caller.*/
-  det=qr_point_ccw(_p0,_p1,_p2);
-  dx1=_p1[0]-_p0[0];
-  dx2=_p2[0]-_p0[0];
-  dy1=_p1[1]-_p0[1];
-  dy2=_p2[1]-_p0[1];
-  _aff->fwd[0][0]=dx1;
-  _aff->fwd[0][1]=dx2;
-  _aff->fwd[1][0]=dy1;
-  _aff->fwd[1][1]=dy2;
-  _aff->inv[0][0]=QR_DIVROUND(dy2<<_res,det);
-  _aff->inv[0][1]=QR_DIVROUND(-dx2<<_res,det);
-  _aff->inv[1][0]=QR_DIVROUND(-dy1<<_res,det);
-  _aff->inv[1][1]=QR_DIVROUND(dx1<<_res,det);
-  _aff->x0=_p0[0];
-  _aff->y0=_p0[1];
-  _aff->res=_res;
-}
-
-/*Map from the image (at subpel resolution) into the square domain.*/
-static void qr_aff_unproject(qr_point _q,const qr_aff *_aff,
- int _x,int _y){
-  _q[0]=_aff->inv[0][0]*(_x-_aff->x0)+_aff->inv[0][1]*(_y-_aff->y0);
-  _q[1]=_aff->inv[1][0]*(_x-_aff->x0)+_aff->inv[1][1]*(_y-_aff->y0);
-}
-
-/*Map from the square domain into the image (at subpel resolution).*/
-static void qr_aff_project(qr_point _p,const qr_aff *_aff,
- int _u,int _v){
-  _p[0]=(_aff->fwd[0][0]*_u+_aff->fwd[0][1]*_v+(1<<_aff->res-1)>>_aff->res)
-   +_aff->x0;
-  _p[1]=(_aff->fwd[1][0]*_u+_aff->fwd[1][1]*_v+(1<<_aff->res-1)>>_aff->res)
-   +_aff->y0;
-}
-
-
-
-/*A full homography.
-  Like the affine homography, this maps from the image (at subpel resolution)
-   to a square domain with power-of-two sides (of res bits) and back.*/
-struct qr_hom{
-  int fwd[3][2];
-  int inv[3][2];
-  int fwd22;
-  int inv22;
-  int x0;
-  int y0;
-  int res;
-};
-
-
-static void qr_hom_init(qr_hom *_hom,int _x0,int _y0,
- int _x1,int _y1,int _x2,int _y2,int _x3,int _y3,int _res){
-  int dx10;
-  int dx20;
-  int dx30;
-  int dx31;
-  int dx32;
-  int dy10;
-  int dy20;
-  int dy30;
-  int dy31;
-  int dy32;
-  int a20;
-  int a21;
-  int a22;
-  int b0;
-  int b1;
-  int b2;
-  int s1;
-  int s2;
-  int r1;
-  int r2;
-  dx10=_x1-_x0;
-  dx20=_x2-_x0;
-  dx30=_x3-_x0;
-  dx31=_x3-_x1;
-  dx32=_x3-_x2;
-  dy10=_y1-_y0;
-  dy20=_y2-_y0;
-  dy30=_y3-_y0;
-  dy31=_y3-_y1;
-  dy32=_y3-_y2;
-  a20=dx32*dy10-dx10*dy32;
-  a21=dx20*dy31-dx31*dy20;
-  a22=dx32*dy31-dx31*dy32;
-  /*Figure out if we need to downscale anything.*/
-  b0=qr_ilog(QR_MAXI(abs(dx10),abs(dy10)))+qr_ilog(abs(a20+a22));
-  b1=qr_ilog(QR_MAXI(abs(dx20),abs(dy20)))+qr_ilog(abs(a21+a22));
-  b2=qr_ilog(QR_MAXI(QR_MAXI(abs(a20),abs(a21)),abs(a22)));
-  s1=QR_MAXI(0,_res+QR_MAXI(QR_MAXI(b0,b1),b2)-(QR_INT_BITS-2));
-  r1=(1<<s1)>>1;
-  /*Compute the final coefficients of the forward transform.
-    The 32x32->64 bit multiplies are really needed for accuracy with large
-     versions.*/
-  _hom->fwd[0][0]=QR_FIXMUL(dx10,a20+a22,r1,s1);
-  _hom->fwd[0][1]=QR_FIXMUL(dx20,a21+a22,r1,s1);
-  _hom->x0=_x0;
-  _hom->fwd[1][0]=QR_FIXMUL(dy10,a20+a22,r1,s1);
-  _hom->fwd[1][1]=QR_FIXMUL(dy20,a21+a22,r1,s1);
-  _hom->y0=_y0;
-  _hom->fwd[2][0]=a20+r1>>s1;
-  _hom->fwd[2][1]=a21+r1>>s1;
-  _hom->fwd22=s1>_res?a22+(r1>>_res)>>s1-_res:a22<<_res-s1;
-  /*Now compute the inverse transform.*/
-  b0=qr_ilog(QR_MAXI(QR_MAXI(abs(dx10),abs(dx20)),abs(dx30)))+
-   qr_ilog(QR_MAXI(abs(_hom->fwd[0][0]),abs(_hom->fwd[1][0])));
-  b1=qr_ilog(QR_MAXI(QR_MAXI(abs(dy10),abs(dy20)),abs(dy30)))+
-   qr_ilog(QR_MAXI(abs(_hom->fwd[0][1]),abs(_hom->fwd[1][1])));
-  b2=qr_ilog(abs(a22))-s1;
-  s2=QR_MAXI(0,QR_MAXI(b0,b1)+b2-(QR_INT_BITS-3));
-  r2=(1<<s2)>>1;
-  s1+=s2;
-  r1<<=s2;
-  /*The 32x32->64 bit multiplies are really needed for accuracy with large
-     versions.*/
-  _hom->inv[0][0]=QR_FIXMUL(_hom->fwd[1][1],a22,r1,s1);
-  _hom->inv[0][1]=QR_FIXMUL(-_hom->fwd[0][1],a22,r1,s1);
-  _hom->inv[1][0]=QR_FIXMUL(-_hom->fwd[1][0],a22,r1,s1);
-  _hom->inv[1][1]=QR_FIXMUL(_hom->fwd[0][0],a22,r1,s1);
-  _hom->inv[2][0]=QR_FIXMUL(_hom->fwd[1][0],_hom->fwd[2][1],
-   -QR_EXTMUL(_hom->fwd[1][1],_hom->fwd[2][0],r2),s2);
-  _hom->inv[2][1]=QR_FIXMUL(_hom->fwd[0][1],_hom->fwd[2][0],
-   -QR_EXTMUL(_hom->fwd[0][0],_hom->fwd[2][1],r2),s2);
-  _hom->inv22=QR_FIXMUL(_hom->fwd[0][0],_hom->fwd[1][1],
-   -QR_EXTMUL(_hom->fwd[0][1],_hom->fwd[1][0],r2),s2);
-  _hom->res=_res;
-}
-
-
-/*Map from the image (at subpel resolution) into the square domain.
-  Returns a negative value if the point went to infinity.*/
-static int qr_hom_unproject(qr_point _q,const qr_hom *_hom,int _x,int _y){
-  int x;
-  int y;
-  int w;
-  _x-=_hom->x0;
-  _y-=_hom->y0;
-  x=_hom->inv[0][0]*_x+_hom->inv[0][1]*_y;
-  y=_hom->inv[1][0]*_x+_hom->inv[1][1]*_y;
-  w=_hom->inv[2][0]*_x+_hom->inv[2][1]*_y
-   +_hom->inv22+(1<<_hom->res-1)>>_hom->res;
-  if(w==0){
-    _q[0]=x<0?INT_MIN:INT_MAX;
-    _q[1]=y<0?INT_MIN:INT_MAX;
-    return -1;
-  }
-  else{
-    if(w<0){
-      x=-x;
-      y=-y;
-      w=-w;
-    }
-    _q[0]=QR_DIVROUND(x,w);
-    _q[1]=QR_DIVROUND(y,w);
-  }
-  return 0;
-}
-
-/*Finish a partial projection, converting from homogeneous coordinates to the
-   normal 2-D representation.
-  In loops, we can avoid many multiplies by computing the homogeneous _x, _y,
-   and _w incrementally, but we cannot avoid the divisions, done here.*/
-static void qr_hom_fproject(qr_point _p,const qr_hom *_hom,
- int _x,int _y,int _w){
-  if(_w==0){
-    _p[0]=_x<0?INT_MIN:INT_MAX;
-    _p[1]=_y<0?INT_MIN:INT_MAX;
-  }
-  else{
-    if(_w<0){
-      _x=-_x;
-      _y=-_y;
-      _w=-_w;
-    }
-    _p[0]=QR_DIVROUND(_x,_w)+_hom->x0;
-    _p[1]=QR_DIVROUND(_y,_w)+_hom->y0;
-  }
-}
-
-#if defined(QR_DEBUG)
-/*Map from the square domain into the image (at subpel resolution).
-  Currently only used directly by debug code.*/
-static void qr_hom_project(qr_point _p,const qr_hom *_hom,
- int _u,int _v){
-  qr_hom_fproject(_p,_hom,
-   _hom->fwd[0][0]*_u+_hom->fwd[0][1]*_v,
-   _hom->fwd[1][0]*_u+_hom->fwd[1][1]*_v,
-   _hom->fwd[2][0]*_u+_hom->fwd[2][1]*_v+_hom->fwd22);
-}
-#endif
-
-
-
-/*All the information we've collected about a finder pattern in the current
-   configuration.*/
-struct qr_finder{
-  /*The module size along each axis (in the square domain).*/
-  int                size[2];
-  /*The version estimated from the module size along each axis.*/
-  int                eversion[2];
-  /*The list of classified edge points for each edge.*/
-  qr_finder_edge_pt *edge_pts[4];
-  /*The number of edge points classified as belonging to each edge.*/
-  int                nedge_pts[4];
-  /*The number of inliers found after running RANSAC on each edge.*/
-  int                ninliers[4];
-  /*The center of the finder pattern (in the square domain).*/
-  qr_point           o;
-  /*The finder center information from the original image.*/
-  qr_finder_center  *c;
-};
-
-
-static int qr_cmp_edge_pt(const void *_a,const void *_b){
-  const qr_finder_edge_pt *a;
-  const qr_finder_edge_pt *b;
-  a=(const qr_finder_edge_pt *)_a;
-  b=(const qr_finder_edge_pt *)_b;
-  return ((a->edge>b->edge)-(a->edge<b->edge)<<1)+
-   (a->extent>b->extent)-(a->extent<b->extent);
-}
-
-/*Computes the index of the edge each edge point belongs to, and its (signed)
-   distance along the corresponding axis from the center of the finder pattern
-   (in the square domain).
-  The resulting list of edge points is sorted by edge index, with ties broken
-   by extent.*/
-static void qr_finder_edge_pts_aff_classify(qr_finder *_f,const qr_aff *_aff){
-  qr_finder_center *c;
-  int               i;
-  int               e;
-  c=_f->c;
-  for(e=0;e<4;e++)_f->nedge_pts[e]=0;
-  for(i=0;i<c->nedge_pts;i++){
-    qr_point q;
-    int      d;
-    qr_aff_unproject(q,_aff,c->edge_pts[i].pos[0],c->edge_pts[i].pos[1]);
-    qr_point_translate(q,-_f->o[0],-_f->o[1]);
-    d=abs(q[1])>abs(q[0]);
-    e=d<<1|(q[d]>=0);
-    _f->nedge_pts[e]++;
-    c->edge_pts[i].edge=e;
-    c->edge_pts[i].extent=q[d];
-  }
-  qsort(c->edge_pts,c->nedge_pts,sizeof(*c->edge_pts),qr_cmp_edge_pt);
-  _f->edge_pts[0]=c->edge_pts;
-  for(e=1;e<4;e++)_f->edge_pts[e]=_f->edge_pts[e-1]+_f->nedge_pts[e-1];
-}
-
-/*Computes the index of the edge each edge point belongs to, and its (signed)
-   distance along the corresponding axis from the center of the finder pattern
-   (in the square domain).
-  The resulting list of edge points is sorted by edge index, with ties broken
-   by extent.*/
-static void qr_finder_edge_pts_hom_classify(qr_finder *_f,const qr_hom *_hom){
-  qr_finder_center *c;
-  int               i;
-  int               e;
-  c=_f->c;
-  for(e=0;e<4;e++)_f->nedge_pts[e]=0;
-  for(i=0;i<c->nedge_pts;i++){
-    qr_point q;
-    int      d;
-    if(qr_hom_unproject(q,_hom,
-     c->edge_pts[i].pos[0],c->edge_pts[i].pos[1])>=0){
-      qr_point_translate(q,-_f->o[0],-_f->o[1]);
-      d=abs(q[1])>abs(q[0]);
-      e=d<<1|(q[d]>=0);
-      _f->nedge_pts[e]++;
-      c->edge_pts[i].edge=e;
-      c->edge_pts[i].extent=q[d];
-    }
-    else{
-      c->edge_pts[i].edge=4;
-      c->edge_pts[i].extent=q[0];
-    }
-  }
-  qsort(c->edge_pts,c->nedge_pts,sizeof(*c->edge_pts),qr_cmp_edge_pt);
-  _f->edge_pts[0]=c->edge_pts;
-  for(e=1;e<4;e++)_f->edge_pts[e]=_f->edge_pts[e-1]+_f->nedge_pts[e-1];
-}
-
-/*TODO: Perhaps these thresholds should be on the module size instead?
-  Unfortunately, I'd need real-world images of codes with larger versions to
-   see if these thresholds are still effective, but such versions aren't used
-   often.*/
-
-/*The amount that the estimated version numbers are allowed to differ from the
-   real version number and still be considered valid.*/
-#define QR_SMALL_VERSION_SLACK (1)
-/*Since cell phone cameras can have severe radial distortion, the estimated
-   version for larger versions can be off by larger amounts.*/
-#define QR_LARGE_VERSION_SLACK (3)
-
-/*Estimates the size of a module after classifying the edge points.
-  _width:  The distance between UL and UR in the square domain.
-  _height: The distance between UL and DL in the square domain.*/
-static int qr_finder_estimate_module_size_and_version(qr_finder *_f,
- int _width,int _height){
-  qr_point offs;
-  int      sums[4];
-  int      nsums[4];
-  int      usize;
-  int      nusize;
-  int      vsize;
-  int      nvsize;
-  int      uversion;
-  int      vversion;
-  int      e;
-  offs[0]=offs[1]=0;
-  for(e=0;e<4;e++)if(_f->nedge_pts[e]>0){
-    qr_finder_edge_pt *edge_pts;
-    int                sum;
-    int                mean;
-    int                n;
-    int                i;
-    /*Average the samples for this edge, dropping the top and bottom 25%.*/
-    edge_pts=_f->edge_pts[e];
-    n=_f->nedge_pts[e];
-    sum=0;
-    for(i=(n>>2);i<n-(n>>2);i++)sum+=edge_pts[i].extent;
-    n=n-((n>>2)<<1);
-    mean=QR_DIVROUND(sum,n);
-    offs[e>>1]+=mean;
-    sums[e]=sum;
-    nsums[e]=n;
-  }
-  else nsums[e]=sums[e]=0;
-  /*If we have samples on both sides of an axis, refine our idea of where the
-     unprojected finder center is located.*/
-  if(_f->nedge_pts[0]>0&&_f->nedge_pts[1]>0){
-    _f->o[0]-=offs[0]>>1;
-    sums[0]-=offs[0]*nsums[0]>>1;
-    sums[1]-=offs[0]*nsums[1]>>1;
-  }
-  if(_f->nedge_pts[2]>0&&_f->nedge_pts[3]>0){
-    _f->o[1]-=offs[1]>>1;
-    sums[2]-=offs[1]*nsums[2]>>1;
-    sums[3]-=offs[1]*nsums[3]>>1;
-  }
-  /*We must have _some_ samples along each axis... if we don't, our transform
-     must be pretty severely distorting the original square (e.g., with
-     coordinates so large as to cause overflow).*/
-  nusize=nsums[0]+nsums[1];
-  if(nusize<=0)return -1;
-  /*The module size is 1/3 the average edge extent.*/
-  nusize*=3;
-  usize=sums[1]-sums[0];
-  usize=((usize<<1)+nusize)/(nusize<<1);
-  if(usize<=0)return -1;
-  /*Now estimate the version directly from the module size and the distance
-     between the finder patterns.
-    This is done independently using the extents along each axis.
-    If either falls significantly outside the valid range (1 to 40), reject the
-     configuration.*/
-  uversion=(_width-8*usize)/(usize<<2);
-  if(uversion<1||uversion>40+QR_LARGE_VERSION_SLACK)return -1;
-  /*Now do the same for the other axis.*/
-  nvsize=nsums[2]+nsums[3];
-  if(nvsize<=0)return -1;
-  nvsize*=3;
-  vsize=sums[3]-sums[2];
-  vsize=((vsize<<1)+nvsize)/(nvsize<<1);
-  if(vsize<=0)return -1;
-  vversion=(_height-8*vsize)/(vsize<<2);
-  if(vversion<1||vversion>40+QR_LARGE_VERSION_SLACK)return -1;
-  /*If the estimated version using extents along one axis is significantly
-     different than the estimated version along the other axis, then the axes
-     have significantly different scalings (relative to the grid).
-    This can happen, e.g., when we have multiple adjacent QR codes, and we've
-     picked two finder patterns from one and the third finder pattern from
-     another, e.g.:
-      X---DL UL---X
-      |....   |....
-      X....  UR....
-    Such a configuration might even pass any other geometric checks if we
-     didn't reject it here.*/
-  if(abs(uversion-vversion)>QR_LARGE_VERSION_SLACK)return -1;
-  _f->size[0]=usize;
-  _f->size[1]=vsize;
-  /*We intentionally do not compute an average version from the sizes along
-     both axes.
-    In the presence of projective distortion, one of them will be much more
-     accurate than the other.*/
-  _f->eversion[0]=uversion;
-  _f->eversion[1]=vversion;
-  return 0;
-}
-
-/*Eliminate outliers from the classified edge points with RANSAC.*/
-static void qr_finder_ransac(qr_finder *_f,const qr_aff *_hom,
- isaac_ctx *_isaac,int _e){
-  qr_finder_edge_pt *edge_pts;
-  int                best_ninliers;
-  int                n;
-  edge_pts=_f->edge_pts[_e];
-  n=_f->nedge_pts[_e];
-  best_ninliers=0;
-  if(n>1){
-    int max_iters;
-    int i;
-    int j;
-    /*17 iterations is enough to guarantee an outlier-free sample with more
-       than 99% probability given as many as 50% outliers.*/
-    max_iters=17;
-    for(i=0;i<max_iters;i++){
-      qr_point  q0;
-      qr_point  q1;
-      int       ninliers;
-      int       thresh;
-      int       p0i;
-      int       p1i;
-      int      *p0;
-      int      *p1;
-      int       j;
-      /*Pick two random points on this edge.*/
-      p0i=isaac_next_uint(_isaac,n);
-      p1i=isaac_next_uint(_isaac,n-1);
-      if(p1i>=p0i)p1i++;
-      p0=edge_pts[p0i].pos;
-      p1=edge_pts[p1i].pos;
-      /*If the corresponding line is not within 45 degrees of the proper
-         orientation in the square domain, reject it outright.
-        This can happen, e.g., when highly skewed orientations cause points to
-         be misclassified into the wrong edge.
-        The irony is that using such points might produce a line which _does_
-         pass the corresponding validity checks.*/
-      qr_aff_unproject(q0,_hom,p0[0],p0[1]);
-      qr_aff_unproject(q1,_hom,p1[0],p1[1]);
-      qr_point_translate(q0,-_f->o[0],-_f->o[1]);
-      qr_point_translate(q1,-_f->o[0],-_f->o[1]);
-      if(abs(q0[_e>>1]-q1[_e>>1])>abs(q0[1-(_e>>1)]-q1[1-(_e>>1)]))continue;
-      /*Identify the other edge points which are inliers.
-        The squared distance should be distributed as a \Chi^2 distribution
-         with one degree of freedom, which means for a 95% confidence the
-         point should lie within a factor 3.8414588 ~= 4 times the expected
-         variance of the point locations.
-        We grossly approximate the standard deviation as 1 pixel in one
-         direction, and 0.5 pixels in the other (because we average two
-         coordinates).*/
-      thresh=qr_isqrt(qr_point_distance2(p0,p1)<<2*QR_FINDER_SUBPREC+1);
-      ninliers=0;
-      for(j=0;j<n;j++){
-        if(abs(qr_point_ccw(p0,p1,edge_pts[j].pos))<=thresh){
-          edge_pts[j].extent|=1;
-          ninliers++;
-        }
-        else edge_pts[j].extent&=~1;
-      }
-      if(ninliers>best_ninliers){
-        for(j=0;j<n;j++)edge_pts[j].extent<<=1;
-        best_ninliers=ninliers;
-        /*The actual number of iterations required is
-            log(1-\alpha)/log(1-r*r),
-           where \alpha is the required probability of taking a sample with
-            no outliers (e.g., 0.99) and r is the estimated ratio of inliers
-            (e.g. ninliers/n).
-          This is just a rough (but conservative) approximation, but it
-           should be good enough to stop the iteration early when we find
-           a good set of inliers.*/
-        if(ninliers>n>>1)max_iters=(67*n-63*ninliers-1)/(n<<1);
-      }
-    }
-    /*Now collect all the inliers at the beginning of the list.*/
-    for(i=j=0;j<best_ninliers;i++)if(edge_pts[i].extent&2){
-      if(j<i){
-        qr_finder_edge_pt tmp;
-        *&tmp=*(edge_pts+i);
-        *(edge_pts+j)=*(edge_pts+i);
-        *(edge_pts+i)=*&tmp;
-      }
-      j++;
-    }
-  }
-  _f->ninliers[_e]=best_ninliers;
-}
-
-/*Perform a least-squares line fit to an edge of a finder pattern using the
-   inliers found by RANSAC.*/
-static int qr_line_fit_finder_edge(qr_line _l,
- const qr_finder *_f,int _e,int _res){
-  qr_finder_edge_pt *edge_pts;
-  qr_point          *pts;
-  int                npts;
-  int                i;
-  npts=_f->ninliers[_e];
-  if(npts<2)return -1;
-  /*We could write a custom version of qr_line_fit_points that accesses
-     edge_pts directly, but this saves on code size and doesn't measurably slow
-     things down.*/
-  pts=(qr_point *)malloc(npts*sizeof(*pts));
-  edge_pts=_f->edge_pts[_e];
-  for(i=0;i<npts;i++){
-    pts[i][0]=edge_pts[i].pos[0];
-    pts[i][1]=edge_pts[i].pos[1];
-  }
-  qr_line_fit_points(_l,pts,npts,_res);
-  /*Make sure the center of the finder pattern lies in the positive halfspace
-     of the line.*/
-  qr_line_orient(_l,_f->c->pos[0],_f->c->pos[1]);
-  free(pts);
-  return 0;
-}
-
-/*Perform a least-squares line fit to a pair of common finder edges using the
-   inliers found by RANSAC.
-  Unlike a normal edge fit, we guarantee that this one succeeds by creating at
-   least one point on each edge using the estimated module size if it has no
-   inliers.*/
-static void qr_line_fit_finder_pair(qr_line _l,const qr_aff *_aff,
- const qr_finder *_f0,const qr_finder *_f1,int _e){
-  qr_point          *pts;
-  int                npts;
-  qr_finder_edge_pt *edge_pts;
-  qr_point           q;
-  int                n0;
-  int                n1;
-  int                i;
-  n0=_f0->ninliers[_e];
-  n1=_f1->ninliers[_e];
-  /*We could write a custom version of qr_line_fit_points that accesses
-     edge_pts directly, but this saves on code size and doesn't measurably slow
-     things down.*/
-  npts=QR_MAXI(n0,1)+QR_MAXI(n1,1);
-  pts=(qr_point *)malloc(npts*sizeof(*pts));
-  if(n0>0){
-    edge_pts=_f0->edge_pts[_e];
-    for(i=0;i<n0;i++){
-      pts[i][0]=edge_pts[i].pos[0];
-      pts[i][1]=edge_pts[i].pos[1];
-    }
-  }
-  else{
-    q[0]=_f0->o[0];
-    q[1]=_f0->o[1];
-    q[_e>>1]+=_f0->size[_e>>1]*(2*(_e&1)-1);
-    qr_aff_project(pts[0],_aff,q[0],q[1]);
-    n0++;
-  }
-  if(n1>0){
-    edge_pts=_f1->edge_pts[_e];
-    for(i=0;i<n1;i++){
-      pts[n0+i][0]=edge_pts[i].pos[0];
-      pts[n0+i][1]=edge_pts[i].pos[1];
-    }
-  }
-  else{
-    q[0]=_f1->o[0];
-    q[1]=_f1->o[1];
-    q[_e>>1]+=_f1->size[_e>>1]*(2*(_e&1)-1);
-    qr_aff_project(pts[n0],_aff,q[0],q[1]);
-    n1++;
-  }
-  qr_line_fit_points(_l,pts,npts,_aff->res);
-  /*Make sure at least one finder center lies in the positive halfspace.*/
-  qr_line_orient(_l,_f0->c->pos[0],_f0->c->pos[1]);
-  free(pts);
-}
-
-static int qr_finder_quick_crossing_check(const unsigned char *_img,
- int _width,int _height,int _x0,int _y0,int _x1,int _y1,int _v){
-  /*The points must be inside the image, and have a !_v:_v:!_v pattern.
-    We don't scan the whole line initially, but quickly reject if the endpoints
-     aren't !_v, or the midpoint isn't _v.
-    If either end point is out of the image, or we don't encounter a _v pixel,
-     we return a negative value, indicating the region should be considered
-     empty.
-    Otherwise, we return a positive value to indicate it is non-empty.*/
-  if(_x0<0||_x0>=_width||_y0<0||_y0>=_height||
-   _x1<0||_x1>=_width||_y1<0||_y1>=_height){
-    return -1;
-  }
-  if(!_img[_y0*_width+_x0]!=_v||!_img[_y1*_width+_x1]!=_v)return 1;
-  if(!_img[(_y0+_y1>>1)*_width+(_x0+_x1>>1)]==_v)return -1;
-  return 0;
-}
-
-/*Locate the midpoint of a _v segment along a !_v:_v:!_v line from (_x0,_y0) to
-   (_x1,_y1).
-  All coordinates, which are NOT in subpel resolution, must lie inside the
-   image, and the endpoints are already assumed to have the value !_v.
-  The returned value is in subpel resolution.*/
-static int qr_finder_locate_crossing(const unsigned char *_img,
- int _width,int _height,int _x0,int _y0,int _x1,int _y1,int _v,qr_point _p){
-  qr_point x0;
-  qr_point x1;
-  qr_point dx;
-  int      step[2];
-  int      steep;
-  int      err;
-  int      derr;
-  /*Use Bresenham's algorithm to trace along the line and find the exact
-     transitions from !_v to _v and back.*/
-  x0[0]=_x0;
-  x0[1]=_y0;
-  x1[0]=_x1;
-  x1[1]=_y1;
-  dx[0]=abs(_x1-_x0);
-  dx[1]=abs(_y1-_y0);
-  steep=dx[1]>dx[0];
-  err=0;
-  derr=dx[1-steep];
-  step[0]=((_x0<_x1)<<1)-1;
-  step[1]=((_y0<_y1)<<1)-1;
-  /*Find the first crossing from !_v to _v.*/
-  for(;;){
-    /*If we make it all the way to the other side, there's no crossing.*/
-    if(x0[steep]==x1[steep])return -1;
-    x0[steep]+=step[steep];
-    err+=derr;
-    if(err<<1>dx[steep]){
-      x0[1-steep]+=step[1-steep];
-      err-=dx[steep];
-    }
-    if(!_img[x0[1]*_width+x0[0]]!=_v)break;
-  }
-  /*Find the last crossing from _v to !_v.*/
-  err=0;
-  for(;;){
-    if(x0[steep]==x1[steep])break;
-    x1[steep]-=step[steep];
-    err+=derr;
-    if(err<<1>dx[steep]){
-      x1[1-steep]-=step[1-steep];
-      err-=dx[steep];
-    }
-    if(!_img[x1[1]*_width+x1[0]]!=_v)break;
-  }
-  /*Return the midpoint of the _v segment.*/
-  _p[0]=(x0[0]+x1[0]+1<<QR_FINDER_SUBPREC)>>1;
-  _p[1]=(x0[1]+x1[1]+1<<QR_FINDER_SUBPREC)>>1;
-  return 0;
-}
-
-static int qr_aff_line_step(const qr_aff *_aff,qr_line _l,
- int _v,int _du,int *_dv){
-  int shift;
-  int round;
-  int dv;
-  int n;
-  int d;
-  n=_aff->fwd[0][_v]*_l[0]+_aff->fwd[1][_v]*_l[1];
-  d=_aff->fwd[0][1-_v]*_l[0]+_aff->fwd[1][1-_v]*_l[1];
-  if(d<0){
-    n=-n;
-    d=-d;
-  }
-  shift=QR_MAXI(0,qr_ilog(_du)+qr_ilog(abs(n))+3-QR_INT_BITS);
-  round=(1<<shift)>>1;
-  n=n+round>>shift;
-  d=d+round>>shift;
-  /*The line should not be outside 45 degrees of horizontal/vertical.
-    TODO: We impose this restriction to help ensure the loop below terminates,
-     but it should not technically be required.
-    It also, however, ensures we avoid division by zero.*/
-  if(abs(n)>=d)return -1;
-  n=-_du*n;
-  dv=QR_DIVROUND(n,d);
-  if(abs(dv)>=_du)return -1;
-  *_dv=dv;
-  return 0;
-}
-
-/*Computes the Hamming distance between two bit patterns (the number of bits
-   that differ).
-  May stop counting after _maxdiff differences.*/
-static int qr_hamming_dist(unsigned _y1,unsigned _y2,int _maxdiff){
-  unsigned y;
-  int      ret;
-  y=_y1^_y2;
-  for(ret=0;ret<_maxdiff&&y;ret++)y&=y-1;
-  return ret;
-}
-
-/*Retrieve a bit (guaranteed to be 0 or 1) from the image, given coordinates in
-   subpel resolution which have not been bounds checked.*/
-static int qr_img_get_bit(const unsigned char *_img,int _width,int _height,
- int _x,int _y){
-  _x>>=QR_FINDER_SUBPREC;
-  _y>>=QR_FINDER_SUBPREC;
-  return _img[QR_CLAMPI(0,_y,_height-1)*_width+QR_CLAMPI(0,_x,_width-1)]!=0;
-}
-
-#if defined(QR_DEBUG)
-#include "image.h"
-
-static void qr_finder_dump_aff_undistorted(qr_finder *_ul,qr_finder *_ur,
- qr_finder *_dl,qr_aff *_aff,const unsigned char *_img,int _width,int _height){
-  unsigned char *gimg;
-  FILE          *fout;
-  int            lpsz;
-  int            pixel_size;
-  int            dim;
-  int            min;
-  int            max;
-  int            u;
-  int            y;
-  int            i;
-  int            j;
-  lpsz=qr_ilog(_ur->size[0]+_ur->size[1]+_dl->size[0]+_dl->size[1])-6;
-  pixel_size=1<<lpsz;
-  dim=(1<<_aff->res-lpsz)+128;
-  gimg=(unsigned char *)malloc(dim*dim*sizeof(*gimg));
-  for(i=0;i<dim;i++)for(j=0;j<dim;j++){
-    qr_point p;
-    qr_aff_project(p,_aff,(j-64)<<lpsz,(i-64)<<lpsz);
-    gimg[i*dim+j]=_img[
-     QR_CLAMPI(0,p[1]>>QR_FINDER_SUBPREC,_height-1)*_width+
-     QR_CLAMPI(0,p[0]>>QR_FINDER_SUBPREC,_width-1)];
-  }
-  {
-    min=(_ur->o[0]-7*_ur->size[0]>>lpsz)+64;
-    if(min<0)min=0;
-    max=(_ur->o[0]+7*_ur->size[0]>>lpsz)+64;
-    if(max>dim)max=dim;
-    for(y=-7;y<=7;y++){
-      i=(_ur->o[1]+y*_ur->size[1]>>lpsz)+64;
-      if(i<0||i>=dim)continue;
-      for(j=min;j<max;j++)gimg[i*dim+j]=0x7F;
-    }
-    min=(_ur->o[1]-7*_ur->size[1]>>lpsz)+64;
-    if(min<0)min=0;
-    max=(_ur->o[1]+7*_ur->size[1]>>lpsz)+64;
-    if(max>dim)max=dim;
-    for(u=-7;u<=7;u++){
-      j=(_ur->o[0]+u*_ur->size[0]>>lpsz)+64;
-      if(j<0||j>=dim)continue;
-      for(i=min;i<max;i++)gimg[i*dim+j]=0x7F;
-    }
-  }
-  {
-    min=(_dl->o[0]-7*_dl->size[0]>>lpsz)+64;
-    if(min<0)min=0;
-    max=(_dl->o[0]+7*_dl->size[0]>>lpsz)+64;
-    if(max>dim)max=dim;
-    for(y=-7;y<=7;y++){
-      i=(_dl->o[1]+y*_dl->size[1]>>lpsz)+64;
-      if(i<0||i>=dim)continue;
-      for(j=min;j<max;j++)gimg[i*dim+j]=0x7F;
-    }
-    min=(_dl->o[1]-7*_dl->size[1]>>lpsz)+64;
-    if(min<0)min=0;
-    max=(_dl->o[1]+7*_dl->size[1]>>lpsz)+64;
-    if(max>dim)max=dim;
-    for(u=-7;u<=7;u++){
-      j=(_dl->o[0]+u*_dl->size[0]>>lpsz)+64;
-      if(j<0||j>=dim)continue;
-      for(i=min;i<max;i++)gimg[i*dim+j]=0x7F;
-    }
-  }
-  fout=fopen("undistorted_aff.png","wb");
-  image_write_png(gimg,dim,dim,fout);
-  fclose(fout);
-  free(gimg);
-}
-
-static void qr_finder_dump_hom_undistorted(qr_finder *_ul,qr_finder *_ur,
- qr_finder *_dl,qr_hom *_hom,const unsigned char *_img,int _width,int _height){
-  unsigned char *gimg;
-  FILE          *fout;
-  int            lpsz;
-  int            pixel_size;
-  int            dim;
-  int            min;
-  int            max;
-  int            u;
-  int            v;
-  int            i;
-  int            j;
-  lpsz=qr_ilog(_ur->size[0]+_ur->size[1]+_dl->size[0]+_dl->size[1])-6;
-  pixel_size=1<<lpsz;
-  dim=(1<<_hom->res-lpsz)+256;
-  gimg=(unsigned char *)malloc(dim*dim*sizeof(*gimg));
-  for(i=0;i<dim;i++)for(j=0;j<dim;j++){
-    qr_point p;
-    qr_hom_project(p,_hom,(j-128)<<lpsz,(i-128)<<lpsz);
-    gimg[i*dim+j]=_img[
-     QR_CLAMPI(0,p[1]>>QR_FINDER_SUBPREC,_height-1)*_width+
-     QR_CLAMPI(0,p[0]>>QR_FINDER_SUBPREC,_width-1)];
-  }
-  {
-    min=(_ur->o[0]-7*_ur->size[0]>>lpsz)+128;
-    if(min<0)min=0;
-    max=(_ur->o[0]+7*_ur->size[0]>>lpsz)+128;
-    if(max>dim)max=dim;
-    for(v=-7;v<=7;v++){
-      i=(_ur->o[1]+v*_ur->size[1]>>lpsz)+128;
-      if(i<0||i>=dim)continue;
-      for(j=min;j<max;j++)gimg[i*dim+j]=0x7F;
-    }
-    min=(_ur->o[1]-7*_ur->size[1]>>lpsz)+128;
-    if(min<0)min=0;
-    max=(_ur->o[1]+7*_ur->size[1]>>lpsz)+128;
-    if(max>dim)max=dim;
-    for(u=-7;u<=7;u++){
-      j=(_ur->o[0]+u*_ur->size[0]>>lpsz)+128;
-      if(j<0||j>=dim)continue;
-      for(i=min;i<max;i++)gimg[i*dim+j]=0x7F;
-    }
-  }
-  {
-    min=(_dl->o[0]-7*_dl->size[0]>>lpsz)+128;
-    if(min<0)min=0;
-    max=(_dl->o[0]+7*_dl->size[0]>>lpsz)+128;
-    if(max>dim)max=dim;
-    for(v=-7;v<=7;v++){
-      i=(_dl->o[1]+v*_dl->size[1]>>lpsz)+128;
-      if(i<0||i>=dim)continue;
-      for(j=min;j<max;j++)gimg[i*dim+j]=0x7F;
-    }
-    min=(_dl->o[1]-7*_dl->size[1]>>lpsz)+128;
-    if(min<0)min=0;
-    max=(_dl->o[1]+7*_dl->size[1]>>lpsz)+128;
-    if(max>dim)max=dim;
-    for(u=-7;u<=7;u++){
-      j=(_dl->o[0]+u*_dl->size[0]>>lpsz)+128;
-      if(j<0||j>=dim)continue;
-      for(i=min;i<max;i++)gimg[i*dim+j]=0x7F;
-    }
-  }
-  fout=fopen("undistorted_hom.png","wb");
-  image_write_png(gimg,dim,dim,fout);
-  fclose(fout);
-  free(gimg);
-}
-#endif
-
-
-
-/*A homography from one region of the grid back to the image.
-  Unlike a qr_hom, this does not include an inverse transform and maps directly
-   from the grid points, not a square with power-of-two sides.*/
-struct qr_hom_cell{
-  int fwd[3][3];
-  int x0;
-  int y0;
-  int u0;
-  int v0;
-};
-
-
-static void qr_hom_cell_init(qr_hom_cell *_cell,int _u0,int _v0,
- int _u1,int _v1,int _u2,int _v2,int _u3,int _v3,int _x0,int _y0,
- int _x1,int _y1,int _x2,int _y2,int _x3,int _y3){
-  int du10;
-  int du20;
-  int du30;
-  int du31;
-  int du32;
-  int dv10;
-  int dv20;
-  int dv30;
-  int dv31;
-  int dv32;
-  int dx10;
-  int dx20;
-  int dx30;
-  int dx31;
-  int dx32;
-  int dy10;
-  int dy20;
-  int dy30;
-  int dy31;
-  int dy32;
-  int a00;
-  int a01;
-  int a02;
-  int a10;
-  int a11;
-  int a12;
-  int a20;
-  int a21;
-  int a22;
-  int i00;
-  int i01;
-  int i10;
-  int i11;
-  int i20;
-  int i21;
-  int i22;
-  int b0;
-  int b1;
-  int b2;
-  int shift;
-  int round;
-  int x;
-  int y;
-  int w;
-  /*First, correct for the arrangement of the source points.
-    We take advantage of the fact that we know the source points have a very
-     limited dynamic range (so there will never be overflow) and a small amount
-     of projective distortion.*/
-  du10=_u1-_u0;
-  du20=_u2-_u0;
-  du30=_u3-_u0;
-  du31=_u3-_u1;
-  du32=_u3-_u2;
-  dv10=_v1-_v0;
-  dv20=_v2-_v0;
-  dv30=_v3-_v0;
-  dv31=_v3-_v1;
-  dv32=_v3-_v2;
-  /*Compute the coefficients of the forward transform from the unit square to
-     the source point configuration.*/
-  a20=du32*dv10-du10*dv32;
-  a21=du20*dv31-du31*dv20;
-  if(a20||a21)a22=du32*dv31-du31*dv32;
-  /*If the source grid points aren't in a non-affine arrangement, there's no
-     reason to scale everything by du32*dv31-du31*dv32.
-    Not doing so allows a much larger dynamic range, and is the only way we can
-     initialize a base cell that covers the whole grid.*/
-  else a22=1;
-  a00=du10*(a20+a22);
-  a01=du20*(a21+a22);
-  a10=dv10*(a20+a22);
-  a11=dv20*(a21+a22);
-  /*Now compute the inverse transform.*/
-  i00=a11*a22;
-  i01=-a01*a22;
-  i10=-a10*a22;
-  i11=a00*a22;
-  i20=a10*a21-a11*a20;
-  i21=a01*a20-a00*a21;
-  i22=a00*a11-a01*a10;
-  /*Invert the coefficients.
-    Since i22 is the largest, we divide it by all the others.
-    The quotient is often exact (e.g., when the source points contain no
-     projective distortion), and is never zero.
-    Hence we can use zero to signal "infinity" when the divisor is zero.*/
-  if(i00)i00=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i00)),i00);
-  if(i01)i01=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i01)),i01);
-  if(i10)i10=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i10)),i10);
-  if(i11)i11=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i11)),i11);
-  if(i20)i20=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i20)),i20);
-  if(i21)i21=QR_FLIPSIGNI(QR_DIVROUND(i22,abs(i21)),i21);
-  /*Now compute the map from the unit square into the image.*/
-  dx10=_x1-_x0;
-  dx20=_x2-_x0;
-  dx30=_x3-_x0;
-  dx31=_x3-_x1;
-  dx32=_x3-_x2;
-  dy10=_y1-_y0;
-  dy20=_y2-_y0;
-  dy30=_y3-_y0;
-  dy31=_y3-_y1;
-  dy32=_y3-_y2;
-  a20=dx32*dy10-dx10*dy32;
-  a21=dx20*dy31-dx31*dy20;
-  a22=dx32*dy31-dx31*dy32;
-  /*Figure out if we need to downscale anything.*/
-  b0=qr_ilog(QR_MAXI(abs(dx10),abs(dy10)))+qr_ilog(abs(a20+a22));
-  b1=qr_ilog(QR_MAXI(abs(dx20),abs(dy20)))+qr_ilog(abs(a21+a22));
-  b2=qr_ilog(QR_MAXI(QR_MAXI(abs(a20),abs(a21)),abs(a22)));
-  shift=QR_MAXI(0,QR_MAXI(QR_MAXI(b0,b1),b2)-(QR_INT_BITS-3-QR_ALIGN_SUBPREC));
-  round=(1<<shift)>>1;
-  /*Compute the final coefficients of the forward transform.*/
-  a00=QR_FIXMUL(dx10,a20+a22,round,shift);
-  a01=QR_FIXMUL(dx20,a21+a22,round,shift);
-  a10=QR_FIXMUL(dy10,a20+a22,round,shift);
-  a11=QR_FIXMUL(dy20,a21+a22,round,shift);
-  /*And compose the two transforms.
-    Since we inverted the coefficients above, we divide by them here instead
-     of multiplying.
-    This lets us take advantage of the full dynamic range.
-    Note a zero divisor is really "infinity", and thus the quotient should also
-     be zero.*/
-  _cell->fwd[0][0]=(i00?QR_DIVROUND(a00,i00):0)+(i10?QR_DIVROUND(a01,i10):0);
-  _cell->fwd[0][1]=(i01?QR_DIVROUND(a00,i01):0)+(i11?QR_DIVROUND(a01,i11):0);
-  _cell->fwd[1][0]=(i00?QR_DIVROUND(a10,i00):0)+(i10?QR_DIVROUND(a11,i10):0);
-  _cell->fwd[1][1]=(i01?QR_DIVROUND(a10,i01):0)+(i11?QR_DIVROUND(a11,i11):0);
-  _cell->fwd[2][0]=(i00?QR_DIVROUND(a20,i00):0)+(i10?QR_DIVROUND(a21,i10):0)
-   +(i20?QR_DIVROUND(a22,i20):0)+round>>shift;
-  _cell->fwd[2][1]=(i01?QR_DIVROUND(a20,i01):0)+(i11?QR_DIVROUND(a21,i11):0)
-   +(i21?QR_DIVROUND(a22,i21):0)+round>>shift;
-  _cell->fwd[2][2]=a22+round>>shift;
-  /*Mathematically, a02 and a12 are exactly zero.
-    However, that concentrates all of the rounding error in the (_u3,_v3)
-     corner; we compute offsets which distribute it over the whole range.*/
-  x=_cell->fwd[0][0]*du10+_cell->fwd[0][1]*dv10;
-  y=_cell->fwd[1][0]*du10+_cell->fwd[1][1]*dv10;
-  w=_cell->fwd[2][0]*du10+_cell->fwd[2][1]*dv10+_cell->fwd[2][2];
-  a02=dx10*w-x;
-  a12=dy10*w-y;
-  x=_cell->fwd[0][0]*du20+_cell->fwd[0][1]*dv20;
-  y=_cell->fwd[1][0]*du20+_cell->fwd[1][1]*dv20;
-  w=_cell->fwd[2][0]*du20+_cell->fwd[2][1]*dv20+_cell->fwd[2][2];
-  a02+=dx20*w-x;
-  a12+=dy20*w-y;
-  x=_cell->fwd[0][0]*du30+_cell->fwd[0][1]*dv30;
-  y=_cell->fwd[1][0]*du30+_cell->fwd[1][1]*dv30;
-  w=_cell->fwd[2][0]*du30+_cell->fwd[2][1]*dv30+_cell->fwd[2][2];
-  a02+=dx30*w-x;
-  a12+=dy30*w-y;
-  _cell->fwd[0][2]=a02+2>>2;
-  _cell->fwd[1][2]=a12+2>>2;
-  _cell->x0=_x0;
-  _cell->y0=_y0;
-  _cell->u0=_u0;
-  _cell->v0=_v0;
-}
-
-/*Finish a partial projection, converting from homogeneous coordinates to the
-   normal 2-D representation.
-  In loops, we can avoid many multiplies by computing the homogeneous _x, _y,
-   and _w incrementally, but we cannot avoid the divisions, done here.*/
-static void qr_hom_cell_fproject(qr_point _p,const qr_hom_cell *_cell,
- int _x,int _y,int _w){
-  if(_w==0){
-    _p[0]=_x<0?INT_MIN:INT_MAX;
-    _p[1]=_y<0?INT_MIN:INT_MAX;
-  }
-  else{
-    if(_w<0){
-      _x=-_x;
-      _y=-_y;
-      _w=-_w;
-    }
-    _p[0]=QR_DIVROUND(_x,_w)+_cell->x0;
-    _p[1]=QR_DIVROUND(_y,_w)+_cell->y0;
-  }
-}
-
-static void qr_hom_cell_project(qr_point _p,const qr_hom_cell *_cell,
- int _u,int _v,int _res){
-  _u-=_cell->u0<<_res;
-  _v-=_cell->v0<<_res;
-  qr_hom_cell_fproject(_p,_cell,
-   _cell->fwd[0][0]*_u+_cell->fwd[0][1]*_v+(_cell->fwd[0][2]<<_res),
-   _cell->fwd[1][0]*_u+_cell->fwd[1][1]*_v+(_cell->fwd[1][2]<<_res),
-   _cell->fwd[2][0]*_u+_cell->fwd[2][1]*_v+(_cell->fwd[2][2]<<_res));
-}
-
-
-
-/*Retrieves the bits corresponding to the alignment pattern template centered
-   at the given location in the original image (at subpel precision).*/
-static unsigned qr_alignment_pattern_fetch(qr_point _p[5][5],int _x0,int _y0,
- const unsigned char *_img,int _width,int _height){
-  unsigned v;
-  int      i;
-  int      j;
-  int      k;
-  int      dx;
-  int      dy;
-  dx=_x0-_p[2][2][0];
-  dy=_y0-_p[2][2][1];
-  v=0;
-  for(k=i=0;i<5;i++)for(j=0;j<5;j++,k++){
-    v|=qr_img_get_bit(_img,_width,_height,_p[i][j][0]+dx,_p[i][j][1]+dy)<<k;
-  }
-  return v;
-}
-
-/*Searches for an alignment pattern near the given location.*/
-static int qr_alignment_pattern_search(qr_point _p,const qr_hom_cell *_cell,
- int _u,int _v,int _r,const unsigned char *_img,int _width,int _height){
-  qr_point c[4];
-  int      nc[4];
-  qr_point p[5][5];
-  qr_point pc;
-  unsigned best_match;
-  int      best_dist;
-  int      bestx;
-  int      besty;
-  unsigned match;
-  int      dist;
-  int      u;
-  int      v;
-  int      x0;
-  int      y0;
-  int      w0;
-  int      x;
-  int      y;
-  int      w;
-  int      dxdu;
-  int      dydu;
-  int      dwdu;
-  int      dxdv;
-  int      dydv;
-  int      dwdv;
-  int      dx;
-  int      dy;
-  int      i;
-  int      j;
-  /*Build up a basic template using _cell to control shape and scale.
-    We project the points in the template back to the image just once, since if
-     the alignment pattern has moved, we don't really know why.
-    If it's because of radial distortion, or the code wasn't flat, or something
-     else, there's no reason to expect that a re-projection around each
-     subsequent search point would be any closer to the actual shape than our
-     first projection.
-    Therefore we simply slide this template around, as is.*/
-  u=(_u-2)-_cell->u0;
-  v=(_v-2)-_cell->v0;
-  x0=_cell->fwd[0][0]*u+_cell->fwd[0][1]*v+_cell->fwd[0][2];
-  y0=_cell->fwd[1][0]*u+_cell->fwd[1][1]*v+_cell->fwd[1][2];
-  w0=_cell->fwd[2][0]*u+_cell->fwd[2][1]*v+_cell->fwd[2][2];
-  dxdu=_cell->fwd[0][0];
-  dydu=_cell->fwd[1][0];
-  dwdu=_cell->fwd[2][0];
-  dxdv=_cell->fwd[0][1];
-  dydv=_cell->fwd[1][1];
-  dwdv=_cell->fwd[2][1];
-  for(i=0;i<5;i++){
-    x=x0;
-    y=y0;
-    w=w0;
-    for(j=0;j<5;j++){
-      qr_hom_cell_fproject(p[i][j],_cell,x,y,w);
-      x+=dxdu;
-      y+=dydu;
-      w+=dwdu;
-    }
-    x0+=dxdv;
-    y0+=dydv;
-    w0+=dwdv;
-  }
-  bestx=p[2][2][0];
-  besty=p[2][2][1];
-  best_match=qr_alignment_pattern_fetch(p,bestx,besty,_img,_width,_height);
-  best_dist=qr_hamming_dist(best_match,0x1F8D63F,25);
-  if(best_dist>0){
-    u=_u-_cell->u0;
-    v=_v-_cell->v0;
-    x=_cell->fwd[0][0]*u+_cell->fwd[0][1]*v+_cell->fwd[0][2]<<QR_ALIGN_SUBPREC;
-    y=_cell->fwd[1][0]*u+_cell->fwd[1][1]*v+_cell->fwd[1][2]<<QR_ALIGN_SUBPREC;
-    w=_cell->fwd[2][0]*u+_cell->fwd[2][1]*v+_cell->fwd[2][2]<<QR_ALIGN_SUBPREC;
-    /*Search an area at most _r modules around the target location, in
-       concentric squares..*/
-    for(i=1;i<_r<<QR_ALIGN_SUBPREC;i++){
-      int side_len;
-      side_len=(i<<1)-1;
-      x-=dxdu+dxdv;
-      y-=dydu+dydv;
-      w-=dwdu+dwdv;
-      for(j=0;j<4*side_len;j++){
-        int      dir;
-        qr_hom_cell_fproject(pc,_cell,x,y,w);
-        match=qr_alignment_pattern_fetch(p,pc[0],pc[1],_img,_width,_height);
-        dist=qr_hamming_dist(match,0x1F8D63F,best_dist+1);
-        if(dist<best_dist){
-          best_match=match;
-          best_dist=dist;
-          bestx=pc[0];
-          besty=pc[1];
-        }
-        if(j<2*side_len){
-          dir=j>=side_len;
-          x+=_cell->fwd[0][dir];
-          y+=_cell->fwd[1][dir];
-          w+=_cell->fwd[2][dir];
-        }
-        else{
-          dir=j>=3*side_len;
-          x-=_cell->fwd[0][dir];
-          y-=_cell->fwd[1][dir];
-          w-=_cell->fwd[2][dir];
-        }
-        if(!best_dist)break;
-      }
-      if(!best_dist)break;
-    }
-  }
-  /*If the best result we got was sufficiently bad, reject the match.
-    If we're wrong and we include it, we can grossly distort the nearby
-     region, whereas using the initial starting point should at least be
-     consistent with the geometry we already have.*/
-  if(best_dist>6){
-    _p[0]=p[2][2][0];
-    _p[1]=p[2][2][1];
-    return -1;
-  }
-  /*Now try to get a more accurate location of the pattern center.*/
-  dx=bestx-p[2][2][0];
-  dy=besty-p[2][2][1];
-  memset(nc,0,sizeof(nc));
-  memset(c,0,sizeof(c));
-  /*We consider 8 lines across the finder pattern in turn.
-    If we actually found a symmetric pattern along that line, search for its
-     exact center in the image.
-    There are plenty more lines we could use if these don't work, but if we've
-     found anything remotely close to an alignment pattern, we should be able
-     to use most of these.*/
-  for(i=0;i<8;i++){
-    static const unsigned MASK_TESTS[8][2]={
-      {0x1040041,0x1000001},{0x0041040,0x0001000},
-      {0x0110110,0x0100010},{0x0011100,0x0001000},
-      {0x0420084,0x0400004},{0x0021080,0x0001000},
-      {0x0006C00,0x0004400},{0x0003800,0x0001000},
-    };
-    static const unsigned char MASK_COORDS[8][2]={
-      {0,0},{1,1},{4,0},{3,1},{2,0},{2,1},{0,2},{1,2}
-    };
-    if((best_match&MASK_TESTS[i][0])==MASK_TESTS[i][1]){
-      int x0;
-      int y0;
-      int x1;
-      int y1;
-      x0=p[MASK_COORDS[i][1]][MASK_COORDS[i][0]][0]+dx>>QR_FINDER_SUBPREC;
-      if(x0<0||x0>=_width)continue;
-      y0=p[MASK_COORDS[i][1]][MASK_COORDS[i][0]][1]+dy>>QR_FINDER_SUBPREC;
-      if(y0<0||y0>=_height)continue;
-      x1=p[4-MASK_COORDS[i][1]][4-MASK_COORDS[i][0]][0]+dx>>QR_FINDER_SUBPREC;
-      if(x1<0||x1>=_width)continue;
-      y1=p[4-MASK_COORDS[i][1]][4-MASK_COORDS[i][0]][1]+dy>>QR_FINDER_SUBPREC;
-      if(y1<0||y1>=_height)continue;
-      if(!qr_finder_locate_crossing(_img,_width,_height,x0,y0,x1,y1,i&1,pc)){
-        int w;
-        int cx;
-        int cy;
-        cx=pc[0]-bestx;
-        cy=pc[1]-besty;
-        if(i&1){
-          /*Weight crossings around the center dot more highly, as they are
-             generally more reliable.*/
-          w=3;
-          cx+=cx<<1;
-          cy+=cy<<1;
-        }
-        else w=1;
-        nc[i>>1]+=w;
-        c[i>>1][0]+=cx;
-        c[i>>1][1]+=cy;
-      }
-    }
-  }
-  /*Sum offsets from lines in orthogonal directions.*/
-  for(i=0;i<2;i++){
-    int a;
-    int b;
-    a=nc[i<<1];
-    b=nc[i<<1|1];
-    if(a&&b){
-      int w;
-      w=QR_MAXI(a,b);
-      c[i<<1][0]=QR_DIVROUND(w*(b*c[i<<1][0]+a*c[i<<1|1][0]),a*b);
-      c[i<<1][1]=QR_DIVROUND(w*(b*c[i<<1][1]+a*c[i<<1|1][1]),a*b);
-      nc[i<<1]=w<<1;
-    }
-    else{
-      c[i<<1][0]+=c[i<<1|1][0];
-      c[i<<1][1]+=c[i<<1|1][1];
-      nc[i<<1]+=b;
-    }
-  }
-  /*Average offsets from pairs of orthogonal lines.*/
-  c[0][0]+=c[2][0];
-  c[0][1]+=c[2][1];
-  nc[0]+=nc[2];
-  /*If we actually found any such lines, apply the adjustment.*/
-  if(nc[0]){
-    dx=QR_DIVROUND(c[0][0],nc[0]);
-    dy=QR_DIVROUND(c[0][1],nc[0]);
-    /*But only if it doesn't make things worse.*/
-    match=qr_alignment_pattern_fetch(p,bestx+dx,besty+dy,_img,_width,_height);
-    dist=qr_hamming_dist(match,0x1F8D63F,best_dist+1);
-    if(dist<=best_dist){
-      bestx+=dx;
-      besty+=dy;
-    }
-  }
-  _p[0]=bestx;
-  _p[1]=besty;
-  return 0;
-}
-
-static int qr_hom_fit(qr_hom *_hom,qr_finder *_ul,qr_finder *_ur,
- qr_finder *_dl,qr_point _p[4],const qr_aff *_aff,isaac_ctx *_isaac,
- const unsigned char *_img,int _width,int _height){
-  qr_point *b;
-  int       nb;
-  int       cb;
-  qr_point *r;
-  int       nr;
-  int       cr;
-  qr_line   l[4];
-  qr_point  q;
-  qr_point  p;
-  int       ox;
-  int       oy;
-  int       ru;
-  int       rv;
-  int       dru;
-  int       drv;
-  int       bu;
-  int       bv;
-  int       dbu;
-  int       dbv;
-  int       rx;
-  int       ry;
-  int       drxi;
-  int       dryi;
-  int       drxj;
-  int       dryj;
-  int       rdone;
-  int       nrempty;
-  int       rlastfit;
-  int       bx;
-  int       by;
-  int       dbxi;
-  int       dbyi;
-  int       dbxj;
-  int       dbyj;
-  int       bdone;
-  int       nbempty;
-  int       blastfit;
-  int       shift;
-  int       round;
-  int       version4;
-  int       brx;
-  int       bry;
-  int       i;
-  /*We attempt to correct large-scale perspective distortion by fitting lines
-     to the edge of the code area.
-    We could also look for an alignment pattern now, but that wouldn't work for
-     version 1 codes, which have no alignment pattern.
-    Even if the code is supposed to have one, there's go guarantee we'd find it
-     intact.*/
-  /*Fitting lines is easy for the edges on which we have two finder patterns.
-    After the fit, UL is guaranteed to be on the proper side, but if either of
-     the other two finder patterns aren't, something is wrong.*/
-  qr_finder_ransac(_ul,_aff,_isaac,0);
-  qr_finder_ransac(_dl,_aff,_isaac,0);
-  qr_line_fit_finder_pair(l[0],_aff,_ul,_dl,0);
-  if(qr_line_eval(l[0],_dl->c->pos[0],_dl->c->pos[1])<0||
-   qr_line_eval(l[0],_ur->c->pos[0],_ur->c->pos[1])<0){
-    return -1;
-  }
-  qr_finder_ransac(_ul,_aff,_isaac,2);
-  qr_finder_ransac(_ur,_aff,_isaac,2);
-  qr_line_fit_finder_pair(l[2],_aff,_ul,_ur,2);
-  if(qr_line_eval(l[2],_dl->c->pos[0],_dl->c->pos[1])<0||
-   qr_line_eval(l[2],_ur->c->pos[0],_ur->c->pos[1])<0){
-    return -1;
-  }
-  /*The edges which only have one finder pattern are more difficult.
-    We start by fitting a line to the edge of the one finder pattern we do
-     have.
-    This can fail due to an insufficient number of sample points, and even if
-     it succeeds can be fairly inaccurate, because all of the points are
-     clustered in one corner of the QR code.
-    If it fails, we just use an axis-aligned line in the affine coordinate
-     system.
-    Then we walk along the edge of the entire code, looking for
-     light:dark:light patterns perpendicular to the edge.
-    Wherever we find one, we take the center of the dark portion as an
-     additional sample point.
-    At the end, we re-fit the line using all such sample points found.*/
-  drv=_ur->size[1]>>1;
-  qr_finder_ransac(_ur,_aff,_isaac,1);
-  if(qr_line_fit_finder_edge(l[1],_ur,1,_aff->res)>=0){
-    if(qr_line_eval(l[1],_ul->c->pos[0],_ul->c->pos[1])<0||
-     qr_line_eval(l[1],_dl->c->pos[0],_dl->c->pos[1])<0){
-      return -1;
-    }
-    /*Figure out the change in ru for a given change in rv when stepping along
-       the fitted line.*/
-    if(qr_aff_line_step(_aff,l[1],1,drv,&dru)<0)return -1;
-  }
-  else dru=0;
-  ru=_ur->o[0]+3*_ur->size[0]-2*dru;
-  rv=_ur->o[1]-2*drv;
-  dbu=_dl->size[0]>>1;
-  qr_finder_ransac(_dl,_aff,_isaac,3);
-  if(qr_line_fit_finder_edge(l[3],_dl,3,_aff->res)>=0){
-    if(qr_line_eval(l[3],_ul->c->pos[0],_ul->c->pos[1])<0||
-     qr_line_eval(l[3],_ur->c->pos[0],_ur->c->pos[1])<0){
-      return -1;
-    }
-    /*Figure out the change in bv for a given change in bu when stepping along
-       the fitted line.*/
-    if(qr_aff_line_step(_aff,l[3],0,dbu,&dbv)<0)return -1;
-  }
-  else dbv=0;
-  bu=_dl->o[0]-2*dbu;
-  bv=_dl->o[1]+3*_dl->size[1]-2*dbv;
-  /*Set up the initial point lists.*/
-  nr=rlastfit=_ur->ninliers[1];
-  cr=nr+(_dl->o[1]-rv+drv-1)/drv;
-  r=(qr_point *)malloc(cr*sizeof(*r));
-  for(i=0;i<_ur->ninliers[1];i++){
-    memcpy(r[i],_ur->edge_pts[1][i].pos,sizeof(r[i]));
-  }
-  nb=blastfit=_dl->ninliers[3];
-  cb=nb+(_ur->o[0]-bu+dbu-1)/dbu;
-  b=(qr_point *)malloc(cb*sizeof(*b));
-  for(i=0;i<_dl->ninliers[3];i++){
-    memcpy(b[i],_dl->edge_pts[3][i].pos,sizeof(b[i]));
-  }
-  /*Set up the step parameters for the affine projection.*/
-  ox=(_aff->x0<<_aff->res)+(1<<_aff->res-1);
-  oy=(_aff->y0<<_aff->res)+(1<<_aff->res-1);
-  rx=_aff->fwd[0][0]*ru+_aff->fwd[0][1]*rv+ox;
-  ry=_aff->fwd[1][0]*ru+_aff->fwd[1][1]*rv+oy;
-  drxi=_aff->fwd[0][0]*dru+_aff->fwd[0][1]*drv;
-  dryi=_aff->fwd[1][0]*dru+_aff->fwd[1][1]*drv;
-  drxj=_aff->fwd[0][0]*_ur->size[0];
-  dryj=_aff->fwd[1][0]*_ur->size[0];
-  bx=_aff->fwd[0][0]*bu+_aff->fwd[0][1]*bv+ox;
-  by=_aff->fwd[1][0]*bu+_aff->fwd[1][1]*bv+oy;
-  dbxi=_aff->fwd[0][0]*dbu+_aff->fwd[0][1]*dbv;
-  dbyi=_aff->fwd[1][0]*dbu+_aff->fwd[1][1]*dbv;
-  dbxj=_aff->fwd[0][1]*_dl->size[1];
-  dbyj=_aff->fwd[1][1]*_dl->size[1];
-  /*Now step along the lines, looking for new sample points.*/
-  nrempty=nbempty=0;
-  for(;;){
-    int ret;
-    int x0;
-    int y0;
-    int x1;
-    int y1;
-    /*If we take too many steps without encountering a non-zero pixel, assume
-       we have wandered off the edge and stop looking before we hit the other
-       side of the quiet region.
-      Otherwise, stop when the lines cross (if they do so inside the affine
-       region) or come close to crossing (outside the affine region).
-      TODO: We don't have any way of detecting when we've wandered into the
-       code interior; we could stop if the outside sample ever shows up dark,
-       but this could happen because of noise in the quiet region, too.*/
-    rdone=rv>=QR_MINI(bv,_dl->o[1]+bv>>1)||nrempty>14;
-    bdone=bu>=QR_MINI(ru,_ur->o[0]+ru>>1)||nbempty>14;
-    if(!rdone&&(bdone||rv<bu)){
-      x0=rx+drxj>>_aff->res+QR_FINDER_SUBPREC;
-      y0=ry+dryj>>_aff->res+QR_FINDER_SUBPREC;
-      x1=rx-drxj>>_aff->res+QR_FINDER_SUBPREC;
-      y1=ry-dryj>>_aff->res+QR_FINDER_SUBPREC;
-      if(nr>=cr){
-        cr=cr<<1|1;
-        r=(qr_point *)realloc(r,cr*sizeof(*r));
-      }
-      ret=qr_finder_quick_crossing_check(_img,_width,_height,x0,y0,x1,y1,1);
-      if(!ret){
-        ret=qr_finder_locate_crossing(_img,_width,_height,x0,y0,x1,y1,1,r[nr]);
-      }
-      if(ret>=0){
-        if(!ret){
-          qr_aff_unproject(q,_aff,r[nr][0],r[nr][1]);
-          /*Move the current point halfway towards the crossing.
-            We don't move the whole way to give us some robustness to noise.*/
-          ru=ru+q[0]>>1;
-          /*But ensure that rv monotonically increases.*/
-          if(q[1]+drv>rv)rv=rv+q[1]>>1;
-          rx=_aff->fwd[0][0]*ru+_aff->fwd[0][1]*rv+ox;
-          ry=_aff->fwd[1][0]*ru+_aff->fwd[1][1]*rv+oy;
-          nr++;
-          /*Re-fit the line to update the step direction periodically.*/
-          if(nr>QR_MAXI(1,rlastfit+(rlastfit>>2))){
-            qr_line_fit_points(l[1],r,nr,_aff->res);
-            if(qr_aff_line_step(_aff,l[1],1,drv,&dru)>=0){
-              drxi=_aff->fwd[0][0]*dru+_aff->fwd[0][1]*drv;
-              dryi=_aff->fwd[1][0]*dru+_aff->fwd[1][1]*drv;
-            }
-            rlastfit=nr;
-          }
-        }
-        else nrempty=0;
-      }
-      else nrempty++;
-      ru+=dru;
-      /*Our final defense: if we overflow, stop.*/
-      if(rv+drv>rv)rv+=drv;
-      else nrempty=INT_MAX;
-      rx+=drxi;
-      ry+=dryi;
-    }
-    else if(!bdone){
-      x0=bx+dbxj>>_aff->res+QR_FINDER_SUBPREC;
-      y0=by+dbyj>>_aff->res+QR_FINDER_SUBPREC;
-      x1=bx-dbxj>>_aff->res+QR_FINDER_SUBPREC;
-      y1=by-dbyj>>_aff->res+QR_FINDER_SUBPREC;
-      if(nb>=cb){
-        cb=cb<<1|1;
-        b=(qr_point *)realloc(b,cb*sizeof(*b));
-      }
-      ret=qr_finder_quick_crossing_check(_img,_width,_height,x0,y0,x1,y1,1);
-      if(!ret){
-        ret=qr_finder_locate_crossing(_img,_width,_height,x0,y0,x1,y1,1,b[nb]);
-      }
-      if(ret>=0){
-        if(!ret){
-          qr_aff_unproject(q,_aff,b[nb][0],b[nb][1]);
-          /*Move the current point halfway towards the crossing.
-            We don't move the whole way to give us some robustness to noise.*/
-          /*But ensure that bu monotonically increases.*/
-          if(q[0]+dbu>bu)bu=bu+q[0]>>1;
-          bv=bv+q[1]>>1;
-          bx=_aff->fwd[0][0]*bu+_aff->fwd[0][1]*bv+ox;
-          by=_aff->fwd[1][0]*bu+_aff->fwd[1][1]*bv+oy;
-          nb++;
-          /*Re-fit the line to update the step direction periodically.*/
-          if(nb>QR_MAXI(1,blastfit+(blastfit>>2))){
-            qr_line_fit_points(l[3],b,nb,_aff->res);
-            if(qr_aff_line_step(_aff,l[3],0,dbu,&dbv)>=0){
-              dbxi=_aff->fwd[0][0]*dbu+_aff->fwd[0][1]*dbv;
-              dbyi=_aff->fwd[1][0]*dbu+_aff->fwd[1][1]*dbv;
-            }
-            blastfit=nb;
-          }
-        }
-        nbempty=0;
-      }
-      else nbempty++;
-      /*Our final defense: if we overflow, stop.*/
-      if(bu+dbu>bu)bu+=dbu;
-      else nbempty=INT_MAX;
-      bv+=dbv;
-      bx+=dbxi;
-      by+=dbyi;
-    }
-    else break;
-  }
-  /*Fit the new lines.
-    If we _still_ don't have enough sample points, then just use an
-     axis-aligned line from the affine coordinate system (e.g., one parallel
-     to the opposite edge in the image).*/
-  if(nr>1)qr_line_fit_points(l[1],r,nr,_aff->res);
-  else{
-    qr_aff_project(p,_aff,_ur->o[0]+3*_ur->size[0],_ur->o[1]);
-    shift=QR_MAXI(0,
-     qr_ilog(QR_MAXI(abs(_aff->fwd[0][1]),abs(_aff->fwd[1][1])))
-     -(_aff->res+1>>1));
-    round=(1<<shift)>>1;
-    l[1][0]=_aff->fwd[1][1]+round>>shift;
-    l[1][1]=-_aff->fwd[0][1]+round>>shift;
-    l[1][2]=-(l[1][0]*p[0]+l[1][1]*p[1]);
-  }
-  free(r);
-  if(nb>1)qr_line_fit_points(l[3],b,nb,_aff->res);
-  else{
-    qr_aff_project(p,_aff,_dl->o[0],_dl->o[1]+3*_dl->size[1]);
-    shift=QR_MAXI(0,
-     qr_ilog(QR_MAXI(abs(_aff->fwd[0][1]),abs(_aff->fwd[1][1])))
-     -(_aff->res+1>>1));
-    round=(1<<shift)>>1;
-    l[3][0]=_aff->fwd[1][0]+round>>shift;
-    l[3][1]=-_aff->fwd[0][0]+round>>shift;
-    l[3][2]=-(l[1][0]*p[0]+l[1][1]*p[1]);
-  }
-  free(b);
-  for(i=0;i<4;i++){
-    if(qr_line_isect(_p[i],l[i&1],l[2+(i>>1)])<0)return -1;
-    /*It's plausible for points to be somewhat outside the image, but too far
-       and too much of the pattern will be gone for it to be decodable.*/
-    if(_p[i][0]<-_width<<QR_FINDER_SUBPREC||
-     _p[i][0]>=_width<<QR_FINDER_SUBPREC+1||
-     _p[i][1]<-_height<<QR_FINDER_SUBPREC||
-     _p[i][1]>=_height<<QR_FINDER_SUBPREC+1){
-      return -1;
-    }
-  }
-  /*By default, use the edge intersection point for the bottom-right corner.*/
-  brx=_p[3][0];
-  bry=_p[3][1];
-  /*However, if our average version estimate is greater than 1, NOW we try to
-     search for an alignment pattern.
-    We get a much better success rate by doing this after our initial attempt
-     to promote the transform to a homography than before.
-    You might also think it would be more reliable to use the interior finder
-     pattern edges, since the outer ones may be obscured or damaged, and it
-     would save us a reprojection below, since they would form a nice square
-     with the location of the alignment pattern, but this turns out to be a bad
-     idea.
-    Non-linear distortion is usually maximal on the outside edge, and thus
-     estimating the grid position from points on the interior means we might
-     get mis-aligned by the time we reach the edge.*/
-  version4=_ul->eversion[0]+_ul->eversion[1]+_ur->eversion[0]+_dl->eversion[1];
-  if(version4>4){
-    qr_hom_cell cell;
-    qr_point    p3;
-    int         dim;
-    dim=17+version4;
-    qr_hom_cell_init(&cell,0,0,dim-1,0,0,dim-1,dim-1,dim-1,
-     _p[0][0],_p[0][1],_p[1][0],_p[1][1],
-     _p[2][0],_p[2][1],_p[3][0],_p[3][1]);
-    if(qr_alignment_pattern_search(p3,&cell,dim-7,dim-7,4,
-     _img,_width,_height)>=0){
-      int c21;
-      int dx21;
-      int dy21;
-      int mask;
-      int w;
-      /*There's no real need to update the bounding box corner, and in fact we
-         actively perform worse if we do.
-        Clearly it was good enough for us to find this alignment pattern, so
-         it should be good enough to use for grid initialization.
-        The point of doing the search was to get more accurate version
-         estimates and a better chance of decoding the version and format info.
-        This is particularly important for small versions that have no encoded
-         version info, since any mismatch in version renders the code
-         undecodable.*/
-      /*We do, however, need four points in a square to initialize our
-         homography, so project the point from the alignment center to the
-         corner of the code area.*/
-      c21=_p[2][0]*_p[1][1]-_p[2][1]*_p[1][0];
-      dx21=_p[2][0]-_p[1][0];
-      dy21=_p[2][1]-_p[1][1];
-      w=(dim-7)*c21
-       +(dim-13)*(_p[0][0]*dy21-_p[0][1]*dx21)+6*(p3[0]*dy21-p3[1]*dx21);
-      mask=QR_SIGNMASK(w);
-      w=abs(w);
-      brx=(int)QR_DIVROUND(QR_EXTMUL((dim-7)*_p[0][0],p3[0]*dy21,
-       QR_EXTMUL((dim-13)*p3[0],c21-_p[0][1]*dx21,
-       QR_EXTMUL(6*_p[0][0],c21-p3[1]*dx21,0)))+mask^mask,w);
-      bry=(int)QR_DIVROUND(QR_EXTMUL((dim-7)*_p[0][1],-p3[1]*dx21,
-       QR_EXTMUL((dim-13)*p3[1],c21+_p[0][0]*dy21,
-       QR_EXTMUL(6*_p[0][1],c21+p3[0]*dy21,0)))+mask^mask,w);
-    }
-  }
-  /*Now we have four points that map to a square: initialize the projection.*/
-  qr_hom_init(_hom,_p[0][0],_p[0][1],_p[1][0],_p[1][1],
-   _p[2][0],_p[2][1],brx,bry,QR_HOM_BITS);
-  return 0;
-}
-
-
-
-/*The BCH(18,6,3) codes are only used for version information, which must lie
-   between 7 and 40 (inclusive).*/
-static const unsigned BCH18_6_CODES[34]={
-                                                          0x07C94,
-  0x085BC,0x09A99,0x0A4D3,0x0BBF6,0x0C762,0x0D847,0x0E60D,0x0F928,
-  0x10B78,0x1145D,0x12A17,0x13532,0x149A6,0x15683,0x168C9,0x177EC,
-  0x18EC4,0x191E1,0x1AFAB,0x1B08E,0x1CC1A,0x1D33F,0x1ED75,0x1F250,
-  0x209D5,0x216F0,0x228BA,0x2379F,0x24B0B,0x2542E,0x26A64,0x27541,
-  0x28C69
-};
-
-/*Corrects a BCH(18,6,3) code word.
-  _y: Contains the code word to be checked on input, and the corrected value on
-       output.
-  Return: The number of errors.
-          If more than 3 errors are detected, returns a negative value and
-           performs no correction.*/
-static int bch18_6_correct(unsigned *_y){
-  unsigned x;
-  unsigned y;
-  int      nerrs;
-  y=*_y;
-  /*Check the easy case first: see if the data bits were uncorrupted.*/
-  x=y>>12;
-  if(x>=7&&x<=40){
-    nerrs=qr_hamming_dist(y,BCH18_6_CODES[x-7],4);
-    if(nerrs<4){
-      *_y=BCH18_6_CODES[x-7];
-      return nerrs;
-    }
-  }
-  /*Exhaustive search is faster than field operations in GF(19).*/
-  for(x=0;x<34;x++)if(x+7!=y>>12){
-    nerrs=qr_hamming_dist(y,BCH18_6_CODES[x],4);
-    if(nerrs<4){
-      *_y=BCH18_6_CODES[x];
-      return nerrs;
-    }
-  }
-  return -1;
-}
-
-#if 0
-static unsigned bch18_6_encode(unsigned _x){
-  return (-(_x&1)&0x01F25)^(-(_x>>1&1)&0x0216F)^(-(_x>>2&1)&0x042DE)^
-   (-(_x>>3&1)&0x085BC)^(-(_x>>4&1)&0x10B78)^(-(_x>>5&1)&0x209D5);
-}
-#endif
-
-/*Reads the version bits near a finder module and decodes the version number.*/
-static int qr_finder_version_decode(qr_finder *_f,const qr_hom *_hom,
- const unsigned char *_img,int _width,int _height,int _dir){
-  qr_point q;
-  unsigned v;
-  int      x0;
-  int      y0;
-  int      w0;
-  int      dxi;
-  int      dyi;
-  int      dwi;
-  int      dxj;
-  int      dyj;
-  int      dwj;
-  int      ret;
-  int      i;
-  int      j;
-  int      k;
-  v=0;
-  q[_dir]=_f->o[_dir]-7*_f->size[_dir];
-  q[1-_dir]=_f->o[1-_dir]-3*_f->size[1-_dir];
-  x0=_hom->fwd[0][0]*q[0]+_hom->fwd[0][1]*q[1];
-  y0=_hom->fwd[1][0]*q[0]+_hom->fwd[1][1]*q[1];
-  w0=_hom->fwd[2][0]*q[0]+_hom->fwd[2][1]*q[1]+_hom->fwd22;
-  dxi=_hom->fwd[0][1-_dir]*_f->size[1-_dir];
-  dyi=_hom->fwd[1][1-_dir]*_f->size[1-_dir];
-  dwi=_hom->fwd[2][1-_dir]*_f->size[1-_dir];
-  dxj=_hom->fwd[0][_dir]*_f->size[_dir];
-  dyj=_hom->fwd[1][_dir]*_f->size[_dir];
-  dwj=_hom->fwd[2][_dir]*_f->size[_dir];
-  for(k=i=0;i<6;i++){
-    int x;
-    int y;
-    int w;
-    x=x0;
-    y=y0;
-    w=w0;
-    for(j=0;j<3;j++,k++){
-      qr_point p;
-      qr_hom_fproject(p,_hom,x,y,w);
-      v|=qr_img_get_bit(_img,_width,_height,p[0],p[1])<<k;
-      x+=dxj;
-      y+=dyj;
-      w+=dwj;
-    }
-    x0+=dxi;
-    y0+=dyi;
-    w0+=dwi;
-  }
-  ret=bch18_6_correct(&v);
-  /*TODO: I'd certainly hope the order the version bits is accessed in is
-     well-defined, but I seem to have images for two different codes with the
-     same version using two different orders?
-    Maybe the other one is a model 1 code?
-    Even if I parse the version here, I can't decode the rest of the code.
-    If this is really needed, we should just re-order the bits.*/
-#if 0
-  if(ret<0){
-    /*17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
-       0  3  6  9 12 15  1  4  7 10 13 16  2  5  8 11 14 17
-      17 13  9  5  1 -3 10  6  2 -2 -6-10  3 -1 -5 -9-13-17*/
-    v=0;
-    for(k=i=0;i<3;i++){
-      p[_dir]=_f->o[_dir]+_f->size[_dir]*(-5-i);
-      for(j=0;j<6;j++,k++){
-        qr_point q;
-        p[1-_dir]=_f->o[1-_dir]+_f->size[1-_dir]*(2-j);
-        qr_hom_project(q,_hom,p[0],p[1]);
-        v|=qr_img_get_bit(_img,_width,_height,q[0],q[1])<<k;
-      }
-    }
-    ret=bch18_6_correct(&v);
-  }
-#endif
-  return ret>=0?(int)(v>>12):ret;
-}
-
-/*Reads the format info bits near the finder modules and decodes them.*/
-static int qr_finder_fmt_info_decode(qr_finder *_ul,qr_finder *_ur,
- qr_finder *_dl,const qr_hom *_hom,
- const unsigned char *_img,int _width,int _height){
-  qr_point p;
-  unsigned lo[2];
-  unsigned hi[2];
-  int      u;
-  int      v;
-  int      x;
-  int      y;
-  int      w;
-  int      dx;
-  int      dy;
-  int      dw;
-  int      fmt_info[4];
-  int      count[4];
-  int      nerrs[4];
-  int      nfmt_info;
-  int      besti;
-  int      imax;
-  int      di;
-  int      i;
-  int      k;
-  /*Read the bits around the UL corner.*/
-  lo[0]=0;
-  u=_ul->o[0]+5*_ul->size[0];
-  v=_ul->o[1]-3*_ul->size[1];
-  x=_hom->fwd[0][0]*u+_hom->fwd[0][1]*v;
-  y=_hom->fwd[1][0]*u+_hom->fwd[1][1]*v;
-  w=_hom->fwd[2][0]*u+_hom->fwd[2][1]*v+_hom->fwd22;
-  dx=_hom->fwd[0][1]*_ul->size[1];
-  dy=_hom->fwd[1][1]*_ul->size[1];
-  dw=_hom->fwd[2][1]*_ul->size[1];
-  for(k=i=0;;i++){
-    /*Skip the timing pattern row.*/
-    if(i!=6){
-      qr_hom_fproject(p,_hom,x,y,w);
-      lo[0]|=qr_img_get_bit(_img,_width,_height,p[0],p[1])<<k++;
-      /*Don't advance q in the last iteration... we'll start the next loop from
-         the current position.*/
-      if(i>=8)break;
-    }
-    x+=dx;
-    y+=dy;
-    w+=dw;
-  }
-  hi[0]=0;
-  dx=-_hom->fwd[0][0]*_ul->size[0];
-  dy=-_hom->fwd[1][0]*_ul->size[0];
-  dw=-_hom->fwd[2][0]*_ul->size[0];
-  while(i-->0){
-    x+=dx;
-    y+=dy;
-    w+=dw;
-    /*Skip the timing pattern column.*/
-    if(i!=6){
-      qr_hom_fproject(p,_hom,x,y,w);
-      hi[0]|=qr_img_get_bit(_img,_width,_height,p[0],p[1])<<k++;
-    }
-  }
-  /*Read the bits next to the UR corner.*/
-  lo[1]=0;
-  u=_ur->o[0]+3*_ur->size[0];
-  v=_ur->o[1]+5*_ur->size[1];
-  x=_hom->fwd[0][0]*u+_hom->fwd[0][1]*v;
-  y=_hom->fwd[1][0]*u+_hom->fwd[1][1]*v;
-  w=_hom->fwd[2][0]*u+_hom->fwd[2][1]*v+_hom->fwd22;
-  dx=-_hom->fwd[0][0]*_ur->size[0];
-  dy=-_hom->fwd[1][0]*_ur->size[0];
-  dw=-_hom->fwd[2][0]*_ur->size[0];
-  for(k=0;k<8;k++){
-    qr_hom_fproject(p,_hom,x,y,w);
-    lo[1]|=qr_img_get_bit(_img,_width,_height,p[0],p[1])<<k;
-    x+=dx;
-    y+=dy;
-    w+=dw;
-  }
-  /*Read the bits next to the DL corner.*/
-  hi[1]=0;
-  u=_dl->o[0]+5*_dl->size[0];
-  v=_dl->o[1]-3*_dl->size[1];
-  x=_hom->fwd[0][0]*u+_hom->fwd[0][1]*v;
-  y=_hom->fwd[1][0]*u+_hom->fwd[1][1]*v;
-  w=_hom->fwd[2][0]*u+_hom->fwd[2][1]*v+_hom->fwd22;
-  dx=_hom->fwd[0][1]*_dl->size[1];
-  dy=_hom->fwd[1][1]*_dl->size[1];
-  dw=_hom->fwd[2][1]*_dl->size[1];
-  for(k=8;k<15;k++){
-    qr_hom_fproject(p,_hom,x,y,w);
-    hi[1]|=qr_img_get_bit(_img,_width,_height,p[0],p[1])<<k;
-    x+=dx;
-    y+=dy;
-    w+=dw;
-  }
-  /*For the 8th bit we have 3 samples... use the majority value.
-    TODO: The DL bit appears to be wrong as much as right? Guess it's not
-     really a third copy after all, but doesn't appear to be used for data.
-  i=((lo[0]>>7&1)+(lo[1]>>7&1)+(hi[1]>>7&1)>>1)<<7;
-  lo[0]=lo[0]&~0x80|i;
-  lo[1]=lo[1]&~0x80|i;
-  hi[1]&=~0x80;*/
-  /*For the remaining bits we have two samples... try them in all
-     combinations and pick the most popular valid code, breaking ties using
-     the number of bit errors.*/
-  imax=2<<(hi[0]!=hi[1]);
-  di=1+(lo[0]==lo[1]);
-  nfmt_info=0;
-  for(i=0;i<imax;i+=di){
-    unsigned v;
-    int      ret;
-    int      j;
-    v=(lo[i&1]|hi[i>>1])^0x5412;
-    ret=bch15_5_correct(&v);
-    v>>=10;
-    if(ret<0)ret=4;
-    for(j=0;;j++){
-      if(j>=nfmt_info){
-        fmt_info[j]=v;
-        count[j]=1;
-        nerrs[j]=ret;
-        nfmt_info++;
-        break;
-      }
-      if(fmt_info[j]==(int)v){
-        count[j]++;
-        if(ret<nerrs[j])nerrs[j]=ret;
-        break;
-      }
-    }
-  }
-  besti=0;
-  for(i=1;i<nfmt_info;i++){
-    if(nerrs[besti]>3&&nerrs[i]<=3||
-     count[i]>count[besti]||count[i]==count[besti]&&nerrs[i]<nerrs[besti]){
-      besti=i;
-    }
-  }
-  return nerrs[besti]<4?fmt_info[besti]:-1;
-}
-
-
-
-/*The grid used to sample the image bits.
-  The grid is divided into separate cells bounded by finder patterns and/or
-   alignment patterns, and a separate map back to the original image is
-   constructed for each cell.
-  All of these structural elements, as well as the timing patterns, version
-   info, and format info, are marked in fpmask so they can easily be skipped
-   during decode.*/
-struct qr_sampling_grid{
-  qr_hom_cell    *cells[6];
-  unsigned       *fpmask;
-  int             cell_limits[6];
-  int             ncells;
-};
-
-
-/*Mark a given region as belonging to the function pattern.*/
-static void qr_sampling_grid_fp_mask_rect(qr_sampling_grid *_grid,int _dim,
- int _u,int _v,int _w,int _h){
-  int i;
-  int j;
-  int stride;
-  stride=_dim+QR_INT_BITS-1>>QR_INT_LOGBITS;
-  /*Note that we store bits column-wise, since that's how they're read out of
-     the grid.*/
-  for(j=_u;j<_u+_w;j++)for(i=_v;i<_v+_h;i++){
-    _grid->fpmask[j*stride+(i>>QR_INT_LOGBITS)]|=1<<(i&QR_INT_BITS-1);
-  }
-}
-
-/*Determine if a given grid location is inside the function pattern.*/
-static int qr_sampling_grid_is_in_fp(const qr_sampling_grid *_grid,int _dim,
- int _u,int _v){
-  return _grid->fpmask[_u*(_dim+QR_INT_BITS-1>>QR_INT_LOGBITS)
-   +(_v>>QR_INT_LOGBITS)]>>(_v&QR_INT_BITS-1)&1;
-}
-
-/*The spacing between alignment patterns after the second for versions >= 7.
-  We could compact this more, but the code to access it would eliminate the
-   gains.*/
-static const unsigned char QR_ALIGNMENT_SPACING[34]={
-  16,18,20,22,24,26,28,
-  20,22,24,24,26,28,28,
-  22,24,24,26,26,28,28,
-  24,24,26,26,26,28,28,
-  24,26,26,26,28,28
-};
-
-static inline void qr_svg_points(const char *cls,
-                                 qr_point *p,
-                                 int n)
-{
-    int i;
-    svg_path_start(cls, 1, 0, 0);
-    for(i = 0; i < n; i++, p++)
-        svg_path_moveto(SVG_ABS, p[0][0], p[0][1]);
-    svg_path_end();
-}
-
-/*Initialize the sampling grid for each region of the code.
-  _version:  The (decoded) version number.
-  _ul_pos:   The location of the UL finder pattern.
-  _ur_pos:   The location of the UR finder pattern.
-  _dl_pos:   The location of the DL finder pattern.
-  _p:        On input, contains estimated positions of the four corner modules.
-             On output, contains a bounding quadrilateral for the code.
-  _img:      The binary input image.
-  _width:    The width of the input image.
-  _height:   The height of the input image.
-  Return: 0 on success, or a negative value on error.*/
-static void qr_sampling_grid_init(qr_sampling_grid *_grid,int _version,
- const qr_point _ul_pos,const qr_point _ur_pos,const qr_point _dl_pos,
- qr_point _p[4],const unsigned char *_img,int _width,int _height){
-  qr_hom_cell          base_cell;
-  int                  align_pos[7];
-  int                  dim;
-  int                  nalign;
-  int                  i;
-  dim=17+(_version<<2);
-  nalign=(_version/7)+2;
-  /*Create a base cell to bootstrap the alignment pattern search.*/
-  qr_hom_cell_init(&base_cell,0,0,dim-1,0,0,dim-1,dim-1,dim-1,
-   _p[0][0],_p[0][1],_p[1][0],_p[1][1],_p[2][0],_p[2][1],_p[3][0],_p[3][1]);
-  /*Allocate the array of cells.*/
-  _grid->ncells=nalign-1;
-  _grid->cells[0]=(qr_hom_cell *)malloc(
-   (nalign-1)*(nalign-1)*sizeof(*_grid->cells[0]));
-  for(i=1;i<_grid->ncells;i++)_grid->cells[i]=_grid->cells[i-1]+_grid->ncells;
-  /*Initialize the function pattern mask.*/
-  _grid->fpmask=(unsigned *)calloc(dim,
-   (dim+QR_INT_BITS-1>>QR_INT_LOGBITS)*sizeof(*_grid->fpmask));
-  /*Mask out the finder patterns (and separators and format info bits).*/
-  qr_sampling_grid_fp_mask_rect(_grid,dim,0,0,9,9);
-  qr_sampling_grid_fp_mask_rect(_grid,dim,0,dim-8,9,8);
-  qr_sampling_grid_fp_mask_rect(_grid,dim,dim-8,0,8,9);
-  /*Mask out the version number bits.*/
-  if(_version>6){
-    qr_sampling_grid_fp_mask_rect(_grid,dim,0,dim-11,6,3);
-    qr_sampling_grid_fp_mask_rect(_grid,dim,dim-11,0,3,6);
-  }
-  /*Mask out the timing patterns.*/
-  qr_sampling_grid_fp_mask_rect(_grid,dim,9,6,dim-17,1);
-  qr_sampling_grid_fp_mask_rect(_grid,dim,6,9,1,dim-17);
-  /*If we have no alignment patterns (e.g., this is a version 1 code), just use
-     the base cell and hope it's good enough.*/
-  if(_version<2)memcpy(_grid->cells[0],&base_cell,sizeof(base_cell));
-  else{
-    qr_point *q;
-    qr_point *p;
-    int       j;
-    int       k;
-    q=(qr_point *)malloc(nalign*nalign*sizeof(*q));
-    p=(qr_point *)malloc(nalign*nalign*sizeof(*p));
-    /*Initialize the alignment pattern position list.*/
-    align_pos[0]=6;
-    align_pos[nalign-1]=dim-7;
-    if(_version>6){
-      int d;
-      d=QR_ALIGNMENT_SPACING[_version-7];
-      for(i=nalign-1;i-->1;)align_pos[i]=align_pos[i+1]-d;
-    }
-    /*Three of the corners use a finder pattern instead of a separate
-       alignment pattern.*/
-    q[0][0]=3;
-    q[0][1]=3;
-    p[0][0]=_ul_pos[0];
-    p[0][1]=_ul_pos[1];
-    q[nalign-1][0]=dim-4;
-    q[nalign-1][1]=3;
-    p[nalign-1][0]=_ur_pos[0];
-    p[nalign-1][1]=_ur_pos[1];
-    q[(nalign-1)*nalign][0]=3;
-    q[(nalign-1)*nalign][1]=dim-4;
-    p[(nalign-1)*nalign][0]=_dl_pos[0];
-    p[(nalign-1)*nalign][1]=_dl_pos[1];
-    /*Scan for alignment patterns using a diagonal sweep.*/
-    for(k=1;k<2*nalign-1;k++){
-      int jmin;
-      int jmax;
-      jmax=QR_MINI(k,nalign-1)-(k==nalign-1);
-      jmin=QR_MAXI(0,k-(nalign-1))+(k==nalign-1);
-      for(j=jmin;j<=jmax;j++){
-        qr_hom_cell *cell;
-        int          u;
-        int          v;
-        int          k;
-        i=jmax-(j-jmin);
-        k=i*nalign+j;
-        u=align_pos[j];
-        v=align_pos[i];
-        q[k][0]=u;
-        q[k][1]=v;
-        /*Mask out the alignment pattern.*/
-        qr_sampling_grid_fp_mask_rect(_grid,dim,u-2,v-2,5,5);
-        /*Pick a cell to use to govern the alignment pattern search.*/
-        if(i>1&&j>1){
-          qr_point p0;
-          qr_point p1;
-          qr_point p2;
-          /*Each predictor is basically a straight-line extrapolation from two
-             neighboring alignment patterns (except possibly near the opposing
-             finder patterns).*/
-          qr_hom_cell_project(p0,_grid->cells[i-2]+j-1,u,v,0);
-          qr_hom_cell_project(p1,_grid->cells[i-2]+j-2,u,v,0);
-          qr_hom_cell_project(p2,_grid->cells[i-1]+j-2,u,v,0);
-          /*Take the median of the predictions as the search center.*/
-          QR_SORT2I(p0[0],p1[0]);
-          QR_SORT2I(p0[1],p1[1]);
-          QR_SORT2I(p1[0],p2[0]);
-          QR_SORT2I(p1[1],p2[1]);
-          QR_SORT2I(p0[0],p1[0]);
-          QR_SORT2I(p0[1],p1[1]);
-          /*We need a cell that has the target point at a known (u,v) location.
-            Since our cells don't have inverses, just construct one from our
-             neighboring points.*/
-          cell=_grid->cells[i-1]+j-1;
-          qr_hom_cell_init(cell,
-           q[k-nalign-1][0],q[k-nalign-1][1],q[k-nalign][0],q[k-nalign][1],
-           q[k-1][0],q[k-1][1],q[k][0],q[k][1],
-           p[k-nalign-1][0],p[k-nalign-1][1],p[k-nalign][0],p[k-nalign][1],
-           p[k-1][0],p[k-1][1],p1[0],p1[1]);
-        }
-        else if(i>1&&j>0)cell=_grid->cells[i-2]+j-1;
-        else if(i>0&&j>1)cell=_grid->cells[i-1]+j-2;
-        else cell=&base_cell;
-        /*Use a very small search radius.
-          A large displacement here usually means a false positive (e.g., when
-           the real alignment pattern is damaged or missing), which can
-           severely distort the projection.*/
-        qr_alignment_pattern_search(p[k],cell,u,v,2,_img,_width,_height);
-        if(i>0&&j>0){
-          qr_hom_cell_init(_grid->cells[i-1]+j-1,
-           q[k-nalign-1][0],q[k-nalign-1][1],q[k-nalign][0],q[k-nalign][1],
-           q[k-1][0],q[k-1][1],q[k][0],q[k][1],
-           p[k-nalign-1][0],p[k-nalign-1][1],p[k-nalign][0],p[k-nalign][1],
-           p[k-1][0],p[k-1][1],p[k][0],p[k][1]);
-        }
-      }
-    }
-    qr_svg_points("align", p, nalign * nalign);
-    free(q);
-    free(p);
-  }
-  /*Set the limits over which each cell is used.*/
-  memcpy(_grid->cell_limits,align_pos+1,
-   (_grid->ncells-1)*sizeof(*_grid->cell_limits));
-  _grid->cell_limits[_grid->ncells-1]=dim;
-  /*Produce a bounding square for the code (to mark finder centers with).
-    Because of non-linear distortion, this might not actually bound the code,
-     but it should be good enough.
-    I don't think it's worth computing a convex hull or anything silly like
-     that.*/
-  qr_hom_cell_project(_p[0],_grid->cells[0]+0,-1,-1,1);
-  qr_hom_cell_project(_p[1],_grid->cells[0]+_grid->ncells-1,(dim<<1)-1,-1,1);
-  qr_hom_cell_project(_p[2],_grid->cells[_grid->ncells-1]+0,-1,(dim<<1)-1,1);
-  qr_hom_cell_project(_p[3],_grid->cells[_grid->ncells-1]+_grid->ncells-1,
-   (dim<<1)-1,(dim<<1)-1,1);
-  /*Clamp the points somewhere near the image (this is really just in case a
-     corner is near the plane at infinity).*/
-  for(i=0;i<4;i++){
-    _p[i][0]=QR_CLAMPI(-_width<<QR_FINDER_SUBPREC,_p[i][0],
-     _width<<QR_FINDER_SUBPREC+1);
-    _p[i][1]=QR_CLAMPI(-_height<<QR_FINDER_SUBPREC,_p[i][1],
-     _height<<QR_FINDER_SUBPREC+1);
-  }
-  /*TODO: Make fine adjustments using the timing patterns.
-    Possible strategy: scan the timing pattern at QR_ALIGN_SUBPREC (or finer)
-     resolution, use dynamic programming to match midpoints between
-     transitions to the ideal grid locations.*/
-}
-
-static void qr_sampling_grid_clear(qr_sampling_grid *_grid){
-  free(_grid->fpmask);
-  free(_grid->cells[0]);
-}
-
-
-
-#if defined(QR_DEBUG)
-static void qr_sampling_grid_dump(qr_sampling_grid *_grid,int _version,
- const unsigned char *_img,int _width,int _height){
-  unsigned char *gimg;
-  FILE          *fout;
-  int            dim;
-  int            u;
-  int            v;
-  int            x;
-  int            y;
-  int            w;
-  int            i;
-  int            j;
-  int            r;
-  int            s;
-  dim=17+(_version<<2)+8<<QR_ALIGN_SUBPREC;
-  gimg=(unsigned char *)malloc(dim*dim*sizeof(*gimg));
-  for(i=0;i<dim;i++)for(j=0;j<dim;j++){
-    qr_hom_cell *cell;
-    if(i>=(4<<QR_ALIGN_SUBPREC)&&i<=dim-(5<<QR_ALIGN_SUBPREC)&&
-     j>=(4<<QR_ALIGN_SUBPREC)&&j<=dim-(5<<QR_ALIGN_SUBPREC)&&
-     ((!(i&(1<<QR_ALIGN_SUBPREC)-1))^(!(j&(1<<QR_ALIGN_SUBPREC)-1)))){
-      gimg[i*dim+j]=0x7F;
-    }
-    else{
-      qr_point p;
-      u=(j>>QR_ALIGN_SUBPREC)-4;
-      v=(i>>QR_ALIGN_SUBPREC)-4;
-      for(r=0;r<_grid->ncells-1;r++)if(u<_grid->cell_limits[r])break;
-      for(s=0;s<_grid->ncells-1;s++)if(v<_grid->cell_limits[s])break;
-      cell=_grid->cells[s]+r;
-      u=j-(cell->u0+4<<QR_ALIGN_SUBPREC);
-      v=i-(cell->v0+4<<QR_ALIGN_SUBPREC);
-      x=cell->fwd[0][0]*u+cell->fwd[0][1]*v+(cell->fwd[0][2]<<QR_ALIGN_SUBPREC);
-      y=cell->fwd[1][0]*u+cell->fwd[1][1]*v+(cell->fwd[1][2]<<QR_ALIGN_SUBPREC);
-      w=cell->fwd[2][0]*u+cell->fwd[2][1]*v+(cell->fwd[2][2]<<QR_ALIGN_SUBPREC);
-      qr_hom_cell_fproject(p,cell,x,y,w);
-      gimg[i*dim+j]=_img[
-       QR_CLAMPI(0,p[1]>>QR_FINDER_SUBPREC,_height-1)*_width+
-       QR_CLAMPI(0,p[0]>>QR_FINDER_SUBPREC,_width-1)];
-    }
-  }
-  for(v=0;v<17+(_version<<2);v++)for(u=0;u<17+(_version<<2);u++){
-    if(qr_sampling_grid_is_in_fp(_grid,17+(_version<<2),u,v)){
-      j=u+4<<QR_ALIGN_SUBPREC;
-      i=v+4<<QR_ALIGN_SUBPREC;
-      gimg[(i-1)*dim+j-1]=0x7F;
-      gimg[(i-1)*dim+j]=0x7F;
-      gimg[(i-1)*dim+j+1]=0x7F;
-      gimg[i*dim+j-1]=0x7F;
-      gimg[i*dim+j+1]=0x7F;
-      gimg[(i+1)*dim+j-1]=0x7F;
-      gimg[(i+1)*dim+j]=0x7F;
-      gimg[(i+1)*dim+j+1]=0x7F;
-    }
-  }
-  fout=fopen("grid.png","wb");
-  image_write_png(gimg,dim,dim,fout);
-  fclose(fout);
-  free(gimg);
-}
-#endif
-
-/*Generate the data mask corresponding to the given mask pattern.*/
-static void qr_data_mask_fill(unsigned *_mask,int _dim,int _pattern){
-  int stride;
-  int i;
-  int j;
-  stride=_dim+QR_INT_BITS-1>>QR_INT_LOGBITS;
-  /*Note that we store bits column-wise, since that's how they're read out of
-     the grid.*/
-  switch(_pattern){
-    /*10101010 i+j+1&1
-      01010101
-      10101010
-      01010101*/
-    case 0:{
-      int m;
-      m=0x55;
-      for(j=0;j<_dim;j++){
-        memset(_mask+j*stride,m,stride*sizeof(*_mask));
-        m^=0xFF;
-      }
-    }break;
-    /*11111111 i+1&1
-      00000000
-      11111111
-      00000000*/
-    case 1:memset(_mask,0x55,_dim*stride*sizeof(*_mask));break;
-    /*10010010 (j+1)%3&1
-      10010010
-      10010010
-      10010010*/
-    case 2:{
-      unsigned m;
-      m=0xFF;
-      for(j=0;j<_dim;j++){
-        memset(_mask+j*stride,m&0xFF,stride*sizeof(*_mask));
-        m=m<<8|m>>16;
-      }
-    }break;
-    /*10010010 (i+j+1)%3&1
-      00100100
-      01001001
-      10010010*/
-    case 3:{
-      unsigned mi;
-      unsigned mj;
-      mj=0;
-      for(i=0;i<(QR_INT_BITS+2)/3;i++)mj|=1<<3*i;
-      for(j=0;j<_dim;j++){
-        mi=mj;
-        for(i=0;i<stride;i++){
-          _mask[j*stride+i]=mi;
-          mi=mi>>QR_INT_BITS%3|mi<<3-QR_INT_BITS%3;
-        }
-        mj=mj>>1|mj<<2;
-      }
-    }break;
-    /*11100011 (i>>1)+(j/3)+1&1
-      11100011
-      00011100
-      00011100*/
-    case 4:{
-      unsigned m;
-      m=7;
-      for(j=0;j<_dim;j++){
-        memset(_mask+j*stride,(0xCC^-(m&1))&0xFF,stride*sizeof(*_mask));
-        m=m>>1|m<<5;
-      }
-    }break;
-    /*11111111 !((i*j)%6)
-      10000010
-      10010010
-      10101010*/
-    case 5:{
-      for(j=0;j<_dim;j++){
-        unsigned m;
-        m=0;
-        for(i=0;i<6;i++)m|=!((i*j)%6)<<i;
-        for(i=6;i<QR_INT_BITS;i<<=1)m|=m<<i;
-        for(i=0;i<stride;i++){
-          _mask[j*stride+i]=m;
-          m=m>>QR_INT_BITS%6|m<<6-QR_INT_BITS%6;
-        }
-      }
-    }break;
-    /*11111111 (i*j)%3+i*j+1&1
-      11100011
-      11011011
-      10101010*/
-    case 6:{
-      for(j=0;j<_dim;j++){
-        unsigned m;
-        m=0;
-        for(i=0;i<6;i++)m|=((i*j)%3+i*j+1&1)<<i;
-        for(i=6;i<QR_INT_BITS;i<<=1)m|=m<<i;
-        for(i=0;i<stride;i++){
-          _mask[j*stride+i]=m;
-          m=m>>QR_INT_BITS%6|m<<6-QR_INT_BITS%6;
-        }
-      }
-    }break;
-    /*10101010 (i*j)%3+i+j+1&1
-      00011100
-      10001110
-      01010101*/
-    default:{
-      for(j=0;j<_dim;j++){
-        unsigned m;
-        m=0;
-        for(i=0;i<6;i++)m|=((i*j)%3+i+j+1&1)<<i;
-        for(i=6;i<QR_INT_BITS;i<<=1)m|=m<<i;
-        for(i=0;i<stride;i++){
-          _mask[j*stride+i]=m;
-          m=m>>QR_INT_BITS%6|m<<6-QR_INT_BITS%6;
-        }
-      }
-    }break;
-  }
-}
-
-static void qr_sampling_grid_sample(const qr_sampling_grid *_grid,
- unsigned *_data_bits,int _dim,int _fmt_info,
- const unsigned char *_img,int _width,int _height){
-  int stride;
-  int u0;
-  int u1;
-  int j;
-  /*We initialize the buffer with the data mask and XOR bits into it as we read
-     them out of the image instead of unmasking in a separate step.*/
-  qr_data_mask_fill(_data_bits,_dim,_fmt_info&7);
-  stride=_dim+QR_INT_BITS-1>>QR_INT_LOGBITS;
-  u0=0;
-  svg_path_start("sampling-grid", 1, 0, 0);
-  /*We read data cell-by-cell to avoid having to constantly change which
-     projection we're using as we read each bit.
-    This (and the position-dependent data mask) is the reason we buffer the
-     bits we read instead of converting them directly to codewords here.
-    Note that bits are stored column-wise, since that's how we'll scan them.*/
-  for(j=0;j<_grid->ncells;j++){
-    int i;
-    int v0;
-    int v1;
-    u1=_grid->cell_limits[j];
-    v0=0;
-    for(i=0;i<_grid->ncells;i++){
-      qr_hom_cell *cell;
-      int          x0;
-      int          y0;
-      int          w0;
-      int          u;
-      int          du;
-      int          dv;
-      v1=_grid->cell_limits[i];
-      cell=_grid->cells[i]+j;
-      du=u0-cell->u0;
-      dv=v0-cell->v0;
-      x0=cell->fwd[0][0]*du+cell->fwd[0][1]*dv+cell->fwd[0][2];
-      y0=cell->fwd[1][0]*du+cell->fwd[1][1]*dv+cell->fwd[1][2];
-      w0=cell->fwd[2][0]*du+cell->fwd[2][1]*dv+cell->fwd[2][2];
-      for(u=u0;u<u1;u++){
-        int x;
-        int y;
-        int w;
-        int v;
-        x=x0;
-        y=y0;
-        w=w0;
-        for(v=v0;v<v1;v++){
-          /*Skip doing all the divisions and bounds checks if the bit is in the
-             function pattern.*/
-          if(!qr_sampling_grid_is_in_fp(_grid,_dim,u,v)){
-            qr_point p;
-            qr_hom_cell_fproject(p,cell,x,y,w);
-            _data_bits[u*stride+(v>>QR_INT_LOGBITS)]^=
-             qr_img_get_bit(_img,_width,_height,p[0],p[1])<<(v&QR_INT_BITS-1);
-            svg_path_moveto(SVG_ABS, p[0], p[1]);
-          }
-          x+=cell->fwd[0][1];
-          y+=cell->fwd[1][1];
-          w+=cell->fwd[2][1];
-        }
-        x0+=cell->fwd[0][0];
-        y0+=cell->fwd[1][0];
-        w0+=cell->fwd[2][0];
-      }
-      v0=v1;
-    }
-    u0=u1;
-  }
-  svg_path_end();
-}
-
-/*Arranges the sample bits read by qr_sampling_grid_sample() into bytes and
-   groups those bytes into Reed-Solomon blocks.
-  The individual block pointers are destroyed by this routine.*/
-static void qr_samples_unpack(unsigned char **_blocks,int _nblocks,
- int _nshort_data,int _nshort_blocks,const unsigned *_data_bits,
- const unsigned *_fp_mask,int _dim){
-  unsigned bits;
-  int      biti;
-  int      stride;
-  int      blocki;
-  int      blockj;
-  int      i;
-  int      j;
-  stride=_dim+QR_INT_BITS-1>>QR_INT_LOGBITS;
-  /*If _all_ the blocks are short, don't skip anything (see below).*/
-  if(_nshort_blocks>=_nblocks)_nshort_blocks=0;
-  /*Scan columns in pairs from right to left.*/
-  bits=0;
-  for(blocki=blockj=biti=0,j=_dim-1;j>0;j-=2){
-    unsigned data1;
-    unsigned data2;
-    unsigned fp_mask1;
-    unsigned fp_mask2;
-    int      nbits;
-    int      l;
-    /*Scan up a pair of columns.*/
-    nbits=(_dim-1&QR_INT_BITS-1)+1;
-    l=j*stride;
-    for(i=stride;i-->0;){
-      data1=_data_bits[l+i];
-      fp_mask1=_fp_mask[l+i];
-      data2=_data_bits[l+i-stride];
-      fp_mask2=_fp_mask[l+i-stride];
-      while(nbits-->0){
-        /*Pull a bit from the right column.*/
-        if(!(fp_mask1>>nbits&1)){
-          bits=bits<<1|data1>>nbits&1;
-          biti++;
-        }
-        /*Pull a bit from the left column.*/
-        if(!(fp_mask2>>nbits&1)){
-          bits=bits<<1|data2>>nbits&1;
-          biti++;
-        }
-        /*If we finished a byte, drop it in a block.*/
-        if(biti>=8){
-          biti-=8;
-          *_blocks[blocki++]++=(unsigned char)(bits>>biti);
-          /*For whatever reason, the long blocks are at the _end_ of the list,
-             instead of the beginning.
-            Even worse, the extra bytes they get come at the end of the data
-             bytes, before the parity bytes.
-            Hence the logic here: when we've filled up the data portion of the
-             short blocks, skip directly to the long blocks for the next byte.
-            It's also the reason we increment _blocks[blocki] on each store,
-             instead of just indexing with blockj (after this iteration the
-             number of bytes in each block differs).*/
-          if(blocki>=_nblocks)blocki=++blockj==_nshort_data?_nshort_blocks:0;
-        }
-      }
-      nbits=QR_INT_BITS;
-    }
-    j-=2;
-    /*Skip the column with the vertical timing pattern.*/
-    if(j==6)j--;
-    /*Scan down a pair of columns.*/
-    l=j*stride;
-    for(i=0;i<stride;i++){
-      data1=_data_bits[l+i];
-      fp_mask1=_fp_mask[l+i];
-      data2=_data_bits[l+i-stride];
-      fp_mask2=_fp_mask[l+i-stride];
-      nbits=QR_MINI(_dim-(i<<QR_INT_LOGBITS),QR_INT_BITS);
-      while(nbits-->0){
-        /*Pull a bit from the right column.*/
-        if(!(fp_mask1&1)){
-          bits=bits<<1|data1&1;
-          biti++;
-        }
-        data1>>=1;
-        fp_mask1>>=1;
-        /*Pull a bit from the left column.*/
-        if(!(fp_mask2&1)){
-          bits=bits<<1|data2&1;
-          biti++;
-        }
-        data2>>=1;
-        fp_mask2>>=1;
-        /*If we finished a byte, drop it in a block.*/
-        if(biti>=8){
-          biti-=8;
-          *_blocks[blocki++]++=(unsigned char)(bits>>biti);
-          /*See comments on the "up" loop for the reason behind this mess.*/
-          if(blocki>=_nblocks)blocki=++blockj==_nshort_data?_nshort_blocks:0;
-        }
-      }
-    }
-  }
-}
-
-
-/*Bit reading code blatantly stolen^W^Wadapted from libogg/libtheora (because
-   I've already debugged it and I know it works).
-  Portions (C) Xiph.Org Foundation 1994-2008, BSD-style license.*/
-struct qr_pack_buf{
-  const unsigned char *buf;
-  int                  endbyte;
-  int                  endbit;
-  int                  storage;
-};
-
-
-static void qr_pack_buf_init(qr_pack_buf *_b,
- const unsigned char *_data,int _ndata){
-  _b->buf=_data;
-  _b->storage=_ndata;
-  _b->endbyte=_b->endbit=0;
-}
-
-/*Assumes 0<=_bits<=16.*/
-static int qr_pack_buf_read(qr_pack_buf *_b,int _bits){
-  const unsigned char *p;
-  unsigned             ret;
-  int                  m;
-  int                  d;
-  m=16-_bits;
-  _bits+=_b->endbit;
-  d=_b->storage-_b->endbyte;
-  if(d<=2){
-    /*Not the main path.*/
-    if(d*8<_bits){
-      _b->endbyte+=_bits>>3;
-      _b->endbit=_bits&7;
-      return -1;
-    }
-    /*Special case to avoid reading p[0] below, which might be past the end of
-       the buffer; also skips some useless accounting.*/
-    else if(!_bits)return 0;
-  }
-  p=_b->buf+_b->endbyte;
-  ret=p[0]<<8+_b->endbit;
-  if(_bits>8){
-    ret|=p[1]<<_b->endbit;
-    if(_bits>16)ret|=p[2]>>8-_b->endbit;
-  }
-  _b->endbyte+=_bits>>3;
-  _b->endbit=_bits&7;
-  return (ret&0xFFFF)>>m;
-}
-
-static int qr_pack_buf_avail(const qr_pack_buf *_b){
-  return (_b->storage-_b->endbyte<<3)-_b->endbit;
-}
-
-
-/*The characters available in QR_MODE_ALNUM.*/
-static const unsigned char QR_ALNUM_TABLE[45]={
-  '0','1','2','3','4','5','6','7','8','9',
-  'A','B','C','D','E','F','G','H','I','J',
-  'K','L','M','N','O','P','Q','R','S','T',
-  'U','V','W','X','Y','Z',' ','$','%','*',
-  '+','-','.','/',':'
-};
-
-static int qr_code_data_parse(qr_code_data *_qrdata,int _version,
- const unsigned char *_data,int _ndata){
-  qr_pack_buf qpb;
-  int         centries;
-  int         len_bits_idx;
-  /*Entries are stored directly in the struct during parsing.
-    Caller cleans up any allocated data on failure.*/
-  _qrdata->entries=NULL;
-  _qrdata->nentries=0;
-  _qrdata->sa_size=0;
-  centries=0;
-  /*The versions are divided into 3 ranges that each use a different number of
-     bits for length fields.*/
-  len_bits_idx=(_version>9)+(_version>26);
-  qr_pack_buf_init(&qpb,_data,_ndata);
-  /*While we have enough bits to read a mode...*/
-  while(qr_pack_buf_avail(&qpb)>=4){
-    qr_code_data_entry *entry;
-    int                 mode;
-    mode=qr_pack_buf_read(&qpb,4);
-    /*Mode 0 is a terminator.*/
-    if(!mode)break;
-    if(_qrdata->nentries>=centries){
-      centries=centries<<1|1;
-      _qrdata->entries=(qr_code_data_entry *)realloc(_qrdata->entries,
-       centries*sizeof(*_qrdata->entries));
-    }
-    entry=_qrdata->entries+_qrdata->nentries++;
-    /*Set the mode to an invalid value until we allocate a buffer for it.
-      This ensures we don't try to free it on clean-up until then.*/
-    entry->mode=-1;
-    switch(mode){
-      /*The number of bits used to encode the character count for each version
-         range and each data mode.*/
-      static const unsigned char LEN_BITS[3][4]={
-        {10, 9, 8, 8},
-        {12,11,16,10},
-        {14,13,16,12}
-      };
-      case QR_MODE_NUM:{
-        unsigned char *buf;
-        unsigned       bits;
-        int            len;
-        int            count;
-        int            rem;
-        len=qr_pack_buf_read(&qpb,LEN_BITS[len_bits_idx][0]);
-        if(len<0)return -1;
-        /*Check to see if there are enough bits left now, so we don't have to
-           in the decode loop.*/
-        count=len/3;
-        rem=len%3;
-        if(qr_pack_buf_avail(&qpb)<10*count+7*(rem>>1&1)+4*(rem&1))return -1;
-        entry->mode=mode;
-        entry->payload.data.buf=buf=(unsigned char *)malloc(len*sizeof(*buf));
-        entry->payload.data.len=len;
-        /*Read groups of 3 digits encoded in 10 bits.*/
-        while(count-->0){
-          bits=qr_pack_buf_read(&qpb,10);
-          if(bits>=1000)return -1;
-          *buf++=(unsigned char)('0'+bits/100);
-          bits%=100;
-          *buf++=(unsigned char)('0'+bits/10);
-          *buf++=(unsigned char)('0'+bits%10);
-        }
-        /*Read the last two digits encoded in 7 bits.*/
-        if(rem>1){
-          bits=qr_pack_buf_read(&qpb,7);
-          if(bits>=100)return -1;
-          *buf++=(unsigned char)('0'+bits/10);
-          *buf++=(unsigned char)('0'+bits%10);
-        }
-        /*Or the last one digit encoded in 4 bits.*/
-        else if(rem){
-          bits=qr_pack_buf_read(&qpb,4);
-          if(bits>=10)return -1;
-          *buf++=(unsigned char)('0'+bits);
-        }
-      }break;
-      case QR_MODE_ALNUM:{
-        unsigned char *buf;
-        unsigned       bits;
-        int            len;
-        int            count;
-        int            rem;
-        len=qr_pack_buf_read(&qpb,LEN_BITS[len_bits_idx][1]);
-        if(len<0)return -1;
-        /*Check to see if there are enough bits left now, so we don't have to
-           in the decode loop.*/
-        count=len>>1;
-        rem=len&1;
-        if(qr_pack_buf_avail(&qpb)<11*count+6*rem)return -1;
-        entry->mode=mode;
-        entry->payload.data.buf=buf=(unsigned char *)malloc(len*sizeof(*buf));
-        entry->payload.data.len=len;
-        /*Read groups of two characters encoded in 11 bits.*/
-        while(count-->0){
-          bits=qr_pack_buf_read(&qpb,11);
-          if(bits>=2025)return -1;
-          *buf++=QR_ALNUM_TABLE[bits/45];
-          *buf++=QR_ALNUM_TABLE[bits%45];
-          len-=2;
-        }
-        /*Read the last character encoded in 6 bits.*/
-        if(rem){
-          bits=qr_pack_buf_read(&qpb,6);
-          if(bits>=45)return -1;
-          *buf++=QR_ALNUM_TABLE[bits];
-        }
-      }break;
-      /*Structured-append header.*/
-      case QR_MODE_STRUCT:{
-        int bits;
-        entry->mode=mode;
-        bits=qr_pack_buf_read(&qpb,16);
-        if(bits<0)return -1;
-        /*We also save a copy of the data in _qrdata for easy reference when
-           grouping structured-append codes.
-          If for some reason the code has multiple S-A headers, last one wins
-           (TODO: should we return an error instead?).*/
-        _qrdata->sa_index=entry->payload.sa.sa_index=
-         (unsigned char)(bits>>12&0xF);
-        _qrdata->sa_size=entry->payload.sa.sa_size=
-         (unsigned char)((bits>>8&0xF)+1);
-        _qrdata->sa_parity=entry->payload.sa.sa_parity=
-         (unsigned char)(bits&0xFF);
-      }break;
-      case QR_MODE_BYTE:{
-        unsigned char *buf;
-        int            len;
-        len=qr_pack_buf_read(&qpb,LEN_BITS[len_bits_idx][2]);
-        if(len<0)return -1;
-        /*Check to see if there are enough bits left now, so we don't have to
-           in the decode loop.*/
-        if(qr_pack_buf_avail(&qpb)<len<<3)return -1;
-        entry->mode=mode;
-        entry->payload.data.buf=buf=(unsigned char *)malloc(len*sizeof(*buf));
-        entry->payload.data.len=len;
-        while(len-->0)*buf++=(unsigned char)qr_pack_buf_read(&qpb,8);
-      }break;
-      /*FNC1 first position marker.*/
-      case QR_MODE_FNC1_1ST:entry->mode=mode;break;
-      /*Extended Channel Interpretation data.*/
-      case QR_MODE_ECI:{
-        unsigned val;
-        int      bits;
-        /*ECI uses a variable-width encoding similar to UTF-8*/
-        bits=qr_pack_buf_read(&qpb,8);
-        if(bits<0)return -1;
-        /*One byte:*/
-        if(!(bits&0x80))val=bits;
-        /*Two bytes:*/
-        else if(!(bits&0x40)){
-          val=bits&0x3F<<8;
-          bits=qr_pack_buf_read(&qpb,8);
-          if(bits<0)return -1;
-          val|=bits;
-        }
-        /*Three bytes:*/
-        else if(!(bits&0x20)){
-          val=bits&0x1F<<16;
-          bits=qr_pack_buf_read(&qpb,16);
-          if(bits<0)return -1;
-          val|=bits;
-          /*Valid ECI values are 0...999999.*/
-          if(val>=1000000)return -1;
-        }
-        /*Invalid lead byte.*/
-        else return -1;
-        entry->mode=mode;
-        entry->payload.eci=val;
-      }break;
-      case QR_MODE_KANJI:{
-        unsigned char *buf;
-        unsigned       bits;
-        int            len;
-        len=qr_pack_buf_read(&qpb,LEN_BITS[len_bits_idx][3]);
-        if(len<0)return -1;
-        /*Check to see if there are enough bits left now, so we don't have to
-           in the decode loop.*/
-        if(qr_pack_buf_avail(&qpb)<13*len)return -1;
-        entry->mode=mode;
-        entry->payload.data.buf=buf=(unsigned char *)malloc(2*len*sizeof(*buf));
-        entry->payload.data.len=2*len;
-        /*Decode 2-byte SJIS characters encoded in 13 bits.*/
-        while(len-->0){
-          bits=qr_pack_buf_read(&qpb,13);
-          bits=(bits/0xC0<<8|bits%0xC0)+0x8140;
-          if(bits>=0xA000)bits+=0x4000;
-          /*Are values 0xXX7F, 0xXXFD...0xXXFF always invalid?
-            Should we reject them here?*/
-          *buf++=(unsigned char)(bits>>8);
-          *buf++=(unsigned char)(bits&0xFF);
-        }
-      }break;
-      /*FNC1 second position marker.*/
-      case QR_MODE_FNC1_2ND:entry->mode=mode;break;
-      /*Unknown mode number:*/
-      default:{
-        /*Unfortunately, because we have to understand the format of a mode to
-           know how many bits it occupies, we can't skip unknown modes.
-          Therefore we have to fail.*/
-        return -1;
-      }break;
-    }
-  }
-  /*TODO: If there was a S-A header, we should compute the parity of this
-     code; how are non-data modes handled (ECI, FNC1)?*/
-  _qrdata->self_parity=0;
-  /*Success.*/
-  _qrdata->entries=(qr_code_data_entry *)realloc(_qrdata->entries,
-   _qrdata->nentries*sizeof(*_qrdata->entries));
-  return 0;
-}
-
-static void qr_code_data_clear(qr_code_data *_qrdata){
-  int i;
-  for(i=0;i<_qrdata->nentries;i++){
-    if(QR_MODE_HAS_DATA(_qrdata->entries[i].mode)){
-      free(_qrdata->entries[i].payload.data.buf);
-    }
-  }
-  free(_qrdata->entries);
-}
-
-
-void qr_code_data_list_init(qr_code_data_list *_qrlist){
-  _qrlist->qrdata=NULL;
-  _qrlist->nqrdata=_qrlist->cqrdata=0;
-}
-
-void qr_code_data_list_clear(qr_code_data_list *_qrlist){
-  int i;
-  for(i=0;i<_qrlist->nqrdata;i++)qr_code_data_clear(_qrlist->qrdata+i);
-  free(_qrlist->qrdata);
-  qr_code_data_list_init(_qrlist);
-}
-
-static void qr_code_data_list_add(qr_code_data_list *_qrlist,
- qr_code_data *_qrdata){
-  if(_qrlist->nqrdata>=_qrlist->cqrdata){
-    _qrlist->cqrdata=_qrlist->cqrdata<<1|1;
-    _qrlist->qrdata=(qr_code_data *)realloc(_qrlist->qrdata,
-     _qrlist->cqrdata*sizeof(*_qrlist->qrdata));
-  }
-  memcpy(_qrlist->qrdata+_qrlist->nqrdata++,_qrdata,sizeof(*_qrdata));
-}
-
-#if 0
-static const unsigned short QR_NCODEWORDS[40]={
-    26,  44,  70, 100, 134, 172, 196, 242, 292, 346,
-   404, 466, 532, 581, 655, 733, 815, 901, 991,1085,
-  1156,1258,1364,1474,1588,1706,1828,1921,2051,2185,
-  2323,2465,2611,2761,2876,3034,3196,3362,3532,3706
-};
-#endif
-
-/*The total number of codewords in a QR code.*/
-static int qr_code_ncodewords(unsigned _version){
-  unsigned nalign;
-  /*This is 24-27 instructions on ARM in thumb mode, or a 26-32 byte savings
-     over just using a table (not counting the instructions that would be
-     needed to do the table lookup).*/
-  if(_version==1)return 26;
-  nalign=(_version/7)+2;
-  return (_version<<4)*(_version+8)
-   -(5*nalign)*(5*nalign-2)+36*(_version<7)+83>>3;
-}
-
-#if 0
-/*The number of parity bytes per Reed-Solomon block for each version and error
-   correction level.*/
-static const unsigned char QR_RS_NPAR[40][4]={
-  { 7,10,13,17},{10,16,22,28},{15,26,18,22},{20,18,26,16},
-  {26,24,18,22},{18,16,24,28},{20,18,18,26},{24,22,22,26},
-  {30,22,20,24},{18,26,24,28},{20,30,28,24},{24,22,26,28},
-  {26,22,24,22},{30,24,20,24},{22,24,30,24},{24,28,24,30},
-  {28,28,28,28},{30,26,28,28},{28,26,26,26},{28,26,30,28},
-  {28,26,28,30},{28,28,30,24},{30,28,30,30},{30,28,30,30},
-  {26,28,30,30},{28,28,28,30},{30,28,30,30},{30,28,30,30},
-  {30,28,30,30},{30,28,30,30},{30,28,30,30},{30,28,30,30},
-  {30,28,30,30},{30,28,30,30},{30,28,30,30},{30,28,30,30},
-  {30,28,30,30},{30,28,30,30},{30,28,30,30},{30,28,30,30}
-};
-#endif
-
-/*Bulk data for the number of parity bytes per Reed-Solomon block.*/
-static const unsigned char QR_RS_NPAR_VALS[71]={
-  /*[ 0]*/ 7,10,13,17,
-  /*[ 4]*/10,16,22, 28,26,26, 26,22, 24,22,22, 26,24,18,22,
-  /*[19]*/15,26,18, 22,24, 30,24,20,24,
-  /*[28]*/18,16,24, 28, 28, 28,28,30,24,
-  /*[37]*/20,18, 18,26, 24,28,24, 30,26,28, 28, 26,28,30, 30,22,20,24,
-  /*[55]*/20,18,26,16,
-  /*[59]*/20,30,28, 24,22,26, 28,26, 30,28,30,30
-};
-
-/*An offset into QR_RS_NPAR_DATA for each version that gives the number of
-   parity bytes per Reed-Solomon block for each error correction level.*/
-static const unsigned char QR_RS_NPAR_OFFS[40]={
-   0, 4,19,55,15,28,37,12,51,39,
-  59,62,10,24,22,41,31,44, 7,65,
-  47,33,67,67,48,32,67,67,67,67,
-  67,67,67,67,67,67,67,67,67,67
-};
-
-/*The number of Reed-Solomon blocks for each version and error correction
-   level.*/
-static const unsigned char QR_RS_NBLOCKS[40][4]={
-  { 1, 1, 1, 1},{ 1, 1, 1, 1},{ 1, 1, 2, 2},{ 1, 2, 2, 4},
-  { 1, 2, 4, 4},{ 2, 4, 4, 4},{ 2, 4, 6, 5},{ 2, 4, 6, 6},
-  { 2, 5, 8, 8},{ 4, 5, 8, 8},{ 4, 5, 8,11},{ 4, 8,10,11},
-  { 4, 9,12,16},{ 4, 9,16,16},{ 6,10,12,18},{ 6,10,17,16},
-  { 6,11,16,19},{ 6,13,18,21},{ 7,14,21,25},{ 8,16,20,25},
-  { 8,17,23,25},{ 9,17,23,34},{ 9,18,25,30},{10,20,27,32},
-  {12,21,29,35},{12,23,34,37},{12,25,34,40},{13,26,35,42},
-  {14,28,38,45},{15,29,40,48},{16,31,43,51},{17,33,45,54},
-  {18,35,48,57},{19,37,51,60},{19,38,53,63},{20,40,56,66},
-  {21,43,59,70},{22,45,62,74},{24,47,65,77},{25,49,68,81}
-};
-
-/*Attempts to fully decode a QR code.
-  _qrdata:   Returns the parsed code data.
-  _gf:       Used for Reed-Solomon error correction.
-  _ul_pos:   The location of the UL finder pattern.
-  _ur_pos:   The location of the UR finder pattern.
-  _dl_pos:   The location of the DL finder pattern.
-  _version:  The (decoded) version number.
-  _fmt_info: The decoded format info.
-  _img:      The binary input image.
-  _width:    The width of the input image.
-  _height:   The height of the input image.
-  Return: 0 on success, or a negative value on error.*/
-static int qr_code_decode(qr_code_data *_qrdata,const rs_gf256 *_gf,
- const qr_point _ul_pos,const qr_point _ur_pos,const qr_point _dl_pos,
- int _version,int _fmt_info,
- const unsigned char *_img,int _width,int _height){
-  qr_sampling_grid   grid;
-  unsigned          *data_bits;
-  unsigned char    **blocks;
-  unsigned char     *block_data;
-  int                nblocks;
-  int                nshort_blocks;
-  int                ncodewords;
-  int                block_sz;
-  int                ecc_level;
-  int                ndata;
-  int                npar;
-  int                dim;
-  int                ret;
-  int                i;
-  /*Read the bits out of the image.*/
-  qr_sampling_grid_init(&grid,_version,_ul_pos,_ur_pos,_dl_pos,_qrdata->bbox,
-   _img,_width,_height);
-#if defined(QR_DEBUG)
-  qr_sampling_grid_dump(&grid,_version,_img,_width,_height);
-#endif
-  dim=17+(_version<<2);
-  data_bits=(unsigned *)malloc(
-   dim*(dim+QR_INT_BITS-1>>QR_INT_LOGBITS)*sizeof(*data_bits));
-  qr_sampling_grid_sample(&grid,data_bits,dim,_fmt_info,_img,_width,_height);
-  /*Group those bits into Reed-Solomon codewords.*/
-  ecc_level=(_fmt_info>>3)^1;
-  nblocks=QR_RS_NBLOCKS[_version-1][ecc_level];
-  npar=*(QR_RS_NPAR_VALS+QR_RS_NPAR_OFFS[_version-1]+ecc_level);
-  ncodewords=qr_code_ncodewords(_version);
-  block_sz=ncodewords/nblocks;
-  nshort_blocks=nblocks-(ncodewords%nblocks);
-  blocks=(unsigned char **)malloc(nblocks*sizeof(*blocks));
-  block_data=(unsigned char *)malloc(ncodewords*sizeof(*block_data));
-  blocks[0]=block_data;
-  for(i=1;i<nblocks;i++)blocks[i]=blocks[i-1]+block_sz+(i>nshort_blocks);
-  qr_samples_unpack(blocks,nblocks,block_sz-npar,nshort_blocks,
-   data_bits,grid.fpmask,dim);
-  qr_sampling_grid_clear(&grid);
-  free(blocks);
-  free(data_bits);
-  /*Perform the error correction.*/
-  ndata=0;
-  ncodewords=0;
-  ret=0;
-  for(i=0;i<nblocks;i++){
-    int block_szi;
-    int ndatai;
-    block_szi=block_sz+(i>=nshort_blocks);
-    if(rs_correct(_gf,QR_M0,block_data+ncodewords,block_szi,npar,NULL,0)<0){
-      ret=-1;
-      break;
-    }
-    ndatai=block_szi-npar;
-    memmove(block_data+ndata,block_data+ncodewords,ndatai*sizeof(*block_data));
-    ncodewords+=block_szi;
-    ndata+=ndatai;
-  }
-  /*Parse the corrected bitstream.*/
-  if(ret>=0){
-    ret=qr_code_data_parse(_qrdata,_version,block_data,ndata);
-    /*We could return any partially decoded data, but then we'd have to have
-       API support for that; a mode ignoring ECC errors might also be useful.*/
-    if(ret<0)qr_code_data_clear(_qrdata);
-    _qrdata->version=_version;
-    _qrdata->ecc_level=ecc_level;
-  }
-  free(block_data);
-  return ret;
-}
-
-/*Searches for an arrangement of these three finder centers that yields a valid
-   configuration.
-  _c: On input, the three finder centers to consider in any order.
-  Return: The detected version number, or a negative value on error.*/
-static int qr_reader_try_configuration(qr_reader *_reader,
- qr_code_data *_qrdata,const unsigned char *_img,int _width,int _height,
- qr_finder_center *_c[3]){
-  int      ci[7];
-  unsigned maxd;
-  int      ccw;
-  int      i0;
-  int      i;
-  /*Sort the points in counter-clockwise order.*/
-  ccw=qr_point_ccw(_c[0]->pos,_c[1]->pos,_c[2]->pos);
-  /*Colinear points can't be the corners of a quadrilateral.*/
-  if(!ccw)return -1;
-  /*Include a few extra copies of the cyclical list to avoid mods.*/
-  ci[6]=ci[3]=ci[0]=0;
-  ci[4]=ci[1]=1+(ccw<0);
-  ci[5]=ci[2]=2-(ccw<0);
-  /*Assume the points farthest from each other are the opposite corners, and
-     find the top-left point.*/
-  maxd=qr_point_distance2(_c[1]->pos,_c[2]->pos);
-  i0=0;
-  for(i=1;i<3;i++){
-    unsigned d;
-    d=qr_point_distance2(_c[ci[i+1]]->pos,_c[ci[i+2]]->pos);
-    if(d>maxd){
-      i0=i;
-      maxd=d;
-    }
-  }
-  /*However, try all three possible orderings, just to be sure (a severely
-     skewed projection could move opposite corners closer than adjacent).*/
-  for(i=i0;i<i0+3;i++){
-    qr_aff    aff;
-    qr_hom    hom;
-    qr_finder ul;
-    qr_finder ur;
-    qr_finder dl;
-    int       res;
-    int       ur_version;
-    int       dl_version;
-    int       fmt_info;
-    ul.c=_c[ci[i]];
-    ur.c=_c[ci[i+1]];
-    dl.c=_c[ci[i+2]];
-    /*Estimate the module size and version number from the two opposite corners.
-      The module size is not constant in the image, so we compute an affine
-       projection from the three points we have to a square domain, and
-       estimate it there.
-      Although it should be the same along both axes, we keep separate
-       estimates to account for any remaining projective distortion.*/
-    res=QR_INT_BITS-2-QR_FINDER_SUBPREC-qr_ilog(QR_MAXI(_width,_height)-1);
-    qr_aff_init(&aff,ul.c->pos,ur.c->pos,dl.c->pos,res);
-    qr_aff_unproject(ur.o,&aff,ur.c->pos[0],ur.c->pos[1]);
-    qr_finder_edge_pts_aff_classify(&ur,&aff);
-    if(qr_finder_estimate_module_size_and_version(&ur,1<<res,1<<res)<0)continue;
-    qr_aff_unproject(dl.o,&aff,dl.c->pos[0],dl.c->pos[1]);
-    qr_finder_edge_pts_aff_classify(&dl,&aff);
-    if(qr_finder_estimate_module_size_and_version(&dl,1<<res,1<<res)<0)continue;
-    /*If the estimated versions are significantly different, reject the
-       configuration.*/
-    if(abs(ur.eversion[1]-dl.eversion[0])>QR_LARGE_VERSION_SLACK)continue;
-    qr_aff_unproject(ul.o,&aff,ul.c->pos[0],ul.c->pos[1]);
-    qr_finder_edge_pts_aff_classify(&ul,&aff);
-    if(qr_finder_estimate_module_size_and_version(&ul,1<<res,1<<res)<0||
-     abs(ul.eversion[1]-ur.eversion[1])>QR_LARGE_VERSION_SLACK||
-     abs(ul.eversion[0]-dl.eversion[0])>QR_LARGE_VERSION_SLACK){
-      continue;
-    }
-#if defined(QR_DEBUG)
-    qr_finder_dump_aff_undistorted(&ul,&ur,&dl,&aff,_img,_width,_height);
-#endif
-    /*If we made it this far, upgrade the affine homography to a full
-       homography.*/
-    if(qr_hom_fit(&hom,&ul,&ur,&dl,_qrdata->bbox,&aff,
-     &_reader->isaac,_img,_width,_height)<0){
-      continue;
-    }
-    qr_hom_unproject(ul.o,&hom,ul.c->pos[0],ul.c->pos[1]);
-    qr_hom_unproject(ur.o,&hom,ur.c->pos[0],ur.c->pos[1]);
-    qr_hom_unproject(dl.o,&hom,dl.c->pos[0],dl.c->pos[1]);
-    qr_finder_edge_pts_hom_classify(&ur,&hom);
-    if(qr_finder_estimate_module_size_and_version(&ur,
-     ur.o[0]-ul.o[0],ur.o[0]-ul.o[0])<0){
-      continue;
-    }
-    qr_finder_edge_pts_hom_classify(&dl,&hom);
-    if(qr_finder_estimate_module_size_and_version(&dl,
-     dl.o[1]-ul.o[1],dl.o[1]-ul.o[1])<0){
-      continue;
-    }
-#if defined(QR_DEBUG)
-    qr_finder_dump_hom_undistorted(&ul,&ur,&dl,&hom,_img,_width,_height);
-#endif
-    /*If we have a small version (less than 7), there's no encoded version
-       information.
-      If the estimated version on the two corners matches and is sufficiently
-       small, we assume this is the case.*/
-    if(ur.eversion[1]==dl.eversion[0]&&ur.eversion[1]<7){
-      /*We used to do a whole bunch of extra geometric checks for small
-         versions, because with just an affine correction, it was fairly easy
-         to estimate two consistent module sizes given a random configuration.
-        However, now that we're estimating a full homography, these appear to
-         be unnecessary.*/
-#if 0
-      static const signed char LINE_TESTS[12][6]={
-        /*DL left, UL > 0, UR > 0*/
-        {2,0,0, 1,1, 1},
-        /*DL right, UL > 0, UR < 0*/
-        {2,1,0, 1,1,-1},
-        /*UR top, UL > 0, DL > 0*/
-        {1,2,0, 1,2, 1},
-        /*UR bottom, UL > 0, DL < 0*/
-        {1,3,0, 1,2,-1},
-        /*UR left, DL < 0, UL < 0*/
-        {1,0,2,-1,0,-1},
-        /*UR right, DL > 0, UL > 0*/
-        {1,1,2, 1,0, 1},
-        /*DL top, UR < 0, UL < 0*/
-        {2,2,1,-1,0,-1},
-        /*DL bottom, UR > 0, UL > 0*/
-        {2,3,1, 1,0, 1},
-        /*UL left, DL > 0, UR > 0*/
-        {0,0,2, 1,1, 1},
-        /*UL right, DL > 0, UR < 0*/
-        {0,1,2, 1,1,-1},
-        /*UL top, UR > 0, DL > 0*/
-        {0,2,1, 1,2, 1},
-        /*UL bottom, UR > 0, DL < 0*/
-        {0,3,1, 1,2,-1}
-      };
-      qr_finder *f[3];
-      int        j;
-      /*Start by decoding the format information.
-        This is cheap, but unlikely to reject invalid configurations.
-        56.25% of all bitstrings are valid, and we mix and match several pieces
-         until we find a valid combination, so our real chances of finding a
-         valid codeword in random bits are even higher.*/
-      fmt_info=qr_finder_fmt_info_decode(&ul,&ur,&dl,&aff,_img,_width,_height);
-      if(fmt_info<0)continue;
-      /*Now we fit lines to the edges of each finder pattern and check to make
-         sure the centers of the other finder patterns lie on the proper side.*/
-      f[0]=&ul;
-      f[1]=&ur;
-      f[2]=&dl;
-      for(j=0;j<12;j++){
-        const signed char *t;
-        qr_line            l0;
-        int               *p;
-        t=LINE_TESTS[j];
-        qr_finder_ransac(f[t[0]],&aff,&_reader->isaac,t[1]);
-        /*We may not have enough points to fit a line accurately here.
-          If not, we just skip the test.*/
-        if(qr_line_fit_finder_edge(l0,f[t[0]],t[1],res)<0)continue;
-        p=f[t[2]]->c->pos;
-        if(qr_line_eval(l0,p[0],p[1])*t[3]<0)break;
-        p=f[t[4]]->c->pos;
-        if(qr_line_eval(l0,p[0],p[1])*t[5]<0)break;
-      }
-      if(j<12)continue;
-      /*All tests passed.*/
-#endif
-      ur_version=ur.eversion[1];
-    }
-    else{
-      /*If the estimated versions are significantly different, reject the
-         configuration.*/
-      if(abs(ur.eversion[1]-dl.eversion[0])>QR_LARGE_VERSION_SLACK)continue;
-      /*Otherwise we try to read the actual version data from the image.
-        If the real version is not sufficiently close to our estimated version,
-         then we assume there was an unrecoverable decoding error (so many bit
-         errors we were within 3 errors of another valid code), and throw that
-         value away.
-        If no decoded version could be sufficiently close, we don't even try.*/
-      if(ur.eversion[1]>=7-QR_LARGE_VERSION_SLACK){
-        ur_version=qr_finder_version_decode(&ur,&hom,_img,_width,_height,0);
-        if(abs(ur_version-ur.eversion[1])>QR_LARGE_VERSION_SLACK)ur_version=-1;
-      }
-      else ur_version=-1;
-      if(dl.eversion[0]>=7-QR_LARGE_VERSION_SLACK){
-        dl_version=qr_finder_version_decode(&dl,&hom,_img,_width,_height,1);
-        if(abs(dl_version-dl.eversion[0])>QR_LARGE_VERSION_SLACK)dl_version=-1;
-      }
-      else dl_version=-1;
-      /*If we got at least one valid version, or we got two and they match,
-         then we found a valid configuration.*/
-      if(ur_version>=0){
-        if(dl_version>=0&&dl_version!=ur_version)continue;
-      }
-      else if(dl_version<0)continue;
-      else ur_version=dl_version;
-    }
-    qr_finder_edge_pts_hom_classify(&ul,&hom);
-    if(qr_finder_estimate_module_size_and_version(&ul,
-     ur.o[0]-dl.o[0],dl.o[1]-ul.o[1])<0||
-     abs(ul.eversion[1]-ur.eversion[1])>QR_SMALL_VERSION_SLACK||
-     abs(ul.eversion[0]-dl.eversion[0])>QR_SMALL_VERSION_SLACK){
-      continue;
-    }
-    fmt_info=qr_finder_fmt_info_decode(&ul,&ur,&dl,&hom,_img,_width,_height);
-    if(fmt_info<0)continue;
-    if(qr_code_decode(_qrdata,&_reader->gf,ul.c->pos,ur.c->pos,dl.c->pos,
-     ur_version,fmt_info,_img,_width,_height)<0){
-      /*TODO: Maybe somebody flipped the code?
-        We'd still get a valid version, and probably valid (but incorrect)
-         format info.
-        After we've come this far, it should be a simple matter to check.*/
-      continue;
-    }
-    return ur_version;
-  }
-  return -1;
-}
-
-void qr_reader_match_centers(qr_reader *_reader,qr_code_data_list *_qrlist,
- qr_finder_center *_centers,int _ncenters,
- const unsigned char *_img,int _width,int _height){
-  /*The number of centers should be small, so an O(n^3) exhaustive search of
-     which ones go together should be reasonable.*/
-  unsigned char *mark;
-  int            i;
-  int            j;
-  int            k;
-  mark=(unsigned char *)calloc(_ncenters,sizeof(*mark));
-  for(i=0;i<_ncenters;i++){
-    /*TODO: We might be able to accelerate this step significantly by
-       considering the remaining finder centers in a more intelligent order,
-       based on the first finder center we just chose.*/
-    for(j=i+1;!mark[i]&&j<_ncenters;j++){
-      for(k=j+1;!mark[j]&&k<_ncenters;k++)if(!mark[k]){
-        qr_finder_center *c[3];
-        qr_code_data      qrdata;
-        int               version;
-        c[0]=_centers+i;
-        c[1]=_centers+j;
-        c[2]=_centers+k;
-        version=qr_reader_try_configuration(_reader,&qrdata,
-         _img,_width,_height,c);
-        if(version>=0){
-          int ninside;
-          int l;
-          /*Add the data to the list.*/
-          qr_code_data_list_add(_qrlist,&qrdata);
-          /*Convert the bounding box we're returning to the user to normal
-             image coordinates.*/
-          for(l=0;l<4;l++){
-            _qrlist->qrdata[_qrlist->nqrdata-1].bbox[l][0]>>=QR_FINDER_SUBPREC;
-            _qrlist->qrdata[_qrlist->nqrdata-1].bbox[l][1]>>=QR_FINDER_SUBPREC;
-          }
-          /*Mark these centers as used.*/
-          mark[i]=mark[j]=mark[k]=1;
-          /*Find any other finder centers located inside this code.*/
-          for(l=ninside=0;l<_ncenters;l++)if(!mark[l]){
-            if(qr_point_ccw(qrdata.bbox[0],qrdata.bbox[1],_centers[l].pos)>=0&&
-             qr_point_ccw(qrdata.bbox[1],qrdata.bbox[3],_centers[l].pos)>=0&&
-             qr_point_ccw(qrdata.bbox[3],qrdata.bbox[2],_centers[l].pos)>=0&&
-             qr_point_ccw(qrdata.bbox[2],qrdata.bbox[0],_centers[l].pos)>=0){
-              mark[l]=2;
-              ninside++;
-            }
-          }
-          if(ninside>=3){
-            /*We might have a "Double QR": a code inside a code.
-              Copy the relevant centers to a new array and do a search confined
-               to that subset.*/
-            qr_finder_center *inside;
-            inside=(qr_finder_center *)malloc(ninside*sizeof(*inside));
-            for(l=ninside=0;l<_ncenters;l++){
-              if(mark[l]==2)*&inside[ninside++]=*&_centers[l];
-            }
-            qr_reader_match_centers(_reader,_qrlist,inside,ninside,
-             _img,_width,_height);
-            free(inside);
-          }
-          /*Mark _all_ such centers used: codes cannot partially overlap.*/
-          for(l=0;l<_ncenters;l++)if(mark[l]==2)mark[l]=1;
-        }
-      }
-    }
-  }
-  free(mark);
-}
-
-int _zbar_qr_found_line (qr_reader *reader,
-                         int dir,
-                         const qr_finder_line *line)
-{
-    /* minimally intrusive brute force version */
-    qr_finder_lines *lines = &reader->finder_lines[dir];
-
-    if(lines->nlines >= lines->clines) {
-        lines->clines *= 2;
-        lines->lines = realloc(lines->lines,
-                               ++lines->clines * sizeof(*lines->lines));
-    }
-
-    memcpy(lines->lines + lines->nlines++, line, sizeof(*line));
-
-    return(0);
-}
-
-static inline void qr_svg_centers (const qr_finder_center *centers,
-                                   int ncenters)
-{
-    int i, j;
-    svg_path_start("centers", 1, 0, 0);
-    for(i = 0; i < ncenters; i++)
-        svg_path_moveto(SVG_ABS, centers[i].pos[0], centers[i].pos[1]);
-    svg_path_end();
-
-    svg_path_start("edge-pts", 1, 0, 0);
-    for(i = 0; i < ncenters; i++) {
-        const qr_finder_center *cen = centers + i;
-        for(j = 0; j < cen->nedge_pts; j++)
-            svg_path_moveto(SVG_ABS,
-                            cen->edge_pts[j].pos[0], cen->edge_pts[j].pos[1]);
-    }
-    svg_path_end();
-}
-
-int _zbar_qr_decode (qr_reader *reader,
-                     zbar_image_scanner_t *iscn,
-                     zbar_image_t *img)
-{
-    int nqrdata = 0, ncenters;
-    qr_finder_edge_pt *edge_pts = NULL;
-    qr_finder_center *centers = NULL;
-
-    if(reader->finder_lines[0].nlines < 9 ||
-       reader->finder_lines[1].nlines < 9)
-        return(0);
-
-    svg_group_start("finder", 0, 1. / (1 << QR_FINDER_SUBPREC), 0, 0, 0);
-
-    ncenters = qr_finder_centers_locate(&centers, &edge_pts, reader, 0, 0);
-
-    zprintf(14, "%dx%d finders, %d centers:\n",
-            reader->finder_lines[0].nlines,
-            reader->finder_lines[1].nlines,
-            ncenters);
-    qr_svg_centers(centers, ncenters);
-
-    if(ncenters >= 3) {
-        void *bin = qr_binarize(img->data, img->width, img->height);
-
-        qr_code_data_list qrlist;
-        qr_code_data_list_init(&qrlist);
-
-        qr_reader_match_centers(reader, &qrlist, centers, ncenters,
-                                bin, img->width, img->height);
-
-        if(qrlist.nqrdata > 0)
-            nqrdata = qr_code_data_list_extract_text(&qrlist, iscn, img);
-
-        qr_code_data_list_clear(&qrlist);
-        free(bin);
-    }
-    svg_group_end();
-
-    if(centers)
-        free(centers);
-    if(edge_pts)
-        free(edge_pts);
-    return(nqrdata);
-}