#ifndef LW_HTTP_THREAD_POOL_COUNT # if (defined(_WIN32) && !defined(_WIN64)) || \ (defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 4) # define LW_HTTP_THREAD_POOL_COUNT 2 # else # define LW_HTTP_THREAD_POOL_COUNT 8 # endif #endif #define CPPHTTPLIB_THREAD_POOL_COUNT LW_HTTP_THREAD_POOL_COUNT #include "httplib.h" #include "lw_infer.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(_WIN32) # include #elif defined(__APPLE__) # include # include #else # include #endif namespace { const uint64_t kMaxImagePixels = UINT64_C(40000000); const size_t kMaxWebPageBytes = 4u * 1024u * 1024u; bool AllocationFits(uint64_t count, size_t element_size) { return element_size != 0u && count <= static_cast(SIZE_MAX / element_size); } uint32_t DefaultOcrWorkers() { lw_ocr_options options; lw_ocr_options_init(&options); return options.worker_count; } struct Config { std::string host; int port; std::string models; std::string web_root; bool use_classifier; uint32_t ocr_workers; uint32_t rec_max_width; Config() : host("127.0.0.1"), port(8787), use_classifier(true), ocr_workers(DefaultOcrWorkers()), rec_max_width(960u) {} }; struct BgrImage { uint32_t width; uint32_t height; std::vector pixels; BgrImage() : width(0u), height(0u) {} }; struct OcrOutput { uint32_t detected_count; std::vector lines; std::string text; OcrOutput() : detected_count(0u) {} }; class ApiError : public std::runtime_error { public: ApiError(int status, const std::string& code, const std::string& message) : std::runtime_error(message), status_(status), code_(code) {} int status() const { return status_; } const std::string& code() const { return code_; } private: int status_; std::string code_; }; std::mutex g_log_mutex; std::atomic g_request_sequence(0u); void Log(const std::string& message) { std::lock_guard guard(g_log_mutex); std::cout << message << std::endl; } std::string JsonEscape(const std::string& value) { std::ostringstream output; for (size_t index = 0u; index < value.size(); ++index) { const unsigned char character = static_cast(value[index]); switch (character) { case '\"': output << "\\\""; break; case '\\': output << "\\\\"; break; case '\b': output << "\\b"; break; case '\f': output << "\\f"; break; case '\n': output << "\\n"; break; case '\r': output << "\\r"; break; case '\t': output << "\\t"; break; default: if (character < 0x20u) { output << "\\u" << std::hex << std::setw(4) << std::setfill('0') << static_cast(character) << std::dec << std::setfill(' '); } else { output << static_cast(character); } break; } } return output.str(); } std::string MakeRequestId() { const uint64_t ticks = static_cast( std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()).count()); const uint64_t sequence = ++g_request_sequence; std::ostringstream output; output << std::hex << ticks << '-' << sequence; return output.str(); } std::string ParentPath(const std::string& path) { const size_t slash = path.find_last_of("/\\"); if (slash == std::string::npos) return "."; if (slash == 0u) return path.substr(0u, 1u); return path.substr(0u, slash); } std::string JoinPath(const std::string& parent, const std::string& child) { if (parent.empty()) return child; if (parent == ".") return "./" + child; const char last = parent[parent.size() - 1u]; return parent + ((last == '/' || last == '\\') ? "" : "/") + child; } // Choose by presence, not by a failed import: a damaged ONNX must report its // error instead of silently falling back to a different model. std::string ModelPath(const std::string& directory, const std::string& name) { const std::string onnx = JoinPath(directory, name + ".onnx"); #if defined(_WIN32) const int count = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, onnx.c_str(), -1, NULL, 0); if (count > 0) { std::vector wide(static_cast(count)); if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, onnx.c_str(), -1, wide.data(), count) > 0) { const DWORD attributes = GetFileAttributesW(wide.data()); if (attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0u) return onnx; } } #else std::ifstream file(onnx.c_str(), std::ios::binary); if (file.good()) return onnx; #endif return JoinPath(directory, name + ".lwm"); } #if defined(_WIN32) std::string WideToUtf8(const wchar_t* value) { if (value == NULL || *value == L'\0') return std::string(); const int count = WideCharToMultiByte( CP_UTF8, WC_ERR_INVALID_CHARS, value, -1, NULL, 0, NULL, NULL); if (count <= 0) throw std::runtime_error("UTF-16 to UTF-8 conversion failed"); std::vector bytes(static_cast(count)); if (WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, value, -1, &bytes[0], count, NULL, NULL) <= 0) { throw std::runtime_error("UTF-16 to UTF-8 conversion failed"); } return std::string(&bytes[0]); } std::wstring Utf8ToWide(const std::string& value) { if (value.empty()) return std::wstring(); const int count = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, value.c_str(), -1, NULL, 0); if (count <= 0) throw std::runtime_error("UTF-8 path conversion failed"); std::vector characters(static_cast(count)); if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, value.c_str(), -1, &characters[0], count) <= 0) { throw std::runtime_error("UTF-8 path conversion failed"); } return std::wstring(&characters[0]); } #endif std::string ExecutableDirectory(const char* argv0) { #if defined(_WIN32) std::vector path(32768u); const DWORD count = GetModuleFileNameW( NULL, &path[0], static_cast(path.size())); if (count != 0u && count < path.size()) { path[count] = L'\0'; return ParentPath(WideToUtf8(&path[0])); } #elif defined(__APPLE__) uint32_t size = 0u; (void)_NSGetExecutablePath(NULL, &size); if (size != 0u) { std::vector path(size + 1u, '\0'); if (_NSGetExecutablePath(&path[0], &size) == 0) { return ParentPath(&path[0]); } } #else std::vector path(4096u, '\0'); const ssize_t count = readlink("/proc/self/exe", &path[0], path.size() - 1u); if (count > 0) { path[static_cast(count)] = '\0'; return ParentPath(&path[0]); } #endif return ParentPath(argv0 == NULL ? "." : argv0); } std::string ReadFileUtf8(const std::string& path, size_t maximum_size) { FILE* file = NULL; #if defined(_WIN32) const std::wstring wide = Utf8ToWide(path); if (_wfopen_s(&file, wide.c_str(), L"rb") != 0) file = NULL; #else file = std::fopen(path.c_str(), "rb"); #endif if (file == NULL) throw std::runtime_error("unable to open file: " + path); std::vector data; char buffer[8192]; for (;;) { const size_t count = std::fread(buffer, 1u, sizeof(buffer), file); if (count != 0u) { if (data.size() > maximum_size - count) { std::fclose(file); throw std::runtime_error("file is too large: " + path); } data.insert(data.end(), buffer, buffer + count); } if (count < sizeof(buffer)) { if (std::ferror(file) != 0) { std::fclose(file); throw std::runtime_error("unable to read file: " + path); } break; } } std::fclose(file); return std::string(data.begin(), data.end()); } bool IsSpace(unsigned char value) { return value == ' ' || value == '\t' || value == '\r' || value == '\n' || value == '\f' || value == '\v'; } std::string ReadPpmToken(const std::string& bytes, size_t* offset) { if (offset == NULL) throw ApiError(400, "bad_request", "invalid PPM parser state"); for (;;) { while (*offset < bytes.size() && IsSpace(static_cast(bytes[*offset]))) ++(*offset); if (*offset >= bytes.size() || bytes[*offset] != '#') break; while (*offset < bytes.size() && bytes[*offset] != '\n') ++(*offset); } const size_t begin = *offset; while (*offset < bytes.size() && !IsSpace(static_cast(bytes[*offset]))) ++(*offset); if (*offset == begin || *offset >= bytes.size()) { throw ApiError(400, "bad_request", "invalid P6 PPM header"); } const std::string token = bytes.substr(begin, *offset - begin); const unsigned char delimiter = static_cast(bytes[*offset]); ++(*offset); if (delimiter == '\r' && *offset < bytes.size() && bytes[*offset] == '\n') { ++(*offset); } return token; } uint32_t ParsePositiveU32(const std::string& value, const char* field) { if (value.empty()) throw ApiError(400, "bad_request", std::string("invalid ") + field); uint64_t parsed = 0u; for (size_t index = 0u; index < value.size(); ++index) { const unsigned char character = static_cast(value[index]); if (character < '0' || character > '9') { throw ApiError(400, "bad_request", std::string("invalid ") + field); } const uint64_t digit = static_cast(character - '0'); if (parsed > (UINT32_MAX - digit) / 10u) { throw ApiError(400, "bad_request", std::string("invalid ") + field); } parsed = parsed * 10u + digit; } if (parsed == 0u) throw ApiError(400, "bad_request", std::string("invalid ") + field); return static_cast(parsed); } BgrImage DecodeP6Ppm(const std::string& bytes) { size_t offset = 0u; if (ReadPpmToken(bytes, &offset) != "P6") { throw ApiError(415, "unsupported_media_type", "server accepts binary P6 PPM; the browser Demo converts JPEG/PNG before upload"); } BgrImage image; image.width = ParsePositiveU32(ReadPpmToken(bytes, &offset), "PPM width"); image.height = ParsePositiveU32(ReadPpmToken(bytes, &offset), "PPM height"); if (ParsePositiveU32(ReadPpmToken(bytes, &offset), "PPM max value") != 255u) { throw ApiError(400, "bad_request", "P6 PPM max value must be 255"); } const uint64_t pixels = static_cast(image.width) * image.height; if (pixels > kMaxImagePixels || pixels > SIZE_MAX / 3u) { throw ApiError(413, "image_too_large", "decoded image exceeds 40,000,000 pixels"); } const size_t byte_count = static_cast(pixels * 3u); if (offset > bytes.size() || bytes.size() - offset != byte_count) { throw ApiError(400, "bad_request", "P6 PPM pixel payload length is invalid"); } image.pixels.resize(byte_count); for (size_t index = 0u; index < byte_count; index += 3u) { image.pixels[index] = static_cast(bytes[offset + index + 2u]); image.pixels[index + 1u] = static_cast(bytes[offset + index + 1u]); image.pixels[index + 2u] = static_cast(bytes[offset + index]); } return image; } uint16_t ReadLe16(const std::string& bytes, size_t offset, const char* field) { if (offset > bytes.size() || bytes.size() - offset < 2u) { throw ApiError(400, "bad_request", std::string("invalid BMP ") + field); } return static_cast( static_cast(bytes[offset]) | (static_cast(static_cast(bytes[offset + 1u])) << 8u)); } uint32_t ReadLe32(const std::string& bytes, size_t offset, const char* field) { if (offset > bytes.size() || bytes.size() - offset < 4u) { throw ApiError(400, "bad_request", std::string("invalid BMP ") + field); } return static_cast(static_cast(bytes[offset])) | (static_cast(static_cast(bytes[offset + 1u])) << 8u) | (static_cast(static_cast(bytes[offset + 2u])) << 16u) | (static_cast(static_cast(bytes[offset + 3u])) << 24u); } BgrImage DecodeBmp24(const std::string& bytes) { if (bytes.size() < 54u || bytes[0] != 'B' || bytes[1] != 'M') { throw ApiError(400, "bad_request", "invalid BMP header"); } const uint32_t pixel_offset = ReadLe32(bytes, 10u, "pixel offset"); const uint32_t dib_size = ReadLe32(bytes, 14u, "DIB header"); const uint32_t raw_width = ReadLe32(bytes, 18u, "width"); const uint32_t raw_height = ReadLe32(bytes, 22u, "height"); const int64_t signed_width = raw_width <= INT32_MAX ? static_cast(raw_width) : static_cast(raw_width) - INT64_C(4294967296); const int64_t signed_height = raw_height <= INT32_MAX ? static_cast(raw_height) : static_cast(raw_height) - INT64_C(4294967296); const uint16_t planes = ReadLe16(bytes, 26u, "planes"); const uint16_t bits_per_pixel = ReadLe16(bytes, 28u, "bit depth"); const uint32_t compression = ReadLe32(bytes, 30u, "compression"); if (dib_size < 40u || dib_size > bytes.size() - 14u || pixel_offset < 14u + static_cast(dib_size) || planes != 1u || bits_per_pixel != 24u || compression != 0u || signed_width <= 0 || signed_height == 0) { throw ApiError(415, "unsupported_media_type", "server accepts uncompressed 24-bit BMP images"); } BgrImage image; image.width = static_cast(signed_width); image.height = static_cast( signed_height < 0 ? -signed_height : signed_height); const uint64_t pixels = static_cast(image.width) * image.height; if (pixels > kMaxImagePixels || !AllocationFits(pixels, 3u)) { throw ApiError(413, "image_too_large", "decoded image exceeds 40,000,000 pixels"); } const uint64_t row_bytes = (static_cast(image.width) * 3u + 3u) & ~UINT64_C(3); const uint64_t payload_bytes = row_bytes * image.height; if (pixel_offset > bytes.size() || payload_bytes > bytes.size() - pixel_offset) { throw ApiError(400, "bad_request", "BMP pixel payload length is invalid"); } image.pixels.resize(static_cast(pixels * 3u)); for (uint32_t y = 0u; y < image.height; ++y) { const uint32_t source_y = signed_height < 0 ? y : image.height - 1u - y; const size_t source_offset = static_cast(pixel_offset + row_bytes * source_y); const size_t destination_offset = static_cast(image.width) * y * 3u; std::memcpy(&image.pixels[destination_offset], bytes.data() + source_offset, static_cast(image.width) * 3u); } return image; } int Base64Value(unsigned char character) { if (character >= 'A' && character <= 'Z') return character - 'A'; if (character >= 'a' && character <= 'z') return character - 'a' + 26; if (character >= '0' && character <= '9') return character - '0' + 52; if (character == '+') return 62; if (character == '/') return 63; return -1; } std::string DecodeBase64(std::string value) { const size_t comma = value.find(','); if (value.compare(0u, 5u, "data:") == 0 && comma != std::string::npos) { value.erase(0u, comma + 1u); } value.erase(std::remove_if(value.begin(), value.end(), [](char character) { return IsSpace(static_cast(character)); }), value.end()); if (value.empty() || value.size() % 4u != 0u) { throw ApiError(400, "bad_request", "imageBase64 is invalid"); } std::string decoded; decoded.reserve(value.size() / 4u * 3u); for (size_t index = 0u; index < value.size(); index += 4u) { const bool final_group = index + 4u == value.size(); const int a = Base64Value(static_cast(value[index])); const int b = Base64Value(static_cast(value[index + 1u])); const int c = value[index + 2u] == '=' ? -2 : Base64Value(static_cast(value[index + 2u])); const int d = value[index + 3u] == '=' ? -2 : Base64Value(static_cast(value[index + 3u])); if (a < 0 || b < 0 || c == -1 || d == -1 || (!final_group && (c == -2 || d == -2)) || (c == -2 && d != -2)) { throw ApiError(400, "bad_request", "imageBase64 is invalid"); } const uint32_t packed = (static_cast(a) << 18u) | (static_cast(b) << 12u) | (static_cast(c < 0 ? 0 : c) << 6u) | static_cast(d < 0 ? 0 : d); decoded.push_back(static_cast((packed >> 16u) & 0xffu)); if (c >= 0) decoded.push_back(static_cast((packed >> 8u) & 0xffu)); if (d >= 0) decoded.push_back(static_cast(packed & 0xffu)); } return decoded; } std::string ExtractJsonString(const std::string& json, const std::string& key) { const std::string marker = "\"" + key + "\""; size_t offset = json.find(marker); if (offset == std::string::npos) return std::string(); offset += marker.size(); while (offset < json.size() && IsSpace(static_cast(json[offset]))) ++offset; if (offset >= json.size() || json[offset++] != ':') return std::string(); while (offset < json.size() && IsSpace(static_cast(json[offset]))) ++offset; if (offset >= json.size() || json[offset++] != '\"') return std::string(); std::string value; while (offset < json.size()) { const char character = json[offset++]; if (character == '\"') return value; if (character == '\\') { if (offset >= json.size()) break; const char escaped = json[offset++]; if (escaped == '/' || escaped == '\\' || escaped == '\"') { value.push_back(escaped); } else { throw ApiError(400, "bad_request", "imageBase64 contains an invalid JSON escape"); } } else { value.push_back(character); } } throw ApiError(400, "bad_request", "JSON string is incomplete"); } std::string LowerMediaType(const std::string& value) { const size_t semicolon = value.find(';'); std::string type = value.substr(0u, semicolon); std::transform(type.begin(), type.end(), type.begin(), [](char character) { const unsigned char byte = static_cast(character); return static_cast(byte >= 'A' && byte <= 'Z' ? byte + 32u : byte); }); while (!type.empty() && IsSpace(static_cast(type.front()))) type.erase(type.begin()); while (!type.empty() && IsSpace(static_cast(type.back()))) type.pop_back(); return type; } BgrImage ReadRequestImage(const httplib::Request& request) { const std::string content_type = LowerMediaType( request.get_header_value("Content-Type")); if (content_type == "application/json") { std::string encoded = ExtractJsonString(request.body, "imageBase64"); if (encoded.empty()) encoded = ExtractJsonString(request.body, "image_base64"); if (encoded.empty()) { throw ApiError(400, "bad_request", "JSON must contain imageBase64"); } return DecodeP6Ppm(DecodeBase64(encoded)); } if (content_type == "image/x-portable-pixmap" || content_type == "image/x-portable-anymap" || content_type == "application/octet-stream") { return DecodeP6Ppm(request.body); } if (content_type == "image/bmp" || content_type == "image/x-ms-bmp") { return DecodeBmp24(request.body); } throw ApiError(415, "unsupported_media_type", "use image/x-portable-pixmap, image/bmp, application/octet-stream, " "or JSON/Base64 P6 PPM"); } class OcrEngine { public: OcrEngine(const Config& config) : handle_(NULL) { lw_ocr_options options; lw_error error; lw_ocr_options_init(&options); options.use_direction_classification = config.use_classifier ? 1u : 0u; options.worker_count = config.ocr_workers; options.recognizer.target_width = config.rec_max_width; lw_error_init(&error); const std::string detector = ModelPath(config.models, "det"); const std::string classifier = ModelPath(config.models, "cls"); const std::string recognizer = ModelPath(config.models, "rec"); const std::string dictionary = JoinPath(config.models, "ppocr_keys.txt"); const lw_status status = lw_ocr_create( detector.c_str(), config.use_classifier ? classifier.c_str() : NULL, recognizer.c_str(), dictionary.c_str(), &options, &handle_, &error); if (status != LW_STATUS_OK || handle_ == NULL) { throw std::runtime_error(std::string("OCR initialization failed: ") + lw_status_string(status) + ": " + error.message); } lw_ocr_info_init(&info_); if (lw_ocr_get_info(handle_, &info_) != LW_STATUS_OK || info_.max_line_capacity == 0u || info_.max_text_capacity == 0u || !AllocationFits(info_.max_line_capacity, sizeof(lw_ocr_line)) || !AllocationFits(info_.max_text_capacity, sizeof(char))) { lw_ocr_free(handle_); handle_ = NULL; throw std::runtime_error("unable to query OCR output capacities"); } lines_.resize(info_.max_line_capacity); text_.resize(static_cast(info_.max_text_capacity)); } ~OcrEngine() { lw_ocr_free(handle_); } OcrOutput Run(const BgrImage& image) { std::lock_guard guard(mutex_); lw_ocr_result result; lw_error error; lw_ocr_result_init(&result); lw_error_init(&error); const lw_status status = lw_ocr_run_bgr_u8( handle_, image.pixels.empty() ? NULL : &image.pixels[0], static_cast(image.pixels.size()), image.width, image.height, image.width * 3u, &lines_[0], static_cast(lines_.size()), &text_[0], static_cast(text_.size()), &result, &error); if (status != LW_STATUS_OK) { throw ApiError(422, "ocr_failed", std::string(lw_status_string(status)) + ": " + error.message); } if (result.line_count > lines_.size() || result.required_text_capacity > text_.size()) { throw std::runtime_error("native OCR returned invalid output capacities"); } OcrOutput output; output.detected_count = result.detected_count; output.lines.assign(lines_.begin(), lines_.begin() + result.line_count); output.text.assign(text_.begin(), text_.begin() + static_cast(result.required_text_capacity)); return output; } private: OcrEngine(const OcrEngine&); OcrEngine& operator=(const OcrEngine&); lw_ocr* handle_; lw_ocr_info info_; std::vector lines_; std::vector text_; std::mutex mutex_; }; std::string BuildOcrJson(const std::string& request_id, const BgrImage& image, const OcrOutput& output, double elapsed_ms) { std::ostringstream json; json.imbue(std::locale::classic()); json << std::setprecision(9) << "{\"ok\":true,\"api_version\":1," << "\"request_id\":\"" << JsonEscape(request_id) << "\"," << "\"image_width\":" << image.width << ",\"image_height\":" << image.height << ",\"detected_count\":" << output.detected_count << ",\"result\":["; for (size_t index = 0u; index < output.lines.size(); ++index) { const lw_ocr_line& line = output.lines[index]; if (line.text_offset > output.text.size() || line.text_length > output.text.size() - static_cast(line.text_offset)) { throw std::runtime_error("native OCR returned an invalid text range"); } const std::string text = output.text.substr( static_cast(line.text_offset), static_cast(line.text_length)); if (index != 0u) json << ','; json << "{\"text\":\"" << JsonEscape(text) << "\"," << "\"score\":" << line.recognition_score << ',' << "\"det_score\":" << line.box.score << ',' << "\"cls_label\":" << line.classification_label << ',' << "\"cls_score\":" << line.classification_score << ',' << "\"rotation\":" << line.applied_rotation_degrees << ',' << "\"x1\":" << line.box.x1 << ",\"y1\":" << line.box.y1 << ',' << "\"x2\":" << line.box.x2 << ",\"y2\":" << line.box.y2 << ',' << "\"x3\":" << line.box.x3 << ",\"y3\":" << line.box.y3 << ',' << "\"x4\":" << line.box.x4 << ",\"y4\":" << line.box.y4 << '}'; } json << "],\"timing_ms\":{\"server_total\":" << elapsed_ms << "}}"; return json.str(); } void SetCommonHeaders(httplib::Response& response, const std::string& request_id) { response.set_header("Cache-Control", "no-store"); response.set_header("X-Content-Type-Options", "nosniff"); response.set_header("X-API-Version", "1"); response.set_header("X-Request-ID", request_id); } void SetJson(httplib::Response& response, int status, const std::string& body, const std::string& request_id) { response.status = status; SetCommonHeaders(response, request_id); response.set_content(body, "application/json; charset=utf-8"); } void SetError(httplib::Response& response, int status, const std::string& code, const std::string& message, const std::string& request_id) { std::ostringstream json; json << "{\"ok\":false,\"api_version\":1,\"request_id\":\"" << JsonEscape(request_id) << "\",\"error_code\":\"" << JsonEscape(code) << "\",\"error\":\"" << JsonEscape(message) << "\"}"; SetJson(response, status, json.str(), request_id); } int ParsePort(const std::string& value) { const uint32_t parsed = ParsePositiveU32(value, "port"); if (parsed > 65535u) throw std::runtime_error("port must be between 1 and 65535"); return static_cast(parsed); } Config ParseArguments(const std::vector& arguments) { Config config; const std::string executable_directory = ExecutableDirectory( arguments.empty() ? NULL : arguments[0].c_str()); const std::string package_root = ParentPath(executable_directory); config.models = JoinPath(package_root, "models"); config.web_root = JoinPath(package_root, "www"); for (size_t index = 1u; index < arguments.size(); ++index) { const std::string& argument = arguments[index]; if (argument == "--no-cls") { config.use_classifier = false; } else if (argument == "--host" || argument == "--port" || argument == "--models" || argument == "--www" || argument == "--ocr-workers" || argument == "--rec-max-width") { if (index + 1u >= arguments.size()) { throw std::runtime_error("missing value after " + argument); } const std::string value = arguments[++index]; if (argument == "--host") config.host = value; else if (argument == "--port") config.port = ParsePort(value); else if (argument == "--models") config.models = value; else if (argument == "--www") config.web_root = value; else if (argument == "--ocr-workers") { config.ocr_workers = ParsePositiveU32(value, "ocr-workers"); if (config.ocr_workers > 16u) throw std::runtime_error("ocr-workers must be between 1 and 16"); } else { config.rec_max_width = ParsePositiveU32(value, "rec-max-width"); if (config.rec_max_width != 192u && config.rec_max_width != 320u && config.rec_max_width != 480u && config.rec_max_width != 640u && config.rec_max_width != 960u) { throw std::runtime_error( "rec-max-width must be one of 192, 320, 480, 640, or 960"); } } } else if (argument == "--help" || argument == "-h") { std::cout << "Usage: lw.PPOCR.C.HttpServer [--host ADDRESS] [--port PORT] " "[--models DIRECTORY] [--www DIRECTORY] [--ocr-workers COUNT] " "[--rec-max-width WIDTH] [--no-cls]\n"; std::exit(0); } else { throw std::runtime_error("unknown argument: " + argument); } } if (config.host.empty()) throw std::runtime_error("host must not be empty"); return config; } int Run(const std::vector& arguments) { const Config config = ParseArguments(arguments); OcrEngine engine(config); const std::string index_html = ReadFileUtf8( JoinPath(config.web_root, "index.html"), kMaxWebPageBytes); httplib::Server server; server.set_read_timeout(30, 0); server.set_write_timeout(30, 0); server.set_payload_max_length(sizeof(void*) == 4u ? 10u * 1024u * 1024u : 50u * 1024u * 1024u); server.Get("/", [&index_html](const httplib::Request&, httplib::Response& response) { const std::string request_id = MakeRequestId(); SetCommonHeaders(response, request_id); response.set_content(index_html, "text/html; charset=utf-8"); }); server.Get("/index.html", [&index_html](const httplib::Request&, httplib::Response& response) { const std::string request_id = MakeRequestId(); SetCommonHeaders(response, request_id); response.set_content(index_html, "text/html; charset=utf-8"); }); server.Get("/health", [](const httplib::Request&, httplib::Response& response) { const std::string request_id = MakeRequestId(); SetJson(response, 200, "{\"ok\":true,\"api_version\":1,\"request_id\":\"" + JsonEscape(request_id) + "\",\"status\":\"ready\"}", request_id); }); server.Post("/api/ocr", [&engine](const httplib::Request& request, httplib::Response& response) { const std::string request_id = MakeRequestId(); const std::chrono::steady_clock::time_point started = std::chrono::steady_clock::now(); try { const BgrImage image = ReadRequestImage(request); const OcrOutput output = engine.Run(image); const double elapsed_ms = std::chrono::duration( std::chrono::steady_clock::now() - started).count(); SetJson(response, 200, BuildOcrJson(request_id, image, output, elapsed_ms), request_id); std::ostringstream log; log << "request_id=" << request_id << " status=200 duration_ms=" << std::fixed << std::setprecision(1) << elapsed_ms << " lines=" << output.lines.size(); Log(log.str()); } catch (const ApiError& error) { SetError(response, error.status(), error.code(), error.what(), request_id); Log("request_id=" + request_id + " status=" + std::to_string(error.status()) + " error_code=" + error.code()); } catch (const std::exception& error) { SetError(response, 500, "internal_error", "server internal error", request_id); Log("request_id=" + request_id + " status=500 detail=" + error.what()); } }); server.set_error_handler([](const httplib::Request&, httplib::Response& response) { if (response.has_header("X-API-Version")) return; const std::string request_id = MakeRequestId(); const int status = response.status == 413 ? 413 : (response.status == 405 ? 405 : 404); const std::string code = status == 413 ? "payload_too_large" : (status == 405 ? "method_not_allowed" : "not_found"); const std::string message = status == 413 ? "request body is too large" : (status == 405 ? "method is not allowed" : "path does not exist"); SetError(response, status, code, message, request_id); }); server.set_exception_handler([](const httplib::Request&, httplib::Response& response, std::exception_ptr) { const std::string request_id = MakeRequestId(); SetError(response, 500, "internal_error", "server internal error", request_id); }); std::ostringstream startup; startup << "lw.PPOCR.C HTTP OCR Demo\n" << "HTTP: http://" << config.host << ':' << config.port << "/\n" << "models: " << config.models << "\n" << "www: " << config.web_root << "\n" << "OCR line workers: " << config.ocr_workers << "\n" << "REC maximum width: " << config.rec_max_width << "\n" << "HTTP workers: " << LW_HTTP_THREAD_POOL_COUNT; Log(startup.str()); const bool listening = server.listen(config.host.c_str(), config.port); if (!listening) { std::cerr << "unable to listen on " << config.host << ':' << config.port << std::endl; return 2; } return 0; } } // namespace #if defined(_WIN32) int wmain(int argc, wchar_t** argv) { SetConsoleOutputCP(CP_UTF8); try { std::vector arguments; for (int index = 0; index < argc; ++index) { arguments.push_back(WideToUtf8(argv[index])); } return Run(arguments); } catch (const std::exception& error) { std::cerr << "fatal: " << error.what() << std::endl; return 1; } } #else int main(int argc, char** argv) { try { std::vector arguments; for (int index = 0; index < argc; ++index) arguments.push_back(argv[index]); return Run(arguments); } catch (const std::exception& error) { std::cerr << "fatal: " << error.what() << std::endl; return 1; } } #endif