[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/app/qrencode/common.c b/ap/app/qrencode/common.c
new file mode 100755
index 0000000..c010f4c
--- /dev/null
+++ b/ap/app/qrencode/common.c
@@ -0,0 +1,512 @@
+#include "common.h"
+
+#define LINE_LEN 79
+#define STATUS_LEN 22
+#define PROGBAR_MAX (LINE_LEN - STATUS_LEN - 1)
+
+static char status_msg[128];
+static int progbar_scale = 0;
+static int progbar_len = 0;
+static int progbar_pos = -1;
+
+int quietmode = 0;
+int errorlog = 0;
+
+static png_uint_32 counter;
+static png_uint_32 maxcount;
+static int barlen;
+
+#define isoption(p) (IsOptChar((p)[0]) && (p)[1]!='\0')
+
+static void print_status(void)
+{
+ fprintf(stderr, "\r%-*.*s ", STATUS_LEN, STATUS_LEN, status_msg);
+ fflush(stderr);
+ progbar_pos = 0;
+}
+
+static void put_dots(int dotchar, int num)
+{
+ int i;
+
+ if (num > PROGBAR_MAX) num = PROGBAR_MAX;
+ if (progbar_pos == -1) print_status();
+
+ for (i = progbar_pos; i < num; i++)
+ fputc(dotchar, stderr);
+
+ if (progbar_pos < num) {
+ progbar_pos = num;
+ fflush(stderr);
+ }
+}
+
+static void print_scale(void)
+{
+ if (progbar_pos != 0) print_status();
+ put_dots('.', progbar_len);
+ print_status();
+ progbar_scale = 1;
+}
+
+static void init_progress_bar(int max)
+{
+ if (quietmode) return;
+
+ progbar_len = max;
+ print_scale();
+}
+
+static void update_progress_bar(int num)
+{
+ if (quietmode) return;
+
+ if (!progbar_scale) print_scale();
+ put_dots('o', num);
+}
+
+static void clear_line(void)
+{
+ if (quietmode) return;
+
+ fprintf(stderr, "\r%*c\r", LINE_LEN, ' ');
+ progbar_scale = 0;
+ progbar_pos = -1;
+}
+
+void xxprintf(const char *fmt, ...)
+{
+ va_list ap;
+ FILE *f;
+
+ va_start(ap, fmt);
+
+ clear_line();
+ vfprintf(stderr, fmt, ap);
+ fflush(stderr);
+
+ if (errorlog && (f = fopen(errlogfile, "a")) != NULL) {
+ vfprintf(f, fmt, ap);
+ fclose(f);
+ }
+
+ va_end(ap);
+}
+
+void set_status(const char *fmt, ...)
+{
+ va_list ap;
+
+ if (quietmode) return;
+
+ va_start(ap, fmt);
+ vsprintf(status_msg, fmt, ap);
+ va_end(ap);
+
+ print_status();
+}
+
+void feed_line(void)
+{
+ if (quietmode) return;
+
+ fputc('\n', stderr);
+ fflush(stderr);
+ progbar_scale = 0;
+ progbar_pos = -1;
+}
+
+static png_uint_32 maxcount_adam7(png_uint_32 width, png_uint_32 height)
+{
+ png_uint_32 c = 0;
+
+ if ( 1 ) c += ((height - 0 + 7) / 8) * 1;
+ if (width > 4) c += ((height - 0 + 7) / 8) * 1;
+ if ( 1 ) c += ((height - 4 + 7) / 8) * 2;
+ if (width > 2) c += ((height - 0 + 3) / 4) * 2;
+ if ( 1 ) c += ((height - 2 + 3) / 4) * 4;
+ if (width > 1) c += ((height - 0 + 1) / 2) * 4;
+ if ( 1 ) c += ((height - 1 + 1) / 2) * 8;
+
+ return c;
+}
+
+void init_progress_meter(png_structp png_ptr, png_uint_32 width,
+ png_uint_32 height)
+{
+ enum { W = 1024, H = 768 };
+
+ if (png_set_interlace_handling(png_ptr) == 7) {
+ maxcount = maxcount_adam7(width, height);
+ } else {
+ maxcount = height;
+ }
+ if (height > ((png_uint_32)W * H) / width) {
+ barlen = PROGBAR_MAX;
+ } else {
+ barlen = (PROGBAR_MAX * width * height + (W * H - 1)) / (W * H);
+ }
+ counter = 0;
+ init_progress_bar(barlen);
+}
+
+void row_callback(png_structp png_ptr, png_uint_32 row, int pass)
+{
+
+ if (row == 0) pass--;
+
+
+ counter += (1 << (pass >> 1)); /* step[pass]; */
+ update_progress_bar(barlen * counter / maxcount);
+}
+
+FILE *binary_stdio(int fd)
+{
+ FILE *fp;
+
+ if (fd != 0 && fd != 1)
+ return NULL;
+
+ printf("---------binary_stdio----else ------\n");
+ fp = (fd == 0) ? stdin : stdout;
+
+ return fp;
+}
+
+char *suffix(const char *path)
+{
+ char c, *p, *q, *r;
+
+ for (r = q = p = basname(path); (c = *p) != '\0'; p++)
+ if (c == '.') q = p;
+ if (q == r) q = p; /* dotfile with no suffix */
+
+ return q;
+}
+
+char *basname(const char *path)
+{
+ const char *p, *q;
+
+ for (p = path_skiproot(path);
+ *(q = path_nextslash(p)) != '\0'; p = q + 1) ;
+
+ return (char *)p;
+}
+
+char *addslash(char *path)
+{
+ char *p, *q;
+
+ for (p = path_skiproot(path);
+ *(q = path_nextslash(p)) != '\0'; p = q + 1) ;
+
+ if (q != p) {
+ *q++ = PATHDELIM;
+ *q = '\0';
+ }
+
+ return path;
+}
+
+
+char *path_skiproot(const char *path)
+{
+ if (IsPathDelim(path[0])) path++;
+ return (char *)path;
+}
+
+char *path_nextslash(const char *path)
+{
+ char c;
+
+ for (; (c = *path) != '\0'; path++) {
+ if (IsDBCSLead((unsigned char)c)) {
+ if (*(++path) == '\0') break;
+ continue;
+ }
+ if (IsPathDelim(c)) break;
+ }
+ return (char *)path;
+}
+
+char *delslash(char *path)
+{
+ char *p, *q, *s;
+
+ for (p = s = path_skiproot(path);
+ *(q = path_nextslash(p)) != '\0'; p = q + 1) ;
+
+ if (q == s) {
+ *q++ = '.';
+ *q = '\0';
+ } else if (q == p) {
+ *--q = '\0';
+ }
+
+ return path;
+}
+
+
+void png_my_error(png_structp png_ptr, png_const_charp message)
+{
+ xxprintf("ERROR(libpng): %s - %s\n", message,
+ (char *)png_get_error_ptr(png_ptr));
+ longjmp(png_jmpbuf(png_ptr), 1);
+}
+
+void png_my_warning(png_structp png_ptr, png_const_charp message)
+{
+ xxprintf("WARNING(libpng): %s - %s\n", message,
+ (char *)png_get_error_ptr(png_ptr));
+}
+
+BOOL imgbuf_alloc(IMAGE *img)
+{
+ BYTE *bp, **rp;
+ LONG n;
+
+ if (img->palnum > 0) {
+ img->palette = malloc((size_t)img->palnum * sizeof(PALETTE));
+ if (img->palette == NULL) { imgbuf_init(img); return FALSE; }
+ } else {
+ img->palette = NULL;
+ }
+ img->rowbytes = ((DWORD)img->width * img->pixdepth + 31) / 32 * 4;
+ img->imgbytes = img->rowbytes * img->height;
+ img->rowptr = malloc((size_t)img->height * sizeof(BYTE *));
+ img->bmpbits = malloc((size_t)img->imgbytes);
+
+ if (img->rowptr == NULL || img->bmpbits == NULL) {
+ imgbuf_free(img); imgbuf_init(img); return FALSE;
+ }
+
+ n = img->height;
+ rp = img->rowptr;
+ bp = img->bmpbits;
+
+ if (img->topdown) {
+ while (--n >= 0) {
+ *(rp++) = bp;
+ bp += img->rowbytes;
+
+ }
+ } else { /* bottom-up */
+ bp += img->imgbytes;
+ while (--n >= 0) {
+
+ ((DWORD *)bp)[-1] = 0;
+ bp -= img->rowbytes;
+ *(rp++) = bp;
+ }
+ }
+
+ return TRUE;
+}
+
+void imgbuf_free(IMAGE *img)
+{
+ free(img->palette);
+ free(img->rowptr);
+ free(img->bmpbits);
+}
+
+void imgbuf_init(IMAGE *img)
+{
+ img->palette = NULL;
+ img->rowptr = NULL;
+ img->bmpbits = NULL;
+}
+
+int parsearg(int *opt, char **arg, int argc, char **argv, char *aopts)
+{
+ static int agi = 1;
+ static char *agp = NULL;
+ char *p;
+ int c, i;
+
+ if (agp != NULL && *agp == '\0') {
+ agp = NULL;
+ agi++;
+ }
+ if (agi >= argc)
+ return 0;
+
+ if (p = argv[agi], agp == NULL && !isoption(p)) {
+
+ c = 0;
+ agi++;
+ } else {
+ if (agp == NULL) agp = p + 1;
+ if (c = (*agp & 0xFF), strchr(aopts, c) != NULL) {
+
+ if (p = agp + 1, *p != '\0') {
+ /*NULL*/;
+ } else if (i = agi + 1, p = argv[i], i < argc && !isoption(p)) {
+ agi = i;
+ } else {
+ p = NULL;
+ }
+ agp = NULL;
+ agi++;
+ } else {
+
+ p = NULL;
+ agp++;
+ }
+ }
+ *opt = c;
+ *arg = p;
+
+ return 1;
+}
+
+char **envargv(int *argcp, char ***argvp, const char *envn)
+{
+ int argc, nagc, envc, i;
+ char **argv, **nagv, *envs, *ep;
+
+ ep = getenv(envn);
+ if (ep == NULL || ep[0] == '\0') return NULL;
+
+ envs = malloc(strlen(ep) + 1);
+ if (envs == NULL) return NULL;
+ strcpy(envs, ep);
+
+ envc = tokenize(envs, envs);
+ if (envc == 0) { free(envs); return NULL; }
+
+ argc = *argcp;
+ argv = *argvp;
+ nagv = malloc((argc + envc + 1) * sizeof(char *));
+ if (nagv == NULL) { free(envs); return NULL; }
+
+ nagc = 1;
+ nagv[0] = argv[0];
+
+ for (i = 0; i < envc; i++) {
+ nagv[nagc++] = envs;
+ while (*(envs++) != '\0') ;
+ }
+ for (i = 1; i < argc; i++) {
+ nagv[nagc++] = argv[i];
+ }
+ nagv[nagc] = NULL;
+
+ *argcp = nagc;
+ *argvp = nagv;
+
+ return argv;
+}
+
+int tokenize(char *buf, const char *str)
+{
+ enum { STR = 0x01, QUOTE = 0x02 };
+ int flag = 0;
+ int num = 0;
+ char c;
+ int i;
+
+ while ((c = *str++) != '\0') {
+ if (!(flag & QUOTE) &&
+ (c == ' ' || c == '\t' || c == '\n' || c == '\r')) {
+ if (flag & STR) {
+ flag &= ~STR;
+ *buf++ = '\0';
+ }
+ } else {
+ if (!(flag & STR)) {
+ flag |= STR;
+ num++;
+ }
+ switch (c) {
+ case '\\':
+
+ for (i = 1; (c = *str) == '\\'; str++, i++) ;
+ if (c == '"') {
+ while ((i -= 2) >= 0)
+ *buf++ = '\\';
+ if (i == -1) {
+ *buf++ = '"';
+ str++;
+ }
+ } else {
+ while ((--i) >= 0)
+ *buf++ = '\\';
+ }
+ break;
+
+ case '"':
+ flag ^= QUOTE;
+ break;
+
+ default:
+ *buf++ = c;
+ }
+ }
+ }
+ if (flag & STR) *buf = '\0';
+
+ return num;
+}
+
+int makedir(const char *path)
+{
+ char dir[FILENAME_MAX];
+ struct stat sbuf;
+ char *p, c;
+ int r;
+
+ delslash(strcpy(dir, path));
+ if (stat(dir, &sbuf) == 0) {
+ if ((sbuf.st_mode & S_IFMT) == S_IFDIR) return 0;
+
+ return -1;
+ }
+ p = path_skiproot(dir);
+ do {
+ p = path_nextslash(p);
+ c = *p; *p = '\0';
+ r = MKDIR(dir, 0777);
+ *p++ = c;
+ } while (c != '\0');
+
+ return r;
+}
+
+int renbak(const char *path)
+{
+ char bak[FILENAME_MAX];
+ struct stat sbuf;
+ char *sfx;
+ int i;
+
+ strcpy(bak, path);
+ if (stat(bak, &sbuf) != 0) return 0;
+
+ sfx = bak + strlen(bak);
+
+ strcpy(sfx, ".bak");
+ i = 0;
+ while (1) {
+ if (stat(bak, &sbuf) != 0 && rename(path, bak) == 0) return 0;
+ if (i >= 1000) break;
+ sprintf(sfx, ".%03d", i++);
+ }
+ return -1;
+}
+
+int cpyftime(const char *srcf, const char *dstf)
+{
+ struct stat sbuf;
+ struct utimbuf ubuf;
+
+ if (stat(srcf, &sbuf) != 0) return -1;
+
+ ubuf.actime = sbuf.st_atime;
+ ubuf.modtime = sbuf.st_mtime;
+
+ return utime(dstf, &ubuf);
+}
+
+