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 2010 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/fxbarcode/BC_Writer.h"
24#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h"
25#include "xfa/fxbarcode/oned/BC_OneDimWriter.h"
26#include "xfa/fxbarcode/oned/BC_OnedCode39Writer.h"
27
28namespace {
29
30const FX_CHAR ALPHABET_STRING[] =
31    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
32
33const FX_CHAR CHECKSUM_STRING[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%";
34
35const int32_t CHARACTER_ENCODINGS[44] = {
36    0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124,
37    0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C,
38    0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007,
39    0x106, 0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0,
40    0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A};
41
42}  // namespace
43
44CBC_OnedCode39Writer::CBC_OnedCode39Writer() {
45  m_iWideNarrRatio = 3;
46}
47CBC_OnedCode39Writer::~CBC_OnedCode39Writer() {}
48bool CBC_OnedCode39Writer::CheckContentValidity(
49    const CFX_WideStringC& contents) {
50  for (int32_t i = 0; i < contents.GetLength(); i++) {
51    FX_WCHAR ch = contents.GetAt(i);
52    if ((ch >= (FX_WCHAR)'0' && ch <= (FX_WCHAR)'9') ||
53        (ch >= (FX_WCHAR)'A' && ch <= (FX_WCHAR)'Z') || ch == (FX_WCHAR)'-' ||
54        ch == (FX_WCHAR)'.' || ch == (FX_WCHAR)' ' || ch == (FX_WCHAR)'*' ||
55        ch == (FX_WCHAR)'$' || ch == (FX_WCHAR)'/' || ch == (FX_WCHAR)'+' ||
56        ch == (FX_WCHAR)'%') {
57      continue;
58    }
59    return false;
60  }
61  return true;
62}
63
64CFX_WideString CBC_OnedCode39Writer::FilterContents(
65    const CFX_WideStringC& contents) {
66  CFX_WideString filtercontents;
67  for (int32_t i = 0; i < contents.GetLength(); i++) {
68    FX_WCHAR ch = contents.GetAt(i);
69    if (ch == (FX_WCHAR)'*' && (i == 0 || i == contents.GetLength() - 1)) {
70      continue;
71    }
72    if (ch > 175) {
73      i++;
74      continue;
75    } else {
76      ch = Upper(ch);
77    }
78    if ((ch >= (FX_WCHAR)'0' && ch <= (FX_WCHAR)'9') ||
79        (ch >= (FX_WCHAR)'A' && ch <= (FX_WCHAR)'Z') || ch == (FX_WCHAR)'-' ||
80        ch == (FX_WCHAR)'.' || ch == (FX_WCHAR)' ' || ch == (FX_WCHAR)'*' ||
81        ch == (FX_WCHAR)'$' || ch == (FX_WCHAR)'/' || ch == (FX_WCHAR)'+' ||
82        ch == (FX_WCHAR)'%') {
83      filtercontents += ch;
84    }
85  }
86  return filtercontents;
87}
88
89CFX_WideString CBC_OnedCode39Writer::RenderTextContents(
90    const CFX_WideStringC& contents) {
91  CFX_WideString renderContents;
92  for (int32_t i = 0; i < contents.GetLength(); i++) {
93    FX_WCHAR ch = contents.GetAt(i);
94    if (ch == (FX_WCHAR)'*' && (i == 0 || i == contents.GetLength() - 1)) {
95      continue;
96    }
97    if (ch > 175) {
98      i++;
99      continue;
100    }
101    if ((ch >= (FX_WCHAR)'0' && ch <= (FX_WCHAR)'9') ||
102        (ch >= (FX_WCHAR)'A' && ch <= (FX_WCHAR)'Z') ||
103        (ch >= (FX_WCHAR)'a' && ch <= (FX_WCHAR)'z') || ch == (FX_WCHAR)'-' ||
104        ch == (FX_WCHAR)'.' || ch == (FX_WCHAR)' ' || ch == (FX_WCHAR)'*' ||
105        ch == (FX_WCHAR)'$' || ch == (FX_WCHAR)'/' || ch == (FX_WCHAR)'+' ||
106        ch == (FX_WCHAR)'%') {
107      renderContents += ch;
108    }
109  }
110  return renderContents;
111}
112
113bool CBC_OnedCode39Writer::SetTextLocation(BC_TEXT_LOC location) {
114  if (location < BC_TEXT_LOC_NONE || location > BC_TEXT_LOC_BELOWEMBED) {
115    return false;
116  }
117  m_locTextLoc = location;
118  return true;
119}
120bool CBC_OnedCode39Writer::SetWideNarrowRatio(int32_t ratio) {
121  if (ratio < 2 || ratio > 3) {
122    return false;
123  }
124  m_iWideNarrRatio = ratio;
125  return true;
126}
127uint8_t* CBC_OnedCode39Writer::Encode(const CFX_ByteString& contents,
128                                      BCFORMAT format,
129                                      int32_t& outWidth,
130                                      int32_t& outHeight,
131                                      int32_t& e) {
132  uint8_t* ret = Encode(contents, format, outWidth, outHeight, 0, e);
133  if (e != BCExceptionNO)
134    return nullptr;
135  return ret;
136}
137uint8_t* CBC_OnedCode39Writer::Encode(const CFX_ByteString& contents,
138                                      BCFORMAT format,
139                                      int32_t& outWidth,
140                                      int32_t& outHeight,
141                                      int32_t hints,
142                                      int32_t& e) {
143  if (format != BCFORMAT_CODE_39) {
144    e = BCExceptionOnlyEncodeCODE_39;
145    return nullptr;
146  }
147  uint8_t* ret =
148      CBC_OneDimWriter::Encode(contents, format, outWidth, outHeight, hints, e);
149  if (e != BCExceptionNO)
150    return nullptr;
151  return ret;
152}
153void CBC_OnedCode39Writer::ToIntArray(int32_t a, int32_t* toReturn) {
154  for (int32_t i = 0; i < 9; i++) {
155    toReturn[i] = (a & (1 << i)) == 0 ? 1 : m_iWideNarrRatio;
156  }
157}
158FX_CHAR CBC_OnedCode39Writer::CalcCheckSum(const CFX_ByteString& contents,
159                                           int32_t& e) {
160  int32_t length = contents.GetLength();
161  if (length > 80) {
162    e = BCExceptionContentsLengthShouldBetween1and80;
163    return '*';
164  }
165  int32_t checksum = 0;
166  int32_t len = (int32_t)strlen(ALPHABET_STRING);
167  for (int32_t i = 0; i < contents.GetLength(); i++) {
168    int32_t j = 0;
169    for (; j < len; j++) {
170      if (ALPHABET_STRING[j] == contents[i]) {
171        if (contents[i] != '*') {
172          checksum += j;
173          break;
174        } else {
175          break;
176        }
177      }
178    }
179    if (j >= len) {
180      e = BCExceptionUnSupportedString;
181      return '*';
182    }
183  }
184  checksum = checksum % 43;
185  return CHECKSUM_STRING[checksum];
186}
187uint8_t* CBC_OnedCode39Writer::Encode(const CFX_ByteString& contents,
188                                      int32_t& outlength,
189                                      int32_t& e) {
190  FX_CHAR checksum = CalcCheckSum(contents, e);
191  if (checksum == '*') {
192    return nullptr;
193  }
194  int32_t widths[9] = {0};
195  int32_t wideStrideNum = 3;
196  int32_t narrStrideNum = 9 - wideStrideNum;
197  CFX_ByteString encodedContents = contents;
198  if (m_bCalcChecksum) {
199    encodedContents += checksum;
200  }
201  m_iContentLen = encodedContents.GetLength();
202  int32_t codeWidth = (wideStrideNum * m_iWideNarrRatio + narrStrideNum) * 2 +
203                      1 + m_iContentLen;
204  int32_t len = (int32_t)strlen(ALPHABET_STRING);
205  for (int32_t j = 0; j < m_iContentLen; j++) {
206    for (int32_t i = 0; i < len; i++) {
207      if (ALPHABET_STRING[i] == encodedContents[j]) {
208        ToIntArray(CHARACTER_ENCODINGS[i], widths);
209        for (int32_t k = 0; k < 9; k++) {
210          codeWidth += widths[k];
211        }
212      }
213    }
214  }
215  outlength = codeWidth;
216  uint8_t* result = FX_Alloc(uint8_t, codeWidth);
217  ToIntArray(CHARACTER_ENCODINGS[39], widths);
218  int32_t pos = AppendPattern(result, 0, widths, 9, 1, e);
219  if (e != BCExceptionNO) {
220    FX_Free(result);
221    return nullptr;
222  }
223  int32_t narrowWhite[] = {1};
224  pos += AppendPattern(result, pos, narrowWhite, 1, 0, e);
225  if (e != BCExceptionNO) {
226    FX_Free(result);
227    return nullptr;
228  }
229  for (int32_t l = m_iContentLen - 1; l >= 0; l--) {
230    for (int32_t i = 0; i < len; i++) {
231      if (ALPHABET_STRING[i] == encodedContents[l]) {
232        ToIntArray(CHARACTER_ENCODINGS[i], widths);
233        pos += AppendPattern(result, pos, widths, 9, 1, e);
234        if (e != BCExceptionNO) {
235          FX_Free(result);
236          return nullptr;
237        }
238      }
239    }
240    pos += AppendPattern(result, pos, narrowWhite, 1, 0, e);
241    if (e != BCExceptionNO) {
242      FX_Free(result);
243      return nullptr;
244    }
245  }
246  ToIntArray(CHARACTER_ENCODINGS[39], widths);
247  pos += AppendPattern(result, pos, widths, 9, 1, e);
248  if (e != BCExceptionNO) {
249    FX_Free(result);
250    return nullptr;
251  }
252  for (int32_t i = 0; i < codeWidth / 2; i++) {
253    result[i] ^= result[codeWidth - 1 - i];
254    result[codeWidth - 1 - i] ^= result[i];
255    result[i] ^= result[codeWidth - 1 - i];
256  }
257  return result;
258}
259CFX_WideString CBC_OnedCode39Writer::encodedContents(
260    const CFX_WideStringC& contents,
261    int32_t& e) {
262  CFX_WideString encodedContents(contents);
263  if (m_bCalcChecksum && m_bPrintChecksum) {
264    CFX_WideString checksumContent = FilterContents(contents);
265    CFX_ByteString str = checksumContent.UTF8Encode();
266    FX_CHAR checksum;
267    checksum = CalcCheckSum(str, e);
268    if (e != BCExceptionNO)
269      return CFX_WideString();
270    str += checksum;
271    encodedContents += checksum;
272  }
273  return encodedContents;
274}
275void CBC_OnedCode39Writer::RenderResult(const CFX_WideStringC& contents,
276                                        uint8_t* code,
277                                        int32_t codeLength,
278                                        bool isDevice,
279                                        int32_t& e) {
280  CFX_WideString encodedCon = encodedContents(contents, e);
281  if (e != BCExceptionNO)
282    return;
283  CBC_OneDimWriter::RenderResult(encodedCon.AsStringC(), code, codeLength,
284                                 isDevice, e);
285}
286