1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 // Original code is licensed as follows:
7 /*
8  * Copyright 2011 ZXing authors
9  *
10  * Licensed under the Apache License, Version 2.0 (the "License");
11  * you may not use this file except in compliance with the License.
12  * You may obtain a copy of the License at
13  *
14  *      http://www.apache.org/licenses/LICENSE-2.0
15  *
16  * Unless required by applicable law or agreed to in writing, software
17  * distributed under the License is distributed on an "AS IS" BASIS,
18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19  * See the License for the specific language governing permissions and
20  * limitations under the License.
21  */
22 
23 #include "xfa/src/fxbarcode/barcode.h"
24 #include "xfa/src/fxbarcode/BC_Reader.h"
25 #include "xfa/src/fxbarcode/BC_Writer.h"
26 #include "xfa/src/fxbarcode/BC_DecoderResult.h"
27 #include "xfa/src/fxbarcode/BC_LuminanceSource.h"
28 #include "xfa/src/fxbarcode/BC_BufferedImageLuminanceSource.h"
29 #include "xfa/src/fxbarcode/BC_Binarizer.h"
30 #include "xfa/src/fxbarcode/BC_BinaryBitmap.h"
31 #include "xfa/src/fxbarcode/BC_UtilCodingConvert.h"
32 #include "xfa/src/fxbarcode/BC_ResultPoint.h"
33 #include "xfa/src/fxbarcode/BC_BinaryBitmap.h"
34 #include "xfa/src/fxbarcode/BC_TwoDimWriter.h"
35 #include "xfa/src/fxbarcode/common/BC_GlobalHistogramBinarizer.h"
36 #include "xfa/src/fxbarcode/common/BC_CommonBitMatrix.h"
37 #include "xfa/src/fxbarcode/common/BC_CommonBitArray.h"
38 #include "xfa/src/fxbarcode/common/BC_CommonBitMatrix.h"
39 #include "xfa/src/fxbarcode/common/BC_CommonDecoderResult.h"
40 #include "xfa/src/fxbarcode/datamatrix/BC_DataMatrixReader.h"
41 #include "xfa/src/fxbarcode/datamatrix/BC_DataMatrixWriter.h"
42 #include "xfa/src/fxbarcode/oned/BC_OneDReader.h"
43 #include "xfa/src/fxbarcode/oned/BC_OneDimReader.h"
44 #include "xfa/src/fxbarcode/oned/BC_OneDimWriter.h"
45 #include "xfa/src/fxbarcode/oned/BC_OnedCode39Reader.h"
46 #include "xfa/src/fxbarcode/oned/BC_OnedCode39Writer.h"
47 #include "xfa/src/fxbarcode/oned/BC_OnedCodaBarReader.h"
48 #include "xfa/src/fxbarcode/oned/BC_OnedCodaBarWriter.h"
49 #include "xfa/src/fxbarcode/oned/BC_OnedCode128Reader.h"
50 #include "xfa/src/fxbarcode/oned/BC_OnedCode128Writer.h"
51 #include "xfa/src/fxbarcode/oned/BC_OnedEAN8Reader.h"
52 #include "xfa/src/fxbarcode/oned/BC_OnedEAN8Writer.h"
53 #include "xfa/src/fxbarcode/oned/BC_OnedEAN13Reader.h"
54 #include "xfa/src/fxbarcode/oned/BC_OnedEAN13Writer.h"
55 #include "xfa/src/fxbarcode/oned/BC_OnedUPCAReader.h"
56 #include "xfa/src/fxbarcode/oned/BC_OnedUPCAWriter.h"
57 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.h"
58 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.h"
59 #include "xfa/src/fxbarcode/pdf417/BC_PDF417.h"
60 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Writer.h"
61 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Detector.h"
62 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.h"
63 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.h"
64 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Common.h"
65 #include "xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.h"
66 #include "xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h"
67 #include "xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.h"
68 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h"
69 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h"
70 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.h"
71 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h"
72 #include "xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h"
73 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h"
74 #include "xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h"
75 #include "xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.h"
76 #include "xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h"
77 #include "xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h"
78 #include "xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h"
79 #include "xfa/src/fxbarcode/pdf417/BC_PDF417Reader.h"
80 #include "xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h"
81 #include "xfa/src/fxbarcode/qrcode/BC_QRCodeReader.h"
82 #include "xfa/src/fxbarcode/qrcode/BC_QRCodeWriter.h"
CBC_CodeBase()83 CBC_CodeBase::CBC_CodeBase() {}
~CBC_CodeBase()84 CBC_CodeBase::~CBC_CodeBase() {}
SetCharEncoding(int32_t encoding)85 FX_BOOL CBC_CodeBase::SetCharEncoding(int32_t encoding) {
86   if (m_pBCWriter) {
87     return m_pBCWriter->SetCharEncoding(encoding);
88   }
89   return FALSE;
90 }
SetModuleHeight(int32_t moduleHeight)91 FX_BOOL CBC_CodeBase::SetModuleHeight(int32_t moduleHeight) {
92   if (m_pBCWriter) {
93     return m_pBCWriter->SetModuleHeight(moduleHeight);
94   }
95   return FALSE;
96 }
SetModuleWidth(int32_t moduleWidth)97 FX_BOOL CBC_CodeBase::SetModuleWidth(int32_t moduleWidth) {
98   if (m_pBCWriter) {
99     return m_pBCWriter->SetModuleWidth(moduleWidth);
100   }
101   return FALSE;
102 }
SetHeight(int32_t height)103 FX_BOOL CBC_CodeBase::SetHeight(int32_t height) {
104   if (m_pBCWriter) {
105     return m_pBCWriter->SetHeight(height);
106   }
107   return FALSE;
108 }
SetWidth(int32_t width)109 FX_BOOL CBC_CodeBase::SetWidth(int32_t width) {
110   if (m_pBCWriter) {
111     return m_pBCWriter->SetWidth(width);
112   }
113   return FALSE;
114 }
SetBackgroundColor(FX_ARGB backgroundColor)115 void CBC_CodeBase::SetBackgroundColor(FX_ARGB backgroundColor) {
116   if (m_pBCWriter) {
117     m_pBCWriter->SetBackgroundColor(backgroundColor);
118   }
119 }
SetBarcodeColor(FX_ARGB foregroundColor)120 void CBC_CodeBase::SetBarcodeColor(FX_ARGB foregroundColor) {
121   if (m_pBCWriter) {
122     m_pBCWriter->SetBarcodeColor(foregroundColor);
123   }
124 }
CBC_OneCode()125 CBC_OneCode::CBC_OneCode(){};
~CBC_OneCode()126 CBC_OneCode::~CBC_OneCode() {}
CheckContentValidity(const CFX_WideStringC & contents)127 FX_BOOL CBC_OneCode::CheckContentValidity(const CFX_WideStringC& contents) {
128   if (m_pBCWriter) {
129     return ((CBC_OneDimWriter*)m_pBCWriter)->CheckContentValidity(contents);
130   }
131   return FALSE;
132 }
FilterContents(const CFX_WideStringC & contents)133 CFX_WideString CBC_OneCode::FilterContents(const CFX_WideStringC& contents) {
134   CFX_WideString tmp;
135   if (m_pBCWriter == NULL) {
136     return tmp;
137   }
138   return ((CBC_OneDimWriter*)m_pBCWriter)->FilterContents(contents);
139 }
SetPrintChecksum(FX_BOOL checksum)140 void CBC_OneCode::SetPrintChecksum(FX_BOOL checksum) {
141   if (m_pBCWriter) {
142     ((CBC_OneDimWriter*)m_pBCWriter)->SetPrintChecksum(checksum);
143   }
144 }
SetDataLength(int32_t length)145 void CBC_OneCode::SetDataLength(int32_t length) {
146   if (m_pBCWriter) {
147     ((CBC_OneDimWriter*)m_pBCWriter)->SetDataLength(length);
148   }
149 }
SetCalChecksum(FX_BOOL calc)150 void CBC_OneCode::SetCalChecksum(FX_BOOL calc) {
151   if (m_pBCWriter) {
152     ((CBC_OneDimWriter*)m_pBCWriter)->SetCalcChecksum(calc);
153   }
154 }
SetFont(CFX_Font * cFont)155 FX_BOOL CBC_OneCode::SetFont(CFX_Font* cFont) {
156   if (m_pBCWriter) {
157     return ((CBC_OneDimWriter*)m_pBCWriter)->SetFont(cFont);
158   }
159   return FALSE;
160 }
SetFontSize(FX_FLOAT size)161 void CBC_OneCode::SetFontSize(FX_FLOAT size) {
162   if (m_pBCWriter) {
163     ((CBC_OneDimWriter*)m_pBCWriter)->SetFontSize(size);
164   }
165 }
SetFontStyle(int32_t style)166 void CBC_OneCode::SetFontStyle(int32_t style) {
167   if (m_pBCWriter) {
168     ((CBC_OneDimWriter*)m_pBCWriter)->SetFontStyle(style);
169   }
170 }
SetFontColor(FX_ARGB color)171 void CBC_OneCode::SetFontColor(FX_ARGB color) {
172   if (m_pBCWriter) {
173     ((CBC_OneDimWriter*)m_pBCWriter)->SetFontColor(color);
174   }
175 }
CBC_Code39()176 CBC_Code39::CBC_Code39() {
177   m_pBCReader = (CBC_Reader*)new (CBC_OnedCode39Reader);
178   m_pBCWriter = (CBC_Writer*)new (CBC_OnedCode39Writer);
179 }
CBC_Code39(FX_BOOL usingCheckDigit)180 CBC_Code39::CBC_Code39(FX_BOOL usingCheckDigit) {
181   m_pBCReader = (CBC_Reader*)new CBC_OnedCode39Reader(usingCheckDigit);
182   m_pBCWriter = (CBC_Writer*)new CBC_OnedCode39Writer;
183 }
CBC_Code39(FX_BOOL usingCheckDigit,FX_BOOL extendedMode)184 CBC_Code39::CBC_Code39(FX_BOOL usingCheckDigit, FX_BOOL extendedMode) {
185   m_pBCReader =
186       (CBC_Reader*)new CBC_OnedCode39Reader(usingCheckDigit, extendedMode);
187   m_pBCWriter = (CBC_Writer*)new CBC_OnedCode39Writer(extendedMode);
188 }
~CBC_Code39()189 CBC_Code39::~CBC_Code39() {
190   if (m_pBCReader) {
191     delete (m_pBCReader);
192     m_pBCReader = NULL;
193   }
194   if (m_pBCWriter) {
195     delete (m_pBCWriter);
196     m_pBCWriter = NULL;
197   }
198 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)199 FX_BOOL CBC_Code39::Encode(const CFX_WideStringC& contents,
200                            FX_BOOL isDevice,
201                            int32_t& e) {
202   if (contents.IsEmpty()) {
203     e = BCExceptionNoContents;
204     return FALSE;
205   }
206   BCFORMAT format = BCFORMAT_CODE_39;
207   int32_t outWidth = 0;
208   int32_t outHeight = 0;
209   CFX_WideString filtercontents =
210       ((CBC_OnedCode39Writer*)m_pBCWriter)->FilterContents(contents);
211   CFX_WideString renderContents =
212       ((CBC_OnedCode39Writer*)m_pBCWriter)->RenderTextContents(contents);
213   m_renderContents = renderContents;
214   CFX_ByteString byteString = filtercontents.UTF8Encode();
215   uint8_t* data = static_cast<CBC_OnedCode39Writer*>(m_pBCWriter)
216                       ->Encode(byteString, format, outWidth, outHeight, e);
217   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
218   ((CBC_OneDimWriter*)m_pBCWriter)
219       ->RenderResult(renderContents, data, outWidth, isDevice, e);
220   FX_Free(data);
221   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
222   return TRUE;
223 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)224 FX_BOOL CBC_Code39::RenderDevice(CFX_RenderDevice* device,
225                                  const CFX_Matrix* matirx,
226                                  int32_t& e) {
227   CFX_WideString renderCon = ((CBC_OnedCode39Writer*)m_pBCWriter)
228                                  ->encodedContents(m_renderContents, e);
229   ((CBC_OneDimWriter*)m_pBCWriter)
230       ->RenderDeviceResult(device, matirx, renderCon, e);
231   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
232   return TRUE;
233 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)234 FX_BOOL CBC_Code39::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
235   CFX_WideString renderCon = ((CBC_OnedCode39Writer*)m_pBCWriter)
236                                  ->encodedContents(m_renderContents, e);
237   ((CBC_OneDimWriter*)m_pBCWriter)
238       ->RenderBitmapResult(pOutBitmap, renderCon, e);
239   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
240   return TRUE;
241 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)242 CFX_WideString CBC_Code39::Decode(uint8_t* buf,
243                                   int32_t width,
244                                   int32_t hight,
245                                   int32_t& e) {
246   CFX_WideString str;
247   return str;
248 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)249 CFX_WideString CBC_Code39::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
250   CBC_BufferedImageLuminanceSource source(pBitmap);
251   CBC_GlobalHistogramBinarizer binarizer(&source);
252   CBC_BinaryBitmap bitmap(&binarizer);
253   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
254   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
255   return CFX_WideString::FromUTF8(str, str.GetLength());
256 }
SetTextLocation(BC_TEXT_LOC location)257 FX_BOOL CBC_Code39::SetTextLocation(BC_TEXT_LOC location) {
258   if (m_pBCWriter) {
259     return ((CBC_OnedCode39Writer*)m_pBCWriter)->SetTextLocation(location);
260   }
261   return FALSE;
262 }
SetWideNarrowRatio(int32_t ratio)263 FX_BOOL CBC_Code39::SetWideNarrowRatio(int32_t ratio) {
264   if (m_pBCWriter) {
265     return ((CBC_OnedCode39Writer*)m_pBCWriter)->SetWideNarrowRatio(ratio);
266   }
267   return FALSE;
268 }
CBC_Codabar()269 CBC_Codabar::CBC_Codabar() {
270   m_pBCReader = (CBC_Reader*)new (CBC_OnedCodaBarReader);
271   m_pBCWriter = (CBC_Writer*)new (CBC_OnedCodaBarWriter);
272 }
~CBC_Codabar()273 CBC_Codabar::~CBC_Codabar() {
274   if (m_pBCReader) {
275     delete (m_pBCReader);
276     m_pBCReader = NULL;
277   }
278   if (m_pBCWriter) {
279     delete (m_pBCWriter);
280     m_pBCWriter = NULL;
281   }
282 }
SetStartChar(FX_CHAR start)283 FX_BOOL CBC_Codabar::SetStartChar(FX_CHAR start) {
284   if (m_pBCWriter) {
285     return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetStartChar(start);
286   }
287   return FALSE;
288 }
SetEndChar(FX_CHAR end)289 FX_BOOL CBC_Codabar::SetEndChar(FX_CHAR end) {
290   if (m_pBCWriter) {
291     return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetEndChar(end);
292   }
293   return FALSE;
294 }
SetTextLocation(BC_TEXT_LOC location)295 FX_BOOL CBC_Codabar::SetTextLocation(BC_TEXT_LOC location) {
296   return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetTextLocation(location);
297 }
SetWideNarrowRatio(int32_t ratio)298 FX_BOOL CBC_Codabar::SetWideNarrowRatio(int32_t ratio) {
299   if (m_pBCWriter) {
300     return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetWideNarrowRatio(ratio);
301   }
302   return FALSE;
303 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)304 FX_BOOL CBC_Codabar::Encode(const CFX_WideStringC& contents,
305                             FX_BOOL isDevice,
306                             int32_t& e) {
307   if (contents.IsEmpty()) {
308     e = BCExceptionNoContents;
309     return FALSE;
310   }
311   BCFORMAT format = BCFORMAT_CODABAR;
312   int32_t outWidth = 0;
313   int32_t outHeight = 0;
314   CFX_WideString filtercontents =
315       ((CBC_OneDimWriter*)m_pBCWriter)->FilterContents(contents);
316   CFX_ByteString byteString = filtercontents.UTF8Encode();
317   m_renderContents = filtercontents;
318   uint8_t* data = static_cast<CBC_OnedCodaBarWriter*>(m_pBCWriter)
319                       ->Encode(byteString, format, outWidth, outHeight, e);
320   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
321   ((CBC_OneDimWriter*)m_pBCWriter)
322       ->RenderResult(filtercontents, data, outWidth, isDevice, e);
323   FX_Free(data);
324   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
325   return TRUE;
326 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)327 FX_BOOL CBC_Codabar::RenderDevice(CFX_RenderDevice* device,
328                                   const CFX_Matrix* matirx,
329                                   int32_t& e) {
330   CFX_WideString renderCon =
331       ((CBC_OnedCodaBarWriter*)m_pBCWriter)->encodedContents(m_renderContents);
332   ((CBC_OneDimWriter*)m_pBCWriter)
333       ->RenderDeviceResult(device, matirx, renderCon, e);
334   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
335   return TRUE;
336 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)337 FX_BOOL CBC_Codabar::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
338   CFX_WideString renderCon =
339       ((CBC_OnedCodaBarWriter*)m_pBCWriter)->encodedContents(m_renderContents);
340   ((CBC_OneDimWriter*)m_pBCWriter)
341       ->RenderBitmapResult(pOutBitmap, renderCon, e);
342   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
343   return TRUE;
344 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)345 CFX_WideString CBC_Codabar::Decode(uint8_t* buf,
346                                    int32_t width,
347                                    int32_t hight,
348                                    int32_t& e) {
349   CFX_WideString str;
350   return str;
351 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)352 CFX_WideString CBC_Codabar::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
353   CBC_BufferedImageLuminanceSource source(pBitmap);
354   CBC_GlobalHistogramBinarizer binarizer(&source);
355   CBC_BinaryBitmap bitmap(&binarizer);
356   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
357   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
358   return CFX_WideString::FromUTF8(str, str.GetLength());
359 }
CBC_Code128(BC_TYPE type)360 CBC_Code128::CBC_Code128(BC_TYPE type) {
361   m_pBCReader = (CBC_Reader*)new (CBC_OnedCode128Reader);
362   m_pBCWriter = (CBC_Writer*)new CBC_OnedCode128Writer(type);
363 }
~CBC_Code128()364 CBC_Code128::~CBC_Code128() {
365   if (m_pBCReader) {
366     delete (m_pBCReader);
367     m_pBCReader = NULL;
368   }
369   if (m_pBCWriter) {
370     delete (m_pBCWriter);
371     m_pBCWriter = NULL;
372   }
373 }
SetTextLocation(BC_TEXT_LOC location)374 FX_BOOL CBC_Code128::SetTextLocation(BC_TEXT_LOC location) {
375   if (m_pBCWriter) {
376     return ((CBC_OnedCode128Writer*)m_pBCWriter)->SetTextLocation(location);
377   }
378   return FALSE;
379 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)380 FX_BOOL CBC_Code128::Encode(const CFX_WideStringC& contents,
381                             FX_BOOL isDevice,
382                             int32_t& e) {
383   if (contents.IsEmpty()) {
384     e = BCExceptionNoContents;
385     return FALSE;
386   }
387   BCFORMAT format = BCFORMAT_CODE_128;
388   int32_t outWidth = 0;
389   int32_t outHeight = 0;
390   CFX_WideString content = contents;
391   if (contents.GetLength() % 2 &&
392       ((CBC_OnedCode128Writer*)m_pBCWriter)->GetType() == BC_CODE128_C) {
393     content += '0';
394   }
395   CFX_WideString encodeContents =
396       ((CBC_OnedCode128Writer*)m_pBCWriter)->FilterContents(content);
397   m_renderContents = encodeContents;
398   CFX_ByteString byteString = encodeContents.UTF8Encode();
399   uint8_t* data = static_cast<CBC_OnedCode128Writer*>(m_pBCWriter)
400                       ->Encode(byteString, format, outWidth, outHeight, e);
401   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
402   ((CBC_OneDimWriter*)m_pBCWriter)
403       ->RenderResult(encodeContents, data, outWidth, isDevice, e);
404   FX_Free(data);
405   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
406   return TRUE;
407 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)408 FX_BOOL CBC_Code128::RenderDevice(CFX_RenderDevice* device,
409                                   const CFX_Matrix* matirx,
410                                   int32_t& e) {
411   ((CBC_OneDimWriter*)m_pBCWriter)
412       ->RenderDeviceResult(device, matirx, m_renderContents, e);
413   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
414   return TRUE;
415 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)416 FX_BOOL CBC_Code128::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
417   ((CBC_OneDimWriter*)m_pBCWriter)
418       ->RenderBitmapResult(pOutBitmap, m_renderContents, e);
419   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
420   return TRUE;
421 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)422 CFX_WideString CBC_Code128::Decode(uint8_t* buf,
423                                    int32_t width,
424                                    int32_t hight,
425                                    int32_t& e) {
426   CFX_WideString str;
427   return str;
428 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)429 CFX_WideString CBC_Code128::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
430   CBC_BufferedImageLuminanceSource source(pBitmap);
431   CBC_GlobalHistogramBinarizer binarizer(&source);
432   CBC_BinaryBitmap bitmap(&binarizer);
433   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
434   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
435   return CFX_WideString::FromUTF8(str, str.GetLength());
436 }
CBC_EAN8()437 CBC_EAN8::CBC_EAN8() {
438   m_pBCReader = (CBC_Reader*)new (CBC_OnedEAN8Reader);
439   m_pBCWriter = (CBC_Writer*)new (CBC_OnedEAN8Writer);
440 }
~CBC_EAN8()441 CBC_EAN8::~CBC_EAN8() {
442   if (m_pBCReader) {
443     delete (m_pBCReader);
444     m_pBCReader = NULL;
445   }
446   if (m_pBCWriter) {
447     delete (m_pBCWriter);
448     m_pBCWriter = NULL;
449   }
450 }
Preprocess(const CFX_WideStringC & contents)451 CFX_WideString CBC_EAN8::Preprocess(const CFX_WideStringC& contents) {
452   CFX_WideString encodeContents =
453       ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);
454   int32_t length = encodeContents.GetLength();
455   if (length <= 7) {
456     for (int32_t i = 0; i < 7 - length; i++) {
457       encodeContents = FX_WCHAR('0') + encodeContents;
458     }
459     CFX_ByteString byteString = encodeContents.UTF8Encode();
460     int32_t checksum =
461         ((CBC_OnedEAN8Writer*)m_pBCWriter)->CalcChecksum(byteString);
462     encodeContents += FX_WCHAR(checksum - 0 + '0');
463   }
464   if (length > 8) {
465     encodeContents = encodeContents.Mid(0, 8);
466   }
467   return encodeContents;
468 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)469 FX_BOOL CBC_EAN8::Encode(const CFX_WideStringC& contents,
470                          FX_BOOL isDevice,
471                          int32_t& e) {
472   if (contents.IsEmpty()) {
473     e = BCExceptionNoContents;
474     return FALSE;
475   }
476   BCFORMAT format = BCFORMAT_EAN_8;
477   int32_t outWidth = 0;
478   int32_t outHeight = 0;
479   CFX_WideString encodeContents = Preprocess(contents);
480   CFX_ByteString byteString = encodeContents.UTF8Encode();
481   m_renderContents = encodeContents;
482   uint8_t* data = static_cast<CBC_OnedEAN8Writer*>(m_pBCWriter)
483                       ->Encode(byteString, format, outWidth, outHeight, e);
484   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
485   ((CBC_OneDimWriter*)m_pBCWriter)
486       ->RenderResult(encodeContents, data, outWidth, isDevice, e);
487   FX_Free(data);
488   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
489   return TRUE;
490 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)491 FX_BOOL CBC_EAN8::RenderDevice(CFX_RenderDevice* device,
492                                const CFX_Matrix* matirx,
493                                int32_t& e) {
494   ((CBC_OneDimWriter*)m_pBCWriter)
495       ->RenderDeviceResult(device, matirx, m_renderContents, e);
496   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
497   return TRUE;
498 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)499 FX_BOOL CBC_EAN8::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
500   ((CBC_OneDimWriter*)m_pBCWriter)
501       ->RenderBitmapResult(pOutBitmap, m_renderContents, e);
502   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
503   return TRUE;
504 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)505 CFX_WideString CBC_EAN8::Decode(uint8_t* buf,
506                                 int32_t width,
507                                 int32_t hight,
508                                 int32_t& e) {
509   CFX_WideString str;
510   return str;
511 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)512 CFX_WideString CBC_EAN8::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
513   CBC_BufferedImageLuminanceSource source(pBitmap);
514   CBC_GlobalHistogramBinarizer binarizer(&source);
515   CBC_BinaryBitmap bitmap(&binarizer);
516   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
517   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
518   return CFX_WideString::FromUTF8(str, str.GetLength());
519 }
CBC_EAN13()520 CBC_EAN13::CBC_EAN13() {
521   m_pBCReader = (CBC_Reader*)new (CBC_OnedEAN13Reader);
522   m_pBCWriter = (CBC_Writer*)new (CBC_OnedEAN13Writer);
523 }
~CBC_EAN13()524 CBC_EAN13::~CBC_EAN13() {
525   if (m_pBCReader) {
526     delete (m_pBCReader);
527     m_pBCReader = NULL;
528   }
529   if (m_pBCWriter) {
530     delete (m_pBCWriter);
531     m_pBCWriter = NULL;
532   }
533 }
Preprocess(const CFX_WideStringC & contents)534 CFX_WideString CBC_EAN13::Preprocess(const CFX_WideStringC& contents) {
535   CFX_WideString encodeContents =
536       ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);
537   int32_t length = encodeContents.GetLength();
538   if (length <= 12) {
539     for (int32_t i = 0; i < 12 - length; i++) {
540       encodeContents = FX_WCHAR('0') + encodeContents;
541     }
542     CFX_ByteString byteString = encodeContents.UTF8Encode();
543     int32_t checksum =
544         ((CBC_OnedEAN13Writer*)m_pBCWriter)->CalcChecksum(byteString);
545     byteString += checksum - 0 + '0';
546     encodeContents = byteString.UTF8Decode();
547   }
548   if (length > 13) {
549     encodeContents = encodeContents.Mid(0, 13);
550   }
551   return encodeContents;
552 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)553 FX_BOOL CBC_EAN13::Encode(const CFX_WideStringC& contents,
554                           FX_BOOL isDevice,
555                           int32_t& e) {
556   if (contents.IsEmpty()) {
557     e = BCExceptionNoContents;
558     return FALSE;
559   }
560   BCFORMAT format = BCFORMAT_EAN_13;
561   int32_t outWidth = 0;
562   int32_t outHeight = 0;
563   CFX_WideString encodeContents = Preprocess(contents);
564   CFX_ByteString byteString = encodeContents.UTF8Encode();
565   m_renderContents = encodeContents;
566   uint8_t* data = static_cast<CBC_OnedEAN13Writer*>(m_pBCWriter)
567                       ->Encode(byteString, format, outWidth, outHeight, e);
568   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
569   ((CBC_OneDimWriter*)m_pBCWriter)
570       ->RenderResult(encodeContents, data, outWidth, isDevice, e);
571   FX_Free(data);
572   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
573   return TRUE;
574 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)575 FX_BOOL CBC_EAN13::RenderDevice(CFX_RenderDevice* device,
576                                 const CFX_Matrix* matirx,
577                                 int32_t& e) {
578   ((CBC_OneDimWriter*)m_pBCWriter)
579       ->RenderDeviceResult(device, matirx, m_renderContents, e);
580   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
581   return TRUE;
582 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)583 FX_BOOL CBC_EAN13::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
584   ((CBC_OneDimWriter*)m_pBCWriter)
585       ->RenderBitmapResult(pOutBitmap, m_renderContents, e);
586   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
587   return TRUE;
588 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)589 CFX_WideString CBC_EAN13::Decode(uint8_t* buf,
590                                  int32_t width,
591                                  int32_t hight,
592                                  int32_t& e) {
593   CFX_WideString str;
594   return str;
595 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)596 CFX_WideString CBC_EAN13::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
597   CBC_BufferedImageLuminanceSource source(pBitmap);
598   CBC_GlobalHistogramBinarizer binarizer(&source);
599   CBC_BinaryBitmap bitmap(&binarizer);
600   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
601   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
602   return CFX_WideString::FromUTF8(str, str.GetLength());
603 }
CBC_UPCA()604 CBC_UPCA::CBC_UPCA() {
605   m_pBCReader = (CBC_Reader*)new (CBC_OnedUPCAReader);
606   ((CBC_OnedUPCAReader*)m_pBCReader)->Init();
607   m_pBCWriter = (CBC_Writer*)new (CBC_OnedUPCAWriter);
608 }
~CBC_UPCA()609 CBC_UPCA::~CBC_UPCA() {
610   if (m_pBCReader) {
611     delete (m_pBCReader);
612     m_pBCReader = NULL;
613   }
614   if (m_pBCWriter) {
615     delete (m_pBCWriter);
616     m_pBCWriter = NULL;
617   }
618 }
Preprocess(const CFX_WideStringC & contents)619 CFX_WideString CBC_UPCA::Preprocess(const CFX_WideStringC& contents) {
620   CFX_WideString encodeContents =
621       ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);
622   int32_t length = encodeContents.GetLength();
623   if (length <= 11) {
624     for (int32_t i = 0; i < 11 - length; i++) {
625       encodeContents = FX_WCHAR('0') + encodeContents;
626     }
627     CFX_ByteString byteString = encodeContents.UTF8Encode();
628     int32_t checksum =
629         ((CBC_OnedUPCAWriter*)m_pBCWriter)->CalcChecksum(byteString);
630     byteString += checksum - 0 + '0';
631     encodeContents = byteString.UTF8Decode();
632   }
633   if (length > 12) {
634     encodeContents = encodeContents.Mid(0, 12);
635   }
636   return encodeContents;
637 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)638 FX_BOOL CBC_UPCA::Encode(const CFX_WideStringC& contents,
639                          FX_BOOL isDevice,
640                          int32_t& e) {
641   if (contents.IsEmpty()) {
642     e = BCExceptionNoContents;
643     return FALSE;
644   }
645   BCFORMAT format = BCFORMAT_UPC_A;
646   int32_t outWidth = 0;
647   int32_t outHeight = 0;
648   CFX_WideString encodeContents = Preprocess(contents);
649   CFX_ByteString byteString = encodeContents.UTF8Encode();
650   m_renderContents = encodeContents;
651   ((CBC_OnedUPCAWriter*)m_pBCWriter)->Init();
652   uint8_t* data = static_cast<CBC_OnedUPCAWriter*>(m_pBCWriter)
653                       ->Encode(byteString, format, outWidth, outHeight, e);
654   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
655   ((CBC_OneDimWriter*)m_pBCWriter)
656       ->RenderResult(encodeContents, data, outWidth, isDevice, e);
657   FX_Free(data);
658   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
659   return TRUE;
660 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)661 FX_BOOL CBC_UPCA::RenderDevice(CFX_RenderDevice* device,
662                                const CFX_Matrix* matirx,
663                                int32_t& e) {
664   ((CBC_OneDimWriter*)m_pBCWriter)
665       ->RenderDeviceResult(device, matirx, m_renderContents, e);
666   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
667   return TRUE;
668 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)669 FX_BOOL CBC_UPCA::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
670   ((CBC_OneDimWriter*)m_pBCWriter)
671       ->RenderBitmapResult(pOutBitmap, m_renderContents, e);
672   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
673   return TRUE;
674 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)675 CFX_WideString CBC_UPCA::Decode(uint8_t* buf,
676                                 int32_t width,
677                                 int32_t hight,
678                                 int32_t& e) {
679   CFX_WideString str;
680   return str;
681 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)682 CFX_WideString CBC_UPCA::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
683   CBC_BufferedImageLuminanceSource source(pBitmap);
684   CBC_GlobalHistogramBinarizer binarizer(&source);
685   CBC_BinaryBitmap bitmap(&binarizer);
686   CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);
687   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
688   return CFX_WideString::FromUTF8(str, str.GetLength());
689 }
CBC_QRCode()690 CBC_QRCode::CBC_QRCode() {
691   m_pBCReader = (CBC_Reader*)new (CBC_QRCodeReader);
692   ((CBC_QRCodeReader*)m_pBCReader)->Init();
693   m_pBCWriter = (CBC_Writer*)new (CBC_QRCodeWriter);
694 }
~CBC_QRCode()695 CBC_QRCode::~CBC_QRCode() {
696   if (m_pBCReader) {
697     delete (m_pBCReader);
698     m_pBCReader = NULL;
699   }
700   if (m_pBCWriter) {
701     delete (m_pBCWriter);
702     m_pBCWriter = NULL;
703   }
704 }
SetVersion(int32_t version)705 FX_BOOL CBC_QRCode::SetVersion(int32_t version) {
706   if (version < 0 || version > 40) {
707     return FALSE;
708   }
709   if (m_pBCWriter == NULL) {
710     return FALSE;
711   }
712   return ((CBC_QRCodeWriter*)m_pBCWriter)->SetVersion(version);
713 }
SetErrorCorrectionLevel(int32_t level)714 FX_BOOL CBC_QRCode::SetErrorCorrectionLevel(int32_t level) {
715   if (level < 0 || level > 3) {
716     return FALSE;
717   }
718   if (m_pBCWriter == NULL) {
719     return FALSE;
720   }
721   return ((CBC_TwoDimWriter*)m_pBCWriter)->SetErrorCorrectionLevel(level);
722 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)723 FX_BOOL CBC_QRCode::Encode(const CFX_WideStringC& contents,
724                            FX_BOOL isDevice,
725                            int32_t& e) {
726   int32_t outWidth = 0;
727   int32_t outHeight = 0;
728   uint8_t* data = ((CBC_QRCodeWriter*)m_pBCWriter)
729                       ->Encode(contents, ((CBC_QRCodeWriter*)m_pBCWriter)
730                                              ->GetErrorCorrectionLevel(),
731                                outWidth, outHeight, e);
732   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
733   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);
734   FX_Free(data);
735   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
736   return TRUE;
737 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)738 FX_BOOL CBC_QRCode::RenderDevice(CFX_RenderDevice* device,
739                                  const CFX_Matrix* matirx,
740                                  int32_t& e) {
741   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);
742   return TRUE;
743 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)744 FX_BOOL CBC_QRCode::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
745   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);
746   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
747   return TRUE;
748 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)749 CFX_WideString CBC_QRCode::Decode(uint8_t* buf,
750                                   int32_t width,
751                                   int32_t hight,
752                                   int32_t& e) {
753   CFX_WideString str;
754   return str;
755 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)756 CFX_WideString CBC_QRCode::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
757   CBC_BufferedImageLuminanceSource source(pBitmap);
758   CBC_GlobalHistogramBinarizer binarizer(&source);
759   CBC_BinaryBitmap bitmap(&binarizer);
760   CFX_ByteString retStr = m_pBCReader->Decode(&bitmap, 0, e);
761   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
762   return CFX_WideString::FromUTF8(retStr, retStr.GetLength());
763 }
CBC_PDF417I()764 CBC_PDF417I::CBC_PDF417I() {
765   m_pBCReader = (CBC_Reader*)new (CBC_PDF417Reader);
766   m_pBCWriter = (CBC_Writer*)new (CBC_PDF417Writer);
767 }
~CBC_PDF417I()768 CBC_PDF417I::~CBC_PDF417I() {
769   if (m_pBCReader) {
770     delete (m_pBCReader);
771     m_pBCReader = NULL;
772   }
773   if (m_pBCWriter) {
774     delete (m_pBCWriter);
775     m_pBCWriter = NULL;
776   }
777 }
SetErrorCorrectionLevel(int32_t level)778 FX_BOOL CBC_PDF417I::SetErrorCorrectionLevel(int32_t level) {
779   ((CBC_PDF417Writer*)m_pBCWriter)->SetErrorCorrectionLevel(level);
780   return TRUE;
781 }
SetTruncated(FX_BOOL truncated)782 void CBC_PDF417I::SetTruncated(FX_BOOL truncated) {
783   ((CBC_PDF417Writer*)m_pBCWriter)->SetTruncated(truncated);
784 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)785 FX_BOOL CBC_PDF417I::Encode(const CFX_WideStringC& contents,
786                             FX_BOOL isDevice,
787                             int32_t& e) {
788   int32_t outWidth = 0;
789   int32_t outHeight = 0;
790   uint8_t* data = ((CBC_PDF417Writer*)m_pBCWriter)
791                       ->Encode(contents, outWidth, outHeight, e);
792   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
793   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);
794   FX_Free(data);
795   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
796   return TRUE;
797 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)798 FX_BOOL CBC_PDF417I::RenderDevice(CFX_RenderDevice* device,
799                                   const CFX_Matrix* matirx,
800                                   int32_t& e) {
801   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);
802   return TRUE;
803 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)804 FX_BOOL CBC_PDF417I::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
805   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);
806   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
807   return TRUE;
808 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)809 CFX_WideString CBC_PDF417I::Decode(uint8_t* buf,
810                                    int32_t width,
811                                    int32_t hight,
812                                    int32_t& e) {
813   CFX_WideString str;
814   return str;
815 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)816 CFX_WideString CBC_PDF417I::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
817   CBC_BufferedImageLuminanceSource source(pBitmap);
818   CBC_GlobalHistogramBinarizer binarizer(&source);
819   CBC_BinaryBitmap bitmap(&binarizer);
820   CFX_ByteString bytestring = m_pBCReader->Decode(&bitmap, 0, e);
821   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
822   return CFX_WideString::FromUTF8(bytestring, bytestring.GetLength());
823 }
CBC_DataMatrix()824 CBC_DataMatrix::CBC_DataMatrix() {
825   m_pBCReader = (CBC_Reader*)new (CBC_DataMatrixReader);
826   ((CBC_DataMatrixReader*)m_pBCReader)->Init();
827   m_pBCWriter = (CBC_Writer*)new (CBC_DataMatrixWriter);
828 }
~CBC_DataMatrix()829 CBC_DataMatrix::~CBC_DataMatrix() {
830   if (m_pBCReader) {
831     delete (m_pBCReader);
832     m_pBCReader = NULL;
833   }
834   if (m_pBCWriter) {
835     delete (m_pBCWriter);
836     m_pBCWriter = NULL;
837   }
838 }
Encode(const CFX_WideStringC & contents,FX_BOOL isDevice,int32_t & e)839 FX_BOOL CBC_DataMatrix::Encode(const CFX_WideStringC& contents,
840                                FX_BOOL isDevice,
841                                int32_t& e) {
842   int32_t outWidth = 0;
843   int32_t outHeight = 0;
844   uint8_t* data = ((CBC_DataMatrixWriter*)m_pBCWriter)
845                       ->Encode(contents, outWidth, outHeight, e);
846   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
847   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);
848   FX_Free(data);
849   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
850   return TRUE;
851 }
RenderDevice(CFX_RenderDevice * device,const CFX_Matrix * matirx,int32_t & e)852 FX_BOOL CBC_DataMatrix::RenderDevice(CFX_RenderDevice* device,
853                                      const CFX_Matrix* matirx,
854                                      int32_t& e) {
855   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);
856   return TRUE;
857 }
RenderBitmap(CFX_DIBitmap * & pOutBitmap,int32_t & e)858 FX_BOOL CBC_DataMatrix::RenderBitmap(CFX_DIBitmap*& pOutBitmap, int32_t& e) {
859   ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);
860   BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);
861   return TRUE;
862 }
Decode(uint8_t * buf,int32_t width,int32_t hight,int32_t & e)863 CFX_WideString CBC_DataMatrix::Decode(uint8_t* buf,
864                                       int32_t width,
865                                       int32_t hight,
866                                       int32_t& e) {
867   CFX_WideString str;
868   return str;
869 }
Decode(CFX_DIBitmap * pBitmap,int32_t & e)870 CFX_WideString CBC_DataMatrix::Decode(CFX_DIBitmap* pBitmap, int32_t& e) {
871   CBC_BufferedImageLuminanceSource source(pBitmap);
872   CBC_GlobalHistogramBinarizer binarizer(&source);
873   CBC_BinaryBitmap bitmap(&binarizer);
874   CFX_ByteString retStr = m_pBCReader->Decode(&bitmap, 0, e);
875   BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));
876   return CFX_WideString::FromUTF8(retStr, retStr.GetLength());
877 }
878