diff --git a/CMakeLists.txt b/CMakeLists.txt index 4a24c374e..1d9281f88 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -495,9 +495,10 @@ find_package(STARSHOOTG) find_package(NNCAM) find_package(MALLINCAM) find_package(OMEGONPROCAM) -if (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND) +find_package(MEADECAM) +if (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND AND MEADECAM_FOUND) add_subdirectory(indi-toupbase) -else (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND) +else (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND AND MEADECAM_FOUND) if (NOT TOUPCAM_FOUND) add_subdirectory(libtoupcam) endif() @@ -525,8 +526,11 @@ endif() if (NOT OMEGONPROCAM_FOUND) add_subdirectory(libomegonprocam) endif() +if (NOT MEADECAM_FOUND) +add_subdirectory(libmeadecam) +endif() SET(LIBRARIES_FOUND FALSE) -endif (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND) +endif (TOUPCAM_FOUND AND ALTAIRCAM_FOUND AND BRESSERCAM_FOUND AND OGMACAM_FOUND AND TSCAM_FOUND AND STARSHOOTG_FOUND AND NNCAM_FOUND AND MALLINCAM_FOUND AND OMEGONPROCAM_FOUND AND MEADECAM_FOUND) endif (WITH_TOUPBASE) ## Bee Focuser @@ -830,6 +834,10 @@ if (WITH_TOUPBASE AND NOT OMEGONPROCAM_FOUND) message(STATUS "libomegonprocam was not found and will now be built. Please install libomegonprocam first before running cmake again to install indi-toupbase.") endif (WITH_TOUPBASE AND NOT OMEGONPROCAM_FOUND) +if (WITH_TOUPBASE AND NOT MEADECAM_FOUND) +message(STATUS "libmeadecam was not found and will now be built. Please install libmeadecam first before running cmake again to install indi-toupbase.") +endif (WITH_TOUPBASE AND NOT MEADECAM_FOUND) + if (WITH_INOVAPLX AND NOT INOVASDK_FOUND) message(STATUS "libinovasdk was not found and will now be built. Please install libinovasdk first before running cmake again to install indi-inovaplx.") endif (WITH_INOVAPLX AND NOT INOVASDK_FOUND) diff --git a/cmake_modules/FindMEADECAM.cmake b/cmake_modules/FindMEADECAM.cmake new file mode 100644 index 000000000..2c13d6c31 --- /dev/null +++ b/cmake_modules/FindMEADECAM.cmake @@ -0,0 +1,50 @@ +# - Try to find Meade Cam Camera Library +# Once done this will define +# +# MEADECAM_FOUND - system has Meade Cam +# MEADECAM_INCLUDE_DIR - the Meade Cam include directory +# MEADECAM_LIBRARIES - Link these to use Meade Cam + +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +if (MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) + + # in cache already + set(MEADECAM_FOUND TRUE) + message(STATUS "Found libmeadecam: ${MEADECAM_LIBRARIES}") + +else (MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) + + find_path(MEADECAM_INCLUDE_DIR meadecam.h + PATH_SUFFIXES libmeadecam + ${_obIncDir} + ${GNUWIN32_DIR}/include + ) + + find_library(MEADECAM_LIBRARIES NAMES meadecam + PATHS + ${_obLinkDir} + ${GNUWIN32_DIR}/lib + ) + + if(MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) + set(MEADECAM_FOUND TRUE) + else (MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) + set(MEADECAM_FOUND FALSE) + endif(MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) + + + if (MEADECAM_FOUND) + if (NOT MEADECAM_FIND_QUIETLY) + message(STATUS "Found MeadeCam: ${MEADECAM_LIBRARIES}") + endif (NOT MEADECAM_FIND_QUIETLY) + else (MEADECAM_FOUND) + if (MEADECAM_FIND_REQUIRED) + message(FATAL_ERROR "MeadeCam not found. Please install MeadeCam Library http://www.indilib.org") + endif (MEADECAM_FIND_REQUIRED) + endif (MEADECAM_FOUND) + + mark_as_advanced(MEADECAM_INCLUDE_DIR MEADECAM_LIBRARIES) + +endif (MEADECAM_INCLUDE_DIR AND MEADECAM_LIBRARIES) diff --git a/debian/libmeadecam/changelog b/debian/libmeadecam/changelog new file mode 100644 index 000000000..6dde7deef --- /dev/null +++ b/debian/libmeadecam/changelog @@ -0,0 +1,5 @@ +libmeadecam (1.54.2) jammy; urgency=medium + + * Upstream release + + -- Ben Gilsrud Mon, 09 Oct 2023 15:00:00 +0300 diff --git a/debian/libmeadecam/compat b/debian/libmeadecam/compat new file mode 100644 index 000000000..f599e28b8 --- /dev/null +++ b/debian/libmeadecam/compat @@ -0,0 +1 @@ +10 diff --git a/debian/libmeadecam/control b/debian/libmeadecam/control new file mode 100644 index 000000000..17d51b37b --- /dev/null +++ b/debian/libmeadecam/control @@ -0,0 +1,13 @@ +Source: libmeadecam +Section: libs +Priority: extra +Maintainer: Ben Gilsrud +Build-Depends: debhelper (>= 6), cdbs, cmake +Standards-Version: 3.9.1 + +Package: libmeadecam +Architecture: amd64 armhf arm64 +Depends: ${shlibs:Depends}, ${misc:Depends}, libtoupcam +Description: Library for Meade Touptek Cameras. + + diff --git a/debian/libmeadecam/copyright b/debian/libmeadecam/copyright new file mode 100644 index 000000000..32beb2474 --- /dev/null +++ b/debian/libmeadecam/copyright @@ -0,0 +1,298 @@ +License: + +Creative Commons Legal Code +Attribution 3.0 Unported + +License + +THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE +COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY +COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS +AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED. + +BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE +BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE +CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE +IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS. + +1. Definitions + + a. "Adaptation" means a work based upon the Work, or upon the Work and other + pre-existing works, such as a translation, adaptation, derivative work, + arrangement of music or other alterations of a literary or artistic work, + or phonogram or performance and includes cinematographic adaptations or any + other form in which the Work may be recast, transformed, or adapted + including in any form recognizably derived from the original, except that a + work that constitutes a Collection will not be considered an Adaptation for + the purpose of this License. For the avoidance of doubt, where the Work is + a musical work, performance or phonogram, the synchronization of the Work + in timed-relation with a moving image ("synching") will be considered an + Adaptation for the purpose of this License. + b. "Collection" means a collection of literary or artistic works, such as + encyclopedias and anthologies, or performances, phonograms or broadcasts, + or other works or subject matter other than works listed in Section 1(f) + below, which, by reason of the selection and arrangement of their contents, + constitute intellectual creations, in which the Work is included in its + entirety in unmodified form along with one or more other contributions, + each constituting separate and independent works in themselves, which + together are assembled into a collective whole. A work that constitutes a + Collection will not be considered an Adaptation (as defined above) for the + purposes of this License. + c. "Distribute" means to make available to the public the original and copies + of the Work or Adaptation, as appropriate, through sale or other transfer + of ownership. + d. "Licensor" means the individual, individuals, entity or entities that offer + (s) the Work under the terms of this License. + e. "Original Author" means, in the case of a literary or artistic work, the + individual, individuals, entity or entities who created the Work or if no + individual or entity can be identified, the publisher; and in addition (i) + in the case of a performance the actors, singers, musicians, dancers, and + other persons who act, sing, deliver, declaim, play in, interpret or + otherwise perform literary or artistic works or expressions of folklore; + (ii) in the case of a phonogram the producer being the person or legal + entity who first fixes the sounds of a performance or other sounds; and, + (iii) in the case of broadcasts, the organization that transmits the + broadcast. + f. "Work" means the literary and/or artistic work offered under the terms of + this License including without limitation any production in the literary, + scientific and artistic domain, whatever may be the mode or form of its + expression including digital form, such as a book, pamphlet and other + writing; a lecture, address, sermon or other work of the same nature; a + dramatic or dramatico-musical work; a choreographic work or entertainment + in dumb show; a musical composition with or without words; a + cinematographic work to which are assimilated works expressed by a process + analogous to cinematography; a work of drawing, painting, architecture, + sculpture, engraving or lithography; a photographic work to which are + assimilated works expressed by a process analogous to photography; a work + of applied art; an illustration, map, plan, sketch or three-dimensional + work relative to geography, topography, architecture or science; a + performance; a broadcast; a phonogram; a compilation of data to the extent + it is protected as a copyrightable work; or a work performed by a variety + or circus performer to the extent it is not otherwise considered a literary + or artistic work. + g. "You" means an individual or entity exercising rights under this License + who has not previously violated the terms of this License with respect to + the Work, or who has received express permission from the Licensor to + exercise rights under this License despite a previous violation. + h. "Publicly Perform" means to perform public recitations of the Work and to + communicate to the public those public recitations, by any means or + process, including by wire or wireless means or public digital + performances; to make available to the public Works in such a way that + members of the public may access these Works from a place and at a place + individually chosen by them; to perform the Work to the public by any means + or process and the communication to the public of the performances of the + Work, including by public digital performance; to broadcast and rebroadcast + the Work by any means including signs, sounds or images. + i. "Reproduce" means to make copies of the Work by any means including without + limitation by sound or visual recordings and the right of fixation and + reproducing fixations of the Work, including storage of a protected + performance or phonogram in digital form or other electronic medium. + +2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, +or restrict any uses free from copyright or rights arising from limitations or +exceptions that are provided for in connection with the copyright protection +under copyright law or other applicable laws. + +3. License Grant. Subject to the terms and conditions of this License, Licensor +hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the +duration of the applicable copyright) license to exercise the rights in the +Work as stated below: + + a. to Reproduce the Work, to incorporate the Work into one or more + Collections, and to Reproduce the Work as incorporated in the Collections; + b. to create and Reproduce Adaptations provided that any such Adaptation, + including any translation in any medium, takes reasonable steps to clearly + label, demarcate or otherwise identify that changes were made to the + original Work. For example, a translation could be marked "The original + work was translated from English to Spanish," or a modification could + indicate "The original work has been modified."; + c. to Distribute and Publicly Perform the Work including as incorporated in + Collections; and, + d. to Distribute and Publicly Perform Adaptations. + e. For the avoidance of doubt: + + i. Non-waivable Compulsory License Schemes. In those jurisdictions in + which the right to collect royalties through any statutory or + compulsory licensing scheme cannot be waived, the Licensor reserves the + exclusive right to collect such royalties for any exercise by You of + the rights granted under this License; + ii. Waivable Compulsory License Schemes. In those jurisdictions in which + the right to collect royalties through any statutory or compulsory + licensing scheme can be waived, the Licensor waives the exclusive right + to collect such royalties for any exercise by You of the rights granted + under this License; and, + iii. Voluntary License Schemes. The Licensor waives the right to collect + royalties, whether individually or, in the event that the Licensor is a + member of a collecting society that administers voluntary licensing + schemes, via that society, from any exercise by You of the rights + granted under this License. + +The above rights may be exercised in all media and formats whether now known or +hereafter devised. The above rights include the right to make such +modifications as are technically necessary to exercise the rights in other +media and formats. Subject to Section 8(f), all rights not expressly granted by +Licensor are hereby reserved. + +4. Restrictions. The license granted in Section 3 above is expressly made +subject to and limited by the following restrictions: + + a. You may Distribute or Publicly Perform the Work only under the terms of + this License. You must include a copy of, or the Uniform Resource + Identifier (URI) for, this License with every copy of the Work You + Distribute or Publicly Perform. You may not offer or impose any terms on + the Work that restrict the terms of this License or the ability of the + recipient of the Work to exercise the rights granted to that recipient + under the terms of the License. You may not sublicense the Work. You must + keep intact all notices that refer to this License and to the disclaimer of + warranties with every copy of the Work You Distribute or Publicly Perform. + When You Distribute or Publicly Perform the Work, You may not impose any + effective technological measures on the Work that restrict the ability of a + recipient of the Work from You to exercise the rights granted to that + recipient under the terms of the License. This Section 4(a) applies to the + Work as incorporated in a Collection, but this does not require the + Collection apart from the Work itself to be made subject to the terms of + this License. If You create a Collection, upon notice from any Licensor You + must, to the extent practicable, remove from the Collection any credit as + required by Section 4(b), as requested. If You create an Adaptation, upon + notice from any Licensor You must, to the extent practicable, remove from + the Adaptation any credit as required by Section 4(b), as requested. + b. If You Distribute, or Publicly Perform the Work or any Adaptations or + Collections, You must, unless a request has been made pursuant to Section 4 + (a), keep intact all copyright notices for the Work and provide, reasonable + to the medium or means You are utilizing: (i) the name of the Original + Author (or pseudonym, if applicable) if supplied, and/or if the Original + Author and/or Licensor designate another party or parties (e.g., a sponsor + institute, publishing entity, journal) for attribution ("Attribution + Parties") in Licensor's copyright notice, terms of service or by other + reasonable means, the name of such party or parties; (ii) the title of the + Work if supplied; (iii) to the extent reasonably practicable, the URI, if + any, that Licensor specifies to be associated with the Work, unless such + URI does not refer to the copyright notice or licensing information for the + Work; and (iv) , consistent with Section 3(b), in the case of an + Adaptation, a credit identifying the use of the Work in the Adaptation + (e.g., "French translation of the Work by Original Author," or "Screenplay + based on original Work by Original Author"). The credit required by this + Section 4 (b) may be implemented in any reasonable manner; provided, + however, that in the case of a Adaptation or Collection, at a minimum such + credit will appear, if a credit for all contributing authors of the + Adaptation or Collection appears, then as part of these credits and in a + manner at least as prominent as the credits for the other contributing + authors. For the avoidance of doubt, You may only use the credit required + by this Section for the purpose of attribution in the manner set out above + and, by exercising Your rights under this License, You may not implicitly + or explicitly assert or imply any connection with, sponsorship or + endorsement by the Original Author, Licensor and/or Attribution Parties, as + appropriate, of You or Your use of the Work, without the separate, express + prior written permission of the Original Author, Licensor and/or + Attribution Parties. + c. Except as otherwise agreed in writing by the Licensor or as may be + otherwise permitted by applicable law, if You Reproduce, Distribute or + Publicly Perform the Work either by itself or as part of any Adaptations or + Collections, You must not distort, mutilate, modify or take other + derogatory action in relation to the Work which would be prejudicial to the + Original Author's honor or reputation. Licensor agrees that in those + jurisdictions (e.g. Japan), in which any exercise of the right granted in + Section 3(b) of this License (the right to make Adaptations) would be + deemed to be a distortion, mutilation, modification or other derogatory + action prejudicial to the Original Author's honor and reputation, the + Licensor will waive or not assert, as appropriate, this Section, to the + fullest extent permitted by the applicable national law, to enable You to + reasonably exercise Your right under Section 3(b) of this License (right to + make Adaptations) but not otherwise. + +5. Representations, Warranties and Disclaimer + +UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS +THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND +CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, +WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A +PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, +ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. +SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH +EXCLUSION MAY NOT APPLY TO YOU. + +6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN +NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, +INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS +LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + +7. Termination + + a. This License and the rights granted hereunder will terminate automatically + upon any breach by You of the terms of this License. Individuals or + entities who have received Adaptations or Collections from You under this + License, however, will not have their licenses terminated provided such + individuals or entities remain in full compliance with those licenses. + Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License. + b. Subject to the above terms and conditions, the license granted here is + perpetual (for the duration of the applicable copyright in the Work). + Notwithstanding the above, Licensor reserves the right to release the Work + under different license terms or to stop distributing the Work at any time; + provided, however that any such election will not serve to withdraw this + License (or any other license that has been, or is required to be, granted + under the terms of this License), and this License will continue in full + force and effect unless terminated as stated above. + +8. Miscellaneous + + a. Each time You Distribute or Publicly Perform the Work or a Collection, the + Licensor offers to the recipient a license to the Work on the same terms + and conditions as the license granted to You under this License. + b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers + to the recipient a license to the original Work on the same terms and + conditions as the license granted to You under this License. + c. If any provision of this License is invalid or unenforceable under + applicable law, it shall not affect the validity or enforceability of the + remainder of the terms of this License, and without further action by the + parties to this agreement, such provision shall be reformed to the minimum + extent necessary to make such provision valid and enforceable. + d. No term or provision of this License shall be deemed waived and no breach + consented to unless such waiver or consent shall be in writing and signed + by the party to be charged with such waiver or consent. + e. This License constitutes the entire agreement between the parties with + respect to the Work licensed here. There are no understandings, agreements + or representations with respect to the Work not specified here. Licensor + shall not be bound by any additional provisions that may appear in any + communication from You. This License may not be modified without the mutual + written agreement of the Licensor and You. + f. The rights granted under, and the subject matter referenced, in this + License were drafted utilizing the terminology of the Berne Convention for + the Protection of Literary and Artistic Works (as amended on September 28, + 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the + WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright + Convention (as revised on July 24, 1971). These rights and subject matter + take effect in the relevant jurisdiction in which the License terms are + sought to be enforced according to the corresponding provisions of the + implementation of those treaty provisions in the applicable national law. + If the standard suite of rights granted under applicable copyright law + includes additional rights not granted under this License, such additional + rights are deemed to be included in the License; this License is not + intended to restrict the license of any rights under applicable law. + + Creative Commons Notice + + Creative Commons is not a party to this License, and makes no warranty + whatsoever in connection with the Work. Creative Commons will not be liable + to You or any party on any legal theory for any damages whatsoever, + including without limitation any general, special, incidental or + consequential damages arising in connection to this license. + Notwithstanding the foregoing two (2) sentences, if Creative Commons has + expressly identified itself as the Licensor hereunder, it shall have all + rights and obligations of Licensor. + + Except for the limited purpose of indicating to the public that the Work is + licensed under the CCPL, Creative Commons does not authorize the use by + either party of the trademark "Creative Commons" or any related trademark + or logo of Creative Commons without the prior written consent of Creative + Commons. Any permitted use will be in compliance with Creative Commons' + then-current trademark usage guidelines, as may be published on its website + or otherwise made available upon request from time to time. For the + avoidance of doubt, this trademark restriction does not form part of this + License. + + Creative Commons may be contacted at http://creativecommons.org/. + +The Debian packaging is (C) 2007, Jasem Mutlaq and +is licensed under the Creative Commons Attribution License 3.0, see above. + diff --git a/debian/libmeadecam/rules b/debian/libmeadecam/rules new file mode 100755 index 000000000..579bc111c --- /dev/null +++ b/debian/libmeadecam/rules @@ -0,0 +1,7 @@ +#!/usr/bin/make -f + +include /usr/share/cdbs/1/rules/debhelper.mk +include /usr/share/cdbs/1/class/cmake.mk + +DEB_SRCDIR=libmeadecam +DEB_DH_SHLIBDEPS_ARGS=-u--ignore-missing-info diff --git a/debian/libmeadecam/source/format b/debian/libmeadecam/source/format new file mode 100644 index 000000000..163aaf8d8 --- /dev/null +++ b/debian/libmeadecam/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/indi-toupbase/CMakeLists.txt b/indi-toupbase/CMakeLists.txt index 54bfe405c..1879e4d50 100644 --- a/indi-toupbase/CMakeLists.txt +++ b/indi-toupbase/CMakeLists.txt @@ -15,6 +15,7 @@ find_package(TOUPCAM REQUIRED) find_package(ALTAIRCAM REQUIRED) find_package(BRESSERCAM REQUIRED) find_package(MALLINCAM REQUIRED) +find_package(MEADECAM REQUIRED) find_package(NNCAM REQUIRED) find_package(OGMACAM REQUIRED) find_package(OMEGONPROCAM REQUIRED) @@ -36,6 +37,7 @@ include_directories( ${ALTAIRCAM_INCLUDE_DIR}) include_directories( ${STARSHOOTG_INCLUDE_DIR}) include_directories( ${NNCAM_INCLUDE_DIR}) include_directories( ${MALLINCAM_INCLUDE_DIR}) +include_directories( ${MEADECAM_INCLUDE_DIR}) include_directories( ${OMEGONPROCAM_INCLUDE_DIR}) include_directories( ${BRESSERCAM_INCLUDE_DIR}) include_directories( ${OGMACAM_INCLUDE_DIR}) @@ -78,6 +80,14 @@ add_executable(indi_mallincam_wheel ${indi_wheel_SRCS}) target_compile_definitions(indi_mallincam_wheel PRIVATE "-DBUILD_MALLINCAM") target_link_libraries(indi_mallincam_wheel ${INDI_LIBRARIES} ${CFITSIO_LIBRARIES} ${MALLINCAM_LIBRARIES} ${ZLIB_LIBRARY} ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}) +########### indi_meadecam_* ########### +add_executable(indi_meadecam_ccd ${indi_toupbase_SRCS}) +target_compile_definitions(indi_meadecam_ccd PRIVATE "-DBUILD_MEADECAM") +target_link_libraries(indi_meadecam_ccd ${INDI_LIBRARIES} ${CFITSIO_LIBRARIES} ${MEADECAM_LIBRARIES} ${ZLIB_LIBRARY} ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}) +add_executable(indi_meadecam_wheel ${indi_wheel_SRCS}) +target_compile_definitions(indi_meadecam_wheel PRIVATE "-DBUILD_MEADECAM") +target_link_libraries(indi_meadecam_wheel ${INDI_LIBRARIES} ${CFITSIO_LIBRARIES} ${MEADECAM_LIBRARIES} ${ZLIB_LIBRARY} ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}) + ########### indi_nncam_* ########### add_executable(indi_nncam_ccd ${indi_toupbase_SRCS}) target_compile_definitions(indi_nncam_ccd PRIVATE "-DBUILD_NNCAM") @@ -146,6 +156,7 @@ install(TARGETS indi_altair_ccd indi_bressercam_ccd indi_mallincam_ccd + indi_meadecam_ccd indi_nncam_ccd indi_ogmacam_ccd indi_omegonprocam_ccd diff --git a/indi-toupbase/indi-toupbase.spec b/indi-toupbase/indi-toupbase.spec index a0f605dfd..c74677fac 100644 --- a/indi-toupbase/indi-toupbase.spec +++ b/indi-toupbase/indi-toupbase.spec @@ -46,6 +46,7 @@ BuildRequires: libtoupcam BuildRequires: libaltaircam BuildRequires: libbressercam BuildRequires: libmallincam +BuildRequires: libmeadecam BuildRequires: libnncam BuildRequires: libogmacam BuildRequires: libomegonprocam diff --git a/indi-toupbase/indi_toupbase.xml.cmake b/indi-toupbase/indi_toupbase.xml.cmake index 2b8bf76ee..ac2a8a71d 100644 --- a/indi-toupbase/indi_toupbase.xml.cmake +++ b/indi-toupbase/indi_toupbase.xml.cmake @@ -17,6 +17,10 @@ indi_mallincam_ccd @TOUPBASE_VERSION_MAJOR@.@TOUPBASE_VERSION_MINOR@ + + indi_meadecam_ccd + @TOUPBASE_VERSION_MAJOR@.@TOUPBASE_VERSION_MINOR@ + indi_nncam_ccd @TOUPBASE_VERSION_MAJOR@.@TOUPBASE_VERSION_MINOR@ diff --git a/indi-toupbase/libtoupbase.h b/indi-toupbase/libtoupbase.h index b8167eab1..0b28aef93 100644 --- a/indi-toupbase/libtoupbase.h +++ b/indi-toupbase/libtoupbase.h @@ -84,6 +84,13 @@ #define XP(x) Tscam##x #define THAND HTscam #define DNAME "Teleskop" +#elif BUILD_MEADECAM +#include +#define FP(x) Toupcam_##x +#define CP(x) TOUPCAM_##x +#define XP(x) Toupcam##x +#define THAND HToupcam +#define DNAME "Meade" #endif -extern std::string errorCodes(HRESULT rc); \ No newline at end of file +extern std::string errorCodes(HRESULT rc); diff --git a/libmeadecam/99-meadecam.rules b/libmeadecam/99-meadecam.rules new file mode 100644 index 000000000..c237cae1e --- /dev/null +++ b/libmeadecam/99-meadecam.rules @@ -0,0 +1,11 @@ +# Copy this file to /etc/udev/rules.d + +# Once done, unplug and re-plug your device. This is all that is +# necessary to see the new permissions. Udev does not have to be restarted. + +# If you think permissions of 0666 are too loose, then see: +# http://reactivated.net/writing_udev_rules.html for more information on finer +# grained permission setting. + +SUBSYSTEM=="usb", ATTRS{idVendor}=="0547", MODE="0666" +SUBSYSTEM=="usb", ATTRS{idVendor}=="0549", MODE="0666" diff --git a/libmeadecam/CMakeLists.txt b/libmeadecam/CMakeLists.txt new file mode 100644 index 000000000..b75e73fc1 --- /dev/null +++ b/libmeadecam/CMakeLists.txt @@ -0,0 +1,31 @@ +cmake_minimum_required (VERSION 3.0) +project (libmeadecam) + +set (LIBMEADECAM_VERSION "1.0") +set (LIBMEADECAM_SOVERSION "1") + +list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/") +list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake_modules/") +find_package(USB1 REQUIRED) + +include (GNUInstallDirs) +include (InstallImported) +include(CMakeCommon) + + +set(meadecam_LIB_SRCS meadecam.c) +add_library(meadecam SHARED ${meadecam_LIB_SRCS}) +set_target_properties(meadecam PROPERTIES VERSION ${LIBMEADECAM_VERSION} SOVERSION ${LIBMEADECAM_SOVERSION}) +target_link_libraries(meadecam ${USB1_LIBRARIES}) +install(TARGETS meadecam LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) + +if (UNIX AND NOT APPLE) + + # Install udev rules + set (UDEVRULES_INSTALL_DIR "/lib/udev/rules.d" CACHE STRING "Base directory for udev rules") + install (FILES 99-meadecam.rules DESTINATION ${UDEVRULES_INSTALL_DIR}) + +endif () + +# Install header files +install (FILES meadecam.h DESTINATION include/libmeadecam) diff --git a/libmeadecam/COPYING.LGPL b/libmeadecam/COPYING.LGPL new file mode 100644 index 000000000..4362b4915 --- /dev/null +++ b/libmeadecam/COPYING.LGPL @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it 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. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/libmeadecam/README.md b/libmeadecam/README.md new file mode 100644 index 000000000..4c0fbe099 --- /dev/null +++ b/libmeadecam/README.md @@ -0,0 +1,12 @@ +This is the library that supports the Meade-branded Touptek camers + +This library is allows us to use the official Touptek libraries to +support the Meade cameras. This is necessary because Meade does not provide +libraries for their cameras like every other touptak rebadger does. + +The library works by using dynamic linking tricks (dlopen/dlsym) to pass +function calls to the official touptek library. The Toupcam_EnumV2 function +is the only original code that this library implements and it remaps the Meade +cameras to the corresponding Touptek camera. + +This has been verified to work with the Toupcam library 54.23231 on arm64. diff --git a/libmeadecam/gen_func_table b/libmeadecam/gen_func_table new file mode 100755 index 000000000..a16da4a8a --- /dev/null +++ b/libmeadecam/gen_func_table @@ -0,0 +1,21 @@ +#!/bin/bash +# Parse a toupcam header file to get symbol info +# This isn't perfect and the output requires some manual fixes + +while read line; do + if grep -q wchar <<< "$line"; then + continue + fi + args=$(echo $line | cut -d '(' -f2 | cut -d ')' -f1) + OLDIFS=$IFS + IFS=$'\n' + params="" + while read f; do + #echo f is $f + params+="$(echo $f | rev | cut -d' ' -f1 | rev | cut -d'[' -f1), " + done <<< $(echo $args | tr ',' '\n') + IFS=$OLDIFS + params=$(echo $params | sed 's/,$//') + line="$(echo $line | sed 's/^C /C(/' | cut -d';' -f1)" + echo "$line, ($params)) \\" +done <<< $(grep -E "^TOUPCAM_API" $1 | sed 's/^TOUPCAM_API(/C /' | sed 's/) /, /' | sed 's/(/, (/') diff --git a/libmeadecam/libmeadecam.spec b/libmeadecam/libmeadecam.spec new file mode 100644 index 000000000..7f783775e --- /dev/null +++ b/libmeadecam/libmeadecam.spec @@ -0,0 +1,84 @@ +%define __cmake_in_source_build %{_vpath_builddir} +Name: libmeadecam +Version:2.0.2.git +Release: %(date -u +%%Y%%m%%d%%H%%M%%S)%{?dist} +Summary: Instrument Neutral Distributed Interface 3rd party drivers + +License: LGPLv2 +# See COPYRIGHT file for a description of the licenses and files covered + +URL: https://indilib.org +Source0: https://github.com/indilib/indi-3rdparty/archive/master.tar.gz + +%global debug_package %{nil} +%define __find_requires %{nil} + +BuildRequires: cmake +BuildRequires: libfli-devel +BuildRequires: libnova-devel +BuildRequires: qt5-qtbase-devel +BuildRequires: systemd +BuildRequires: gphoto2-devel +BuildRequires: LibRaw-devel +BuildRequires: indi-libs +BuildRequires: indi-devel +BuildRequires: libtiff-devel +BuildRequires: cfitsio-devel +BuildRequires: zlib-devel +BuildRequires: gsl-devel +BuildRequires: libcurl-devel +BuildRequires: libjpeg-turbo-devel +BuildRequires: fftw-devel +BuildRequires: libftdi-devel +BuildRequires: gpsd-devel +BuildRequires: libdc1394-devel +BuildRequires: boost-devel +BuildRequires: boost-regex + +BuildRequires: gmock + +BuildRequires: pkgconfig(fftw3) +BuildRequires: pkgconfig(cfitsio) +BuildRequires: pkgconfig(libcurl) +BuildRequires: pkgconfig(gsl) +BuildRequires: pkgconfig(libjpeg) +BuildRequires: pkgconfig(zlib) + +Provides: libmeadecam.so()(64bit) +Provides: libmeadecam.so + + +%description +INDI is a distributed control protocol designed to operate +astronomical instrumentation. INDI is small, flexible, easy to parse, +and scalable. It supports common DCS functions such as remote control, +data acquisition, monitoring, and a lot more. This is a 3rd party driver. + + +%prep -v +%autosetup -v -p1 -n indi-3rdparty-master + +%build +# This package tries to mix and match PIE and PIC which is wrong and will +# trigger link errors when LTO is enabled. +# Disable LTO +%define _lto_cflags %{nil} + +cd libmeadecam +%cmake . +make VERBOSE=1 %{?_smp_mflags} -j4 + +%install +cd libmeadecam +find %buildroot -type f \( -name '*.so' -o -name '*.so.*' \) -exec chmod 755 {} + +make DESTDIR=%{buildroot} install + +%files +%{_libdir}/* +%{_includedir}/libmeadecam +/lib/udev/rules.d/99-meadecam.rules + + +%changelog +* initial release 2022-05-27 + diff --git a/libmeadecam/meadecam.c b/libmeadecam/meadecam.c new file mode 100644 index 000000000..2e1dc575d --- /dev/null +++ b/libmeadecam/meadecam.c @@ -0,0 +1,1663 @@ +#include +#include +#include +#include +#include +#include "meadecam.h" + +#if defined(__APPLE__) +#define LIBTOUPCAM_NAME "libtoupcam.dylib" +#else +#define LIBTOUPCAM_NAME "libtoupcam.so" +#endif + +void *libtoupcam; + +/* Create a function pointer for a given toupcam function. */ +#define C_PTR(RET, DEC, PARAM, ARG) TOUPCAM_API(RET) (*Meade_ ## DEC) PARAM; + +/* Define a function that calls the corresponding toupcam function */ +#define C_DEF(RET, DEC, PARAM, ARG) TOUPCAM_API(RET) DEC PARAM \ +{ \ + return Meade_ ## DEC ARG; \ +} + +#define MYDLSYM(X, Y) dlsym(X, #Y) +#define C_ASSIGN(RET, DEC, PARAM, ARG) Meade_ ## DEC = MYDLSYM(libtoupcam, DEC ); + +#define TOUPCAM_LIST \ +C(const char*, Toupcam_Version, (), ()) \ +C(HToupcam, Toupcam_Open, (const char* camId), (camId)) \ +C(HToupcam, Toupcam_OpenByIndex, (unsigned index), (index)) \ +C(void, Toupcam_Close, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_StartPullModeWithCallback, (HToupcam h, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent), (h, funEvent, ctxEvent)) \ +C(HRESULT, Toupcam_PullImageV3, (HToupcam h, void* pImageData, int bStill, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo), (h, pImageData, bStill, bits, rowPitch, pInfo)) \ +C(HRESULT, Toupcam_WaitImageV3, (HToupcam h, unsigned nWaitMS, void* pImageData, int bStill, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo), (h, nWaitMS, pImageData, bStill, bits, rowPitch, pInfo)) \ +C(HRESULT, Toupcam_PullImageV2, (HToupcam h, void* pImageData, int bits, ToupcamFrameInfoV2* pInfo), (h, pImageData, bits, pInfo)) \ +C(HRESULT, Toupcam_PullStillImageV2, (HToupcam h, void* pImageData, int bits, ToupcamFrameInfoV2* pInfo), (h, pImageData, bits, pInfo)) \ +C(HRESULT, Toupcam_PullImageWithRowPitchV2, (HToupcam h, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV2* pInfo), (h, pImageData, bits, rowPitch, pInfo)) \ +C(HRESULT, Toupcam_PullStillImageWithRowPitchV2, (HToupcam h, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV2* pInfo), (h, pImageData, bits, rowPitch, pInfo)) \ +C(HRESULT, Toupcam_PullImage, (HToupcam h, void* pImageData, int bits, unsigned* pnWidth, unsigned* pnHeight), (h, pImageData, bits, pnWidth, pnHeight)) \ +C(HRESULT, Toupcam_PullStillImage, (HToupcam h, void* pImageData, int bits, unsigned* pnWidth, unsigned* pnHeight), (h, pImageData, bits, pnWidth, pnHeight)) \ +C(HRESULT, Toupcam_PullImageWithRowPitch, (HToupcam h, void* pImageData, int bits, int rowPitch, unsigned* pnWidth, unsigned* pnHeight), (h, pImageData, bits, rowPitch, pnWidth, pnHeight)) \ +C(HRESULT, Toupcam_PullStillImageWithRowPitch, (HToupcam h, void* pImageData, int bits, int rowPitch, unsigned* pnWidth, unsigned* pnHeight), (h, pImageData, bits, rowPitch, pnWidth, pnHeight)) \ +C(HRESULT, Toupcam_StartPushModeV4, (HToupcam h, PTOUPCAM_DATA_CALLBACK_V4 funData, void* ctxData, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent), (h, funData, ctxData, funEvent, ctxEvent)) \ +C(HRESULT, Toupcam_StartPushModeV3, (HToupcam h, PTOUPCAM_DATA_CALLBACK_V3 funData, void* ctxData, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent), (h, funData, ctxData, funEvent, ctxEvent)) \ +C(HRESULT, Toupcam_Stop, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_Pause, (HToupcam h, int bPause), (h, bPause)) \ +C(HRESULT, Toupcam_Snap, (HToupcam h, unsigned nResolutionIndex), (h, nResolutionIndex)) \ +C(HRESULT, Toupcam_SnapN, (HToupcam h, unsigned nResolutionIndex, unsigned nNumber), (h, nResolutionIndex, nNumber)) \ +C(HRESULT, Toupcam_SnapR, (HToupcam h, unsigned nResolutionIndex, unsigned nNumber), (h, nResolutionIndex, nNumber)) \ +C(HRESULT, Toupcam_Trigger, (HToupcam h, unsigned short nNumber), (h, nNumber)) \ +C(HRESULT, Toupcam_TriggerSync, (HToupcam h, unsigned nTimeout, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo), (h, nTimeout, pImageData, bits, rowPitch, pInfo)) \ +C(HRESULT, Toupcam_put_Size, (HToupcam h, int nWidth, int nHeight), (h, nWidth, nHeight)) \ +C(HRESULT, Toupcam_get_Size, (HToupcam h, int* pWidth, int* pHeight), (h, pWidth, pHeight)) \ +C(HRESULT, Toupcam_put_eSize, (HToupcam h, unsigned nResolutionIndex), (h, nResolutionIndex)) \ +C(HRESULT, Toupcam_get_eSize, (HToupcam h, unsigned* pnResolutionIndex), (h, pnResolutionIndex)) \ +C(HRESULT, Toupcam_get_FinalSize, (HToupcam h, int* pWidth, int* pHeight), (h, pWidth, pHeight)) \ +C(HRESULT, Toupcam_get_ResolutionNumber, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_Resolution, (HToupcam h, unsigned nResolutionIndex, int* pWidth, int* pHeight), (h, nResolutionIndex, pWidth, pHeight)) \ +C(HRESULT, Toupcam_get_ResolutionRatio, (HToupcam h, unsigned nResolutionIndex, int* pNumerator, int* pDenominator), (h, nResolutionIndex, pNumerator, pDenominator)) \ +C(HRESULT, Toupcam_get_Field, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_RawFormat, (HToupcam h, unsigned* pFourCC, unsigned* pBitsPerPixel), (h, pFourCC, pBitsPerPixel)) \ +C(HRESULT, Toupcam_get_AutoExpoEnable, (HToupcam h, int* bAutoExposure), (h, bAutoExposure)) \ +C(HRESULT, Toupcam_put_AutoExpoEnable, (HToupcam h, int bAutoExposure), (h, bAutoExposure)) \ +C(HRESULT, Toupcam_get_AutoExpoTarget, (HToupcam h, unsigned short* Target), (h, Target)) \ +C(HRESULT, Toupcam_put_AutoExpoTarget, (HToupcam h, unsigned short Target), (h, Target)) \ +C(HRESULT, Toupcam_put_AutoExpoRange, (HToupcam h, unsigned maxTime, unsigned minTime, unsigned short maxGain, unsigned short minGain), (h, maxTime, minTime, maxGain, minGain)) \ +C(HRESULT, Toupcam_get_AutoExpoRange, (HToupcam h, unsigned* maxTime, unsigned* minTime, unsigned short* maxGain, unsigned short* minGain), (h, maxTime, minTime, maxGain, minGain)) \ +C(HRESULT, Toupcam_put_MaxAutoExpoTimeAGain, (HToupcam h, unsigned maxTime, unsigned short maxGain), (h, maxTime, maxGain)) \ +C(HRESULT, Toupcam_get_MaxAutoExpoTimeAGain, (HToupcam h, unsigned* maxTime, unsigned short* maxGain), (h, maxTime, maxGain)) \ +C(HRESULT, Toupcam_put_MinAutoExpoTimeAGain, (HToupcam h, unsigned minTime, unsigned short minGain), (h, minTime, minGain)) \ +C(HRESULT, Toupcam_get_MinAutoExpoTimeAGain, (HToupcam h, unsigned* minTime, unsigned short* minGain), (h, minTime, minGain)) \ +C(HRESULT, Toupcam_get_ExpoTime, (HToupcam h, unsigned* Time), (h, Time)) \ +C(HRESULT, Toupcam_put_ExpoTime, (HToupcam h, unsigned Time), (h, Time)) \ +C(HRESULT, Toupcam_get_RealExpoTime, (HToupcam h, unsigned* Time), (h, Time)) \ +C(HRESULT, Toupcam_get_ExpTimeRange, (HToupcam h, unsigned* nMin, unsigned* nMax, unsigned* nDef), (h, nMin, nMax, nDef)) \ +C(HRESULT, Toupcam_get_ExpoAGain, (HToupcam h, unsigned short* Gain), (h, Gain)) \ +C(HRESULT, Toupcam_put_ExpoAGain, (HToupcam h, unsigned short Gain), (h, Gain)) \ +C(HRESULT, Toupcam_get_ExpoAGainRange, (HToupcam h, unsigned short* nMin, unsigned short* nMax, unsigned short* nDef), (h, nMin, nMax, nDef)) \ +C(HRESULT, Toupcam_AwbOnce, (HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT), (h, funTT, ctxTT)) \ +C(HRESULT, Toupcam_AwbInit, (HToupcam h, PITOUPCAM_WHITEBALANCE_CALLBACK funWB, void* ctxWB), (h, funWB, ctxWB)) \ +C(HRESULT, Toupcam_put_TempTint, (HToupcam h, int nTemp, int nTint), (h, nTemp, nTint)) \ +C(HRESULT, Toupcam_get_TempTint, (HToupcam h, int* nTemp, int* nTint), (h, nTemp, nTint)) \ +C(HRESULT, Toupcam_put_WhiteBalanceGain, (HToupcam h, int aGain[3]), (h, aGain)) \ +C(HRESULT, Toupcam_get_WhiteBalanceGain, (HToupcam h, int aGain[3]), (h, aGain)) \ +C(HRESULT, Toupcam_AbbOnce, (HToupcam h, PITOUPCAM_BLACKBALANCE_CALLBACK funBB, void* ctxBB), (h, funBB, ctxBB)) \ +C(HRESULT, Toupcam_put_BlackBalance, (HToupcam h, unsigned short aSub[3]), (h, aSub)) \ +C(HRESULT, Toupcam_get_BlackBalance, (HToupcam h, unsigned short aSub[3]), (h, aSub)) \ +C(HRESULT, Toupcam_FfcOnce, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_FfcExport, (HToupcam h, const char* filepath), (h, filepath)) \ +C(HRESULT, Toupcam_FfcImport, (HToupcam h, const char* filepath), (h, filepath)) \ +C(HRESULT, Toupcam_DfcOnce, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_DfcExport, (HToupcam h, const char* filepath), (h, filepath)) \ +C(HRESULT, Toupcam_DfcImport, (HToupcam h, const char* filepath), (h, filepath)) \ +C(HRESULT, Toupcam_put_Hue, (HToupcam h, int Hue), (h, Hue)) \ +C(HRESULT, Toupcam_get_Hue, (HToupcam h, int* Hue), (h, Hue)) \ +C(HRESULT, Toupcam_put_Saturation, (HToupcam h, int Saturation), (h, Saturation)) \ +C(HRESULT, Toupcam_get_Saturation, (HToupcam h, int* Saturation), (h, Saturation)) \ +C(HRESULT, Toupcam_put_Brightness, (HToupcam h, int Brightness), (h, Brightness)) \ +C(HRESULT, Toupcam_get_Brightness, (HToupcam h, int* Brightness), (h, Brightness)) \ +C(HRESULT, Toupcam_get_Contrast, (HToupcam h, int* Contrast), (h, Contrast)) \ +C(HRESULT, Toupcam_put_Contrast, (HToupcam h, int Contrast), (h, Contrast)) \ +C(HRESULT, Toupcam_get_Gamma, (HToupcam h, int* Gamma), (h, Gamma)) \ +C(HRESULT, Toupcam_put_Gamma, (HToupcam h, int Gamma), (h, Gamma)) \ +C(HRESULT, Toupcam_get_Chrome, (HToupcam h, int* bChrome), (h, bChrome)) \ +C(HRESULT, Toupcam_put_Chrome, (HToupcam h, int bChrome), (h, bChrome)) \ +C(HRESULT, Toupcam_get_VFlip, (HToupcam h, int* bVFlip), (h, bVFlip)) \ +C(HRESULT, Toupcam_put_VFlip, (HToupcam h, int bVFlip), (h, bVFlip)) \ +C(HRESULT, Toupcam_get_HFlip, (HToupcam h, int* bHFlip), (h, bHFlip)) \ +C(HRESULT, Toupcam_put_HFlip, (HToupcam h, int bHFlip), (h, bHFlip)) \ +C(HRESULT, Toupcam_get_Negative, (HToupcam h, int* bNegative), (h, bNegative)) \ +C(HRESULT, Toupcam_put_Negative, (HToupcam h, int bNegative), (h, bNegative)) \ +C(HRESULT, Toupcam_put_Speed, (HToupcam h, unsigned short nSpeed), (h, nSpeed)) \ +C(HRESULT, Toupcam_get_Speed, (HToupcam h, unsigned short* pSpeed), (h, pSpeed)) \ +C(HRESULT, Toupcam_get_MaxSpeed, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_FanMaxSpeed, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_MaxBitDepth, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_put_HZ, (HToupcam h, int nHZ), (h, nHZ)) \ +C(HRESULT, Toupcam_get_HZ, (HToupcam h, int* nHZ), (h, nHZ)) \ +C(HRESULT, Toupcam_put_Mode, (HToupcam h, int bSkip), (h, bSkip)) \ +C(HRESULT, Toupcam_get_Mode, (HToupcam h, int* bSkip), (h, bSkip)) \ +C(HRESULT, Toupcam_put_AWBAuxRect, (HToupcam h, const RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_get_AWBAuxRect, (HToupcam h, RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_put_AEAuxRect, (HToupcam h, const RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_get_AEAuxRect, (HToupcam h, RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_put_ABBAuxRect, (HToupcam h, const RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_get_ABBAuxRect, (HToupcam h, RECT* pAuxRect), (h, pAuxRect)) \ +C(HRESULT, Toupcam_get_MonoMode, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_StillResolutionNumber, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_StillResolution, (HToupcam h, unsigned nResolutionIndex, int* pWidth, int* pHeight), (h, nResolutionIndex, pWidth, pHeight)) \ +C(HRESULT, Toupcam_put_RealTime, (HToupcam h, int val), (h, val)) \ +C(HRESULT, Toupcam_get_RealTime, (HToupcam h, int* val), (h, val)) \ +C(HRESULT, Toupcam_Flush, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_get_Temperature, (HToupcam h, short* pTemperature), (h, pTemperature)) \ +C(HRESULT, Toupcam_put_Temperature, (HToupcam h, short nTemperature), (h, nTemperature)) \ +C(HRESULT, Toupcam_get_Revision, (HToupcam h, unsigned short* pRevision), (h, pRevision)) \ +C(HRESULT, Toupcam_get_SerialNumber, (HToupcam h, char sn[32]), (h, sn)) \ +C(HRESULT, Toupcam_get_FwVersion, (HToupcam h, char fwver[16]), (h, fwver)) \ +C(HRESULT, Toupcam_get_HwVersion, (HToupcam h, char hwver[16]), (h, hwver)) \ +C(HRESULT, Toupcam_get_ProductionDate, (HToupcam h, char pdate[10]), (h, pdate)) \ +C(HRESULT, Toupcam_get_FpgaVersion, (HToupcam h, char fpgaver[16]), (h, fpgaver)) \ +C(HRESULT, Toupcam_get_PixelSize, (HToupcam h, unsigned nResolutionIndex, float* x, float* y), (h, nResolutionIndex, x, y)) \ +C(HRESULT, Toupcam_put_LevelRange, (HToupcam h, unsigned short aLow[4], unsigned short aHigh[4]), (h, aLow, aHigh)) \ +C(HRESULT, Toupcam_get_LevelRange, (HToupcam h, unsigned short aLow[4], unsigned short aHigh[4]), (h, aLow, aHigh)) \ +C(HRESULT, Toupcam_put_LevelRangeV2, (HToupcam h, unsigned short mode, const RECT* pRoiRect, unsigned short aLow[4], unsigned short aHigh[4]), (h, mode, pRoiRect, aLow, aHigh)) \ +C(HRESULT, Toupcam_get_LevelRangeV2, (HToupcam h, unsigned short* pMode, RECT* pRoiRect, unsigned short aLow[4], unsigned short aHigh[4]), (h, pMode, pRoiRect, aLow, aHigh)) \ +C(HRESULT, Toupcam_LevelRangeAuto, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_GetHistogram, (HToupcam h, PITOUPCAM_HISTOGRAM_CALLBACK funHistogram, void* ctxHistogram), (h, funHistogram, ctxHistogram)) \ +C(HRESULT, Toupcam_GetHistogramV2, (HToupcam h, PITOUPCAM_HISTOGRAM_CALLBACKV2 funHistogramV2, void* ctxHistogramV2), (h, funHistogramV2, ctxHistogramV2)) \ +C(HRESULT, Toupcam_put_LEDState, (HToupcam h, unsigned short iLed, unsigned short iState, unsigned short iPeriod), (h, iLed, iState, iPeriod)) \ +C(HRESULT, Toupcam_write_EEPROM, (HToupcam h, unsigned addr, const unsigned char* pBuffer, unsigned nBufferLen), (h, addr, pBuffer, nBufferLen)) \ +C(HRESULT, Toupcam_read_EEPROM, (HToupcam h, unsigned addr, unsigned char* pBuffer, unsigned nBufferLen), (h, addr, pBuffer, nBufferLen)) \ +C(HRESULT, Toupcam_read_Pipe, (HToupcam h, unsigned pipeId, void* pBuffer, unsigned nBufferLen), (h, pipeId, pBuffer, nBufferLen)) \ +C(HRESULT, Toupcam_write_Pipe, (HToupcam h, unsigned pipeId, const void* pBuffer, unsigned nBufferLen), (h, pipeId, pBuffer, nBufferLen)) \ +C(HRESULT, Toupcam_feed_Pipe, (HToupcam h, unsigned pipeId), (h, pipeId)) \ +C(HRESULT, Toupcam_put_Option, (HToupcam h, unsigned iOption, int iValue), (h, iOption, iValue)) \ +C(HRESULT, Toupcam_get_Option, (HToupcam h, unsigned iOption, int* piValue), (h, iOption, piValue)) \ +C(HRESULT, Toupcam_put_Roi, (HToupcam h, unsigned xOffset, unsigned yOffset, unsigned xWidth, unsigned yHeight), (h, xOffset, yOffset, xWidth, yHeight)) \ +C(HRESULT, Toupcam_get_Roi, (HToupcam h, unsigned* pxOffset, unsigned* pyOffset, unsigned* pxWidth, unsigned* pyHeight), (h, pxOffset, pyOffset, pxWidth, pyHeight)) \ +C(HRESULT, Toupcam_Replug, (const char* camId), (camId)) \ +C(HRESULT, Toupcam_get_AfParam, (HToupcam h, ToupcamAfParam* pAfParam), (h, pAfParam)) \ +C(HRESULT, Toupcam_IoControl, (HToupcam h, unsigned ioLineNumber, unsigned nType, int outVal, int* inVal), (h, ioLineNumber, nType, outVal, inVal)) \ +C(HRESULT, Toupcam_rwc_Flash, (HToupcam h, unsigned action, unsigned addr, unsigned len, void* pData), (h, action, addr, len, pData)) \ +C(HRESULT, Toupcam_write_UART, (HToupcam h, const unsigned char* pData, unsigned nDataLen), (h, pData, nDataLen)) \ +C(HRESULT, Toupcam_read_UART, (HToupcam h, unsigned char* pBuffer, unsigned nBufferLen), (h, pBuffer, nBufferLen)) \ +C(const ToupcamModelV2**, Toupcam_all_Model, (), ()) \ +C(const ToupcamModelV2*, Toupcam_query_Model, (HToupcam h), (h)) \ +C(const ToupcamModelV2*, Toupcam_get_Model, (unsigned short idVendor, unsigned short idProduct), (idVendor, idProduct)) \ +C(HRESULT, Toupcam_Update, (const char* camId, const char* filePath, PITOUPCAM_PROGRESS funProgress, void* ctxProgress), (camId, filePath, funProgress, ctxProgress)) \ +C(HRESULT, Toupcam_put_Linear, (HToupcam h, const unsigned char* v8, const unsigned short* v16), (h, v8, v16)) \ +C(HRESULT, Toupcam_put_Curve, (HToupcam h, const unsigned char* v8, const unsigned short* v16), (h, v8, v16)) \ +C(HRESULT, Toupcam_put_ColorMatrix, (HToupcam h, const double v[9]), (h, v)) \ +C(HRESULT, Toupcam_put_InitWBGain, (HToupcam h, const unsigned short v[3]), (h, v)) \ +C(HRESULT, Toupcam_get_FrameRate, (HToupcam h, unsigned* nFrame, unsigned* nTime, unsigned* nTotalFrame), (h, nFrame, nTime, nTotalFrame)) \ +C(HRESULT, Toupcam_ST4PlusGuide, (HToupcam h, unsigned nDirect, unsigned nDuration), (h, nDirect, nDuration)) \ +C(HRESULT, Toupcam_ST4PlusGuideState, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_Gain2TempTint, (const int gain[3], int* temp, int* tint), (gain, temp, tint)) \ +C(void, Toupcam_TempTint2Gain, (const int temp, const int tint, int gain[3]), (temp, tint, gain)) \ +C(double, Toupcam_calc_ClarityFactor, (const void* pImageData, int bits, unsigned nImgWidth, unsigned nImgHeight), (pImageData, bits, nImgWidth, nImgHeight)) \ +C(double, Toupcam_calc_ClarityFactorV2, (const void* pImageData, int bits, unsigned nImgWidth, unsigned nImgHeight, unsigned xOffset, unsigned yOffset, unsigned xWidth, unsigned yHeight), (pImageData, bits, nImgWidth, nImgHeight, xOffset, yOffset, xWidth, yHeight)) \ +C(void, Toupcam_deBayerV2, (unsigned nFourCC, int nW, int nH, const void* input, void* output, unsigned char nBitDepth, unsigned char nBitCount), (nFourCC, nW, nH, input, output, nBitDepth, nBitCount)) \ +C(void, Toupcam_deBayer, (unsigned nFourCC, int nW, int nH, const void* input, void* output, unsigned char nBitDepth), (nFourCC, nW, nH, input, output, nBitDepth)) \ +C(HRESULT, Toupcam_put_Demosaic, (HToupcam h, PTOUPCAM_DEMOSAIC_CALLBACK funDemosaic, void* ctxDemosaic), (h, funDemosaic, ctxDemosaic)) \ +C(unsigned, Toupcam_Enum, (ToupcamDevice arr[TOUPCAM_MAX]), (arr)) \ +C(HRESULT, Toupcam_StartPushModeV2, (HToupcam h, PTOUPCAM_DATA_CALLBACK_V2 funData, void* ctxData), (h, funData, ctxData)) \ +C(HRESULT, Toupcam_StartPushMode, (HToupcam h, PTOUPCAM_DATA_CALLBACK funData, void* ctxData), (h, funData, ctxData)) \ +C(HRESULT, Toupcam_put_ExpoCallback, (HToupcam h, PITOUPCAM_EXPOSURE_CALLBACK funExpo, void* ctxExpo), (h, funExpo, ctxExpo)) \ +C(HRESULT, Toupcam_put_ChromeCallback, (HToupcam h, PITOUPCAM_CHROME_CALLBACK funChrome, void* ctxChrome), (h, funChrome, ctxChrome)) \ +C(HRESULT, Toupcam_FfcOnePush, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_DfcOnePush, (HToupcam h), (h)) \ +C(HRESULT, Toupcam_AwbOnePush, (HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT), (h, funTT, ctxTT)) \ +C(HRESULT, Toupcam_AbbOnePush, (HToupcam h, PITOUPCAM_BLACKBALANCE_CALLBACK funBB, void* ctxBB), (h, funBB, ctxBB)) \ +C(HRESULT, Toupcam_GigeEnable, (PTOUPCAM_HOTPLUG funHotPlug, void* ctxHotPlug), (funHotPlug, ctxHotPlug)) \ +C(void, Toupcam_HotPlug, (PTOUPCAM_HOTPLUG funHotPlug, void* ctxHotPlug), (funHotPlug, ctxHotPlug)) \ +C(HRESULT, Toupcam_AAF, (HToupcam h, int action, int outVal, int* inVal), (h, action, outVal, inVal)) \ +C(HRESULT, Toupcam_put_TempTintInit, (HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT), (h, funTT, ctxTT)) \ +C(HRESULT, Toupcam_put_ProcessMode, (HToupcam h, unsigned nProcessMode), (h, nProcessMode)) \ +C(HRESULT, Toupcam_get_ProcessMode, (HToupcam h, unsigned* pnProcessMode), (h, pnProcessMode)) \ +C(HRESULT, Toupcam_put_RoiMode, (HToupcam h, int bRoiMode, int xOffset, int yOffset), (h, bRoiMode, xOffset, yOffset)) \ +C(HRESULT, Toupcam_get_RoiMode, (HToupcam h, int* pbRoiMode, int* pxOffset, int* pyOffset), (h, pbRoiMode, pxOffset, pyOffset)) \ +C(HRESULT, Toupcam_put_VignetEnable, (HToupcam h, int bEnable), (h, bEnable)) \ +C(HRESULT, Toupcam_get_VignetEnable, (HToupcam h, int* bEnable), (h, bEnable)) \ +C(HRESULT, Toupcam_put_VignetAmountInt, (HToupcam h, int nAmount), (h, nAmount)) \ +C(HRESULT, Toupcam_get_VignetAmountInt, (HToupcam h, int* nAmount), (h, nAmount)) \ +C(HRESULT, Toupcam_put_VignetMidPointInt, (HToupcam h, int nMidPoint), (h, nMidPoint)) \ +C(HRESULT, Toupcam_get_VignetMidPointInt, (HToupcam h, int* nMidPoint), (h, nMidPoint)) \ +C(HRESULT, Toupcam_set_Name, (HToupcam h, const char* name), (h, name)) \ +C(HRESULT, Toupcam_query_Name, (HToupcam h, char name[64]), (h, name)) \ +C(HRESULT, Toupcam_put_Name, (const char* camId, const char* name), (camId, name)) \ +C(HRESULT, Toupcam_get_Name, (const char* camId, char name[64]), (camId, name)) \ +C(unsigned, Toupcam_EnumWithName, (ToupcamDeviceV2 pti[TOUPCAM_MAX]), (pti)) \ +C(HRESULT, Toupcam_put_RoiN, (HToupcam h, unsigned xOffset[], unsigned yOffset[], unsigned xWidth[], unsigned yHeight[], unsigned Num), (h, xOffset, yOffset, xWidth, yHeight, Num)) \ +C(HRESULT, Toupcam_log_File, (const char *filepath), (filepath)) \ +C(HRESULT, Toupcam_log_Level, (unsigned level), (level)) + + +#define C C_PTR +TOUPCAM_LIST +#undef C + +#define C C_DEF +TOUPCAM_LIST +#undef C + +const char *err; +static __attribute__((constructor)) void con() { + libtoupcam = dlopen(LIBTOUPCAM_NAME, RTLD_LAZY); +#define C C_ASSIGN +TOUPCAM_LIST +#undef C +} + +#if 0 +/* These are the cameras that are supported by the Touptek driver. */ +enum { + TOUPCAM_MODEL_UA130CA, + TOUPCAM_MODEL_G3CMOS10300KPA, + TOUPCAM_MODEL_G3CMOS10300KPA_USB2, + TOUPCAM_MODEL_E3CMOS01500KMA, + TOUPCAM_MODEL_E3CMOS01500KMA_USB2, + TOUPCAM_MODEL_MTR3CCD01400KPB, + TOUPCAM_MODEL_MTR3CCD01400KPB_USB2, + TOUPCAM_MODEL_UA1600CA, + TOUPCAM_MODEL_MTR3CCD09000KPA, + TOUPCAM_MODEL_MTR3CCD09000KPA_USB2, + TOUPCAM_MODEL_G3M178M, + TOUPCAM_MODEL_G3M178M_USB2, + TOUPCAM_MODEL_G3M178C, + TOUPCAM_MODEL_G3M178C_USB2, + TOUPCAM_MODEL_U3CMOS16000KPB, + TOUPCAM_MODEL_U3CMOS16000KPB_USB2, + TOUPCAM_MODEL_E3ISPM02000KPA, + TOUPCAM_MODEL_E3ISPM02000KPA_USB2, + TOUPCAM_MODEL_G3CMOS20000KMA, + TOUPCAM_MODEL_G3CMOS20000KMA_USB2, + TOUPCAM_MODEL_U3CCD12000KPA, + TOUPCAM_MODEL_U3CCD12000KPA_USB2, + TOUPCAM_MODEL_ATR3CMOS16000KMA, + TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2, + TOUPCAM_MODEL_G3CMOS20000KPA, + TOUPCAM_MODEL_G3CMOS20000KPA_USB2, + TOUPCAM_MODEL_G3CMOS02300KPA, + TOUPCAM_MODEL_G3CMOS02300KPA_USB2, + TOUPCAM_MODEL_I3ISPM12000KPA, + TOUPCAM_MODEL_I3ISPM12000KPA_USB2, + TOUPCAM_MODEL_U3CCD09000KPA, + TOUPCAM_MODEL_U3CCD09000KPA_USB2, + TOUPCAM_MODEL_G3CMOS02300KMC, + TOUPCAM_MODEL_G3CMOS02300KMC_USB2, + TOUPCAM_MODEL_E3ISPM12300KPA, + TOUPCAM_MODEL_E3ISPM12300KPA_USB2, + TOUPCAM_MODEL_ECMOS06600KPA, + TOUPCAM_MODEL_ECMOS08300KPA, + TOUPCAM_MODEL_UA1000CA, + TOUPCAM_MODEL_UA1000CA_2, + TOUPCAM_MODEL_UA510CA, + TOUPCAM_MODEL_UA510CA_2, + TOUPCAM_MODEL_UA310CA, + TOUPCAM_MODEL_UA310CA_2, + TOUPCAM_MODEL_E3ISPM08300KPA, + TOUPCAM_MODEL_E3ISPM08300KPA_USB2, + TOUPCAM_MODEL_G3CMOS16000KMA, + TOUPCAM_MODEL_G3CMOS16000KMA_USB2, + TOUPCAM_MODEL_G3CMOS16000KPA, + TOUPCAM_MODEL_G3CMOS16000KPA_USB2, + TOUPCAM_MODEL_G3M287M, + TOUPCAM_MODEL_G3M287M_USB2, + TOUPCAM_MODEL_G3M385C, + TOUPCAM_MODEL_G3M385C_USB2, + TOUPCAM_MODEL_EP3CMOS00400KMA, + TOUPCAM_MODEL_EP3CMOS00400KMA_USB2, + TOUPCAM_MODEL_EP3CMOS00400KPA, + TOUPCAM_MODEL_EP3CMOS00400KPA_USB2, + TOUPCAM_MODEL_E3CMOS00400KMA, + TOUPCAM_MODEL_E3CMOS00400KMA_USB2, + TOUPCAM_MODEL_E3CMOS00400KPA, + TOUPCAM_MODEL_E3CMOS00400KPA_USB2, + TOUPCAM_MODEL_G3M290C, + TOUPCAM_MODEL_G3M290C_USB2, + TOUPCAM_MODEL_G3M290M, + TOUPCAM_MODEL_G3M290M_USB2, + TOUPCAM_MODEL_G3M224C, + TOUPCAM_MODEL_G3M224C_USB2, + TOUPCAM_MODEL_U3ISPM16000KPB, + TOUPCAM_MODEL_U3ISPM16000KPB_USB2, + TOUPCAM_MODEL_E3CMOS05000KMA, + TOUPCAM_MODEL_E3CMOS05000KMA_USB2, + TOUPCAM_MODEL_E3CMOS03100KMC, + TOUPCAM_MODEL_E3CMOS03100KMC_USB2, + TOUPCAM_MODEL_E3ISPM09000KPA, + TOUPCAM_MODEL_E3ISPM09000KPA_USB2, + TOUPCAM_MODEL_I3CMOS01200KPA, + TOUPCAM_MODEL_I3CMOS01200KPA_USB2, + TOUPCAM_MODEL_U3ISPM16000KPA, + TOUPCAM_MODEL_U3ISPM16000KPA_USB2, + TOUPCAM_MODEL_U3CMOS16000KMB, + TOUPCAM_MODEL_U3CMOS16000KMB_USB2, + TOUPCAM_MODEL_G3CMOS02300KPC, + TOUPCAM_MODEL_G3CMOS02300KPC_USB2, + TOUPCAM_MODEL_G3M178M_2, + TOUPCAM_MODEL_G3M178M_USB2_2, + TOUPCAM_MODEL_G3M178C_2, + TOUPCAM_MODEL_G3M178C_USB2_2, + TOUPCAM_MODEL_E3ISPM03100KPA, + TOUPCAM_MODEL_E3ISPM03100KPA_USB2, + TOUPCAM_MODEL_E3ISPM05000KPA, + TOUPCAM_MODEL_E3ISPM05000KPA_USB2, + TOUPCAM_MODEL_MG3CMOS16000KPA, + TOUPCAM_MODEL_MG3CMOS16000KPA_USB2, + TOUPCAM_MODEL_MG3CMOS02300KPA, + TOUPCAM_MODEL_MG3CMOS02300KPA_USB2, + TOUPCAM_MODEL_U3ISPM18000KPA, + TOUPCAM_MODEL_U3ISPM18000KPA_USB2, + TOUPCAM_MODEL_E3ISPM03100KPB, + TOUPCAM_MODEL_E3ISPM03100KPB_USB2, + TOUPCAM_MODEL_EP3CMOS02300KPC, + TOUPCAM_MODEL_EP3CMOS02300KPC_USB2, + TOUPCAM_MODEL_EP3CMOS02300KMC, + TOUPCAM_MODEL_EP3CMOS02300KMC_USB2, + TOUPCAM_MODEL_EP3CMOS06300KMA, + TOUPCAM_MODEL_EP3CMOS06300KMA_USB2, + TOUPCAM_MODEL_EP3CMOS20000KPA, + TOUPCAM_MODEL_EP3CMOS20000KPA_USB2, + TOUPCAM_MODEL_GPCMOS02000KMA, + TOUPCAM_MODEL_EXCCD01400KPA, + TOUPCAM_MODEL_I3CMOS03100KPA, + TOUPCAM_MODEL_I3CMOS03100KPA_USB2, + TOUPCAM_MODEL_U3CMOS10000KMA, + TOUPCAM_MODEL_U3CMOS10000KMA_USB2, + TOUPCAM_MODEL_E3ISPM12000KPA, + TOUPCAM_MODEL_E3ISPM12000KPA_USB2, + TOUPCAM_MODEL_E3ISPM05000KPA_2, + TOUPCAM_MODEL_E3ISPM05000KPA_USB2_2, + TOUPCAM_MODEL_AF3CMOS06300KPA, + TOUPCAM_MODEL_AF3CMOS06300KPA_USB2, + TOUPCAM_MODEL_E3ISPM20000KPA, + TOUPCAM_MODEL_E3ISPM20000KPA_USB2, + TOUPCAM_MODEL_G3CMOS20000KPA_2, + TOUPCAM_MODEL_G3CMOS20000KPA_USB2_2, + TOUPCAM_MODEL_E3CMOS02300KMC, + TOUPCAM_MODEL_E3CMOS02300KMC_USB2, + TOUPCAM_MODEL_ATR3CMOS02300KMB, + TOUPCAM_MODEL_ATR3CMOS02300KMB_USB2, + TOUPCAM_MODEL_E3CMOS20000KPA, + TOUPCAM_MODEL_E3CMOS20000KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS16000KPA, + TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS16000KMA, + TOUPCAM_MODEL_MTR3CMOS16000KMA_USB2, + TOUPCAM_MODEL_ECMOS05300KPA, + TOUPCAM_MODEL_ECMOS03100KPA, + TOUPCAM_MODEL_E3ISPM06300KPA, + TOUPCAM_MODEL_E3ISPM06300KPA_USB2, + TOUPCAM_MODEL_ECMOS01200KPA, + TOUPCAM_MODEL_E3CMOS01200KPA, + TOUPCAM_MODEL_E3CMOS01200KPA_USB2, + TOUPCAM_MODEL_G3CMOS16000KMA_2, + TOUPCAM_MODEL_G3CMOS16000KMA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS02300KPB, + TOUPCAM_MODEL_ATR3CMOS02300KPB_USB2, + TOUPCAM_MODEL_ATR3CMOS06300KPA, + TOUPCAM_MODEL_ATR3CMOS06300KPA_USB2, + TOUPCAM_MODEL_ATR3CMOS16000KPA, + TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2, + TOUPCAM_MODEL_G3CMOS16000KPA_2, + TOUPCAM_MODEL_G3CMOS16000KPA_USB2_2, + TOUPCAM_MODEL_ECMOS02000KPA, + TOUPCAM_MODEL_EP3CMOS06300KPA, + TOUPCAM_MODEL_EP3CMOS06300KPA_USB2, + TOUPCAM_MODEL_E3CMOS05000KMA_2, + TOUPCAM_MODEL_E3CMOS05000KMA_USB2_2, + TOUPCAM_MODEL_E3CMOS05000KPA, + TOUPCAM_MODEL_E3CMOS05000KPA_USB2, + TOUPCAM_MODEL_GPCMOS02000KPA, + TOUPCAM_MODEL_EXCCD00440KPB, + TOUPCAM_MODEL_GPCMOS01200KMA, + TOUPCAM_MODEL_EXCCD00300KPA, + TOUPCAM_MODEL_U3CMOS16000KMB_2, + TOUPCAM_MODEL_U3CMOS16000KMB_USB2_2, + TOUPCAM_MODEL_U3CCD01400KPB, + TOUPCAM_MODEL_U3CCD01400KPB_USB2, + TOUPCAM_MODEL_U3CCD01400KMB, + TOUPCAM_MODEL_U3CCD01400KMB_USB2, + TOUPCAM_MODEL_G3CMOS06300KMA, + TOUPCAM_MODEL_G3CMOS06300KMA_USB2, + TOUPCAM_MODEL_MTR3CCD01400KMB, + TOUPCAM_MODEL_MTR3CCD01400KMB_USB2, + TOUPCAM_MODEL_MTR3CCD01400KPB_2, + TOUPCAM_MODEL_MTR3CCD01400KPB_USB2_2, + TOUPCAM_MODEL_GPCMOS01200KMB, + TOUPCAM_MODEL_U3CMOS16000KPB_2, + TOUPCAM_MODEL_U3CMOS16000KPB_USB2_2, + TOUPCAM_MODEL_GPCMOS01200KPB, + TOUPCAM_MODEL_G3CMOS01200KPA, + TOUPCAM_MODEL_G3CMOS01200KPA_USB2, + TOUPCAM_MODEL_G3CMOS06300KPA, + TOUPCAM_MODEL_G3CMOS06300KPA_USB2, + TOUPCAM_MODEL_E3CMOS06300KMA, + TOUPCAM_MODEL_E3CMOS06300KMA_USB2, + TOUPCAM_MODEL_X05100KPA, + TOUPCAM_MODEL_X01200KPA, + TOUPCAM_MODEL_GPCMOS01200KPC, + TOUPCAM_MODEL_ATR3CCD06000KPA, + TOUPCAM_MODEL_ATR3CCD06000KPA_USB2, + TOUPCAM_MODEL_ATR3CCD06000KMA, + TOUPCAM_MODEL_ATR3CCD06000KMA_USB2, + TOUPCAM_MODEL_MTR3CCD02800KMA, + TOUPCAM_MODEL_MTR3CCD02800KMA_USB2, + TOUPCAM_MODEL_MTR3CCD02800KPA, + TOUPCAM_MODEL_MTR3CCD02800KPA_USB2, + TOUPCAM_MODEL_U3CCD06000KMA, + TOUPCAM_MODEL_U3CCD06000KMA_USB2, + TOUPCAM_MODEL_MTR3CCD01400KMA, + TOUPCAM_MODEL_MTR3CCD01400KMA_USB2, + TOUPCAM_MODEL_G3CMOS02300KMC_2, + TOUPCAM_MODEL_G3CMOS02300KMC_USB2_2, + TOUPCAM_MODEL_MTR3CCD06000KMA, + TOUPCAM_MODEL_MTR3CCD06000KMA_USB2, + TOUPCAM_MODEL_U3CCD02800KMA, + TOUPCAM_MODEL_U3CCD02800KMA_USB2, + TOUPCAM_MODEL_GCMOS01200KMA, + TOUPCAM_MODEL_GCMOS01200KMB, + TOUPCAM_MODEL_G3CMOS02300KPB, + TOUPCAM_MODEL_G3CMOS02300KPB_USB2, + TOUPCAM_MODEL_GCMOS01200KPB, + TOUPCAM_MODEL_U3CCD02800KPA, + TOUPCAM_MODEL_U3CCD02800KPA_USB2, + TOUPCAM_MODEL_MTR3CCD01400KPA, + TOUPCAM_MODEL_MTR3CCD01400KPA_USB2, + TOUPCAM_MODEL_U3CMOS16000KPA, + TOUPCAM_MODEL_U3CMOS16000KPA_USB2, + TOUPCAM_MODEL_U3CCD06000KPA, + TOUPCAM_MODEL_U3CCD06000KPA_USB2, + TOUPCAM_MODEL_EXCCD00300KMA, + TOUPCAM_MODEL_EXCCD00300KMA_2, + TOUPCAM_MODEL_EP3CMOS02300KPA, + TOUPCAM_MODEL_EP3CMOS02300KPA_USB2, + TOUPCAM_MODEL_EXCCD00440KPA, + TOUPCAM_MODEL_EXCCD00440KMB, + TOUPCAM_MODEL_EXCCD00440KMA, + TOUPCAM_MODEL_MTR3CCD06000KPA, + TOUPCAM_MODEL_MTR3CCD06000KPA_USB2, + TOUPCAM_MODEL_EXCCD00440KPB_2, + TOUPCAM_MODEL_ICMOS03100KPA, + TOUPCAM_MODEL_E3CMOS12000KPA, + TOUPCAM_MODEL_E3CMOS12000KPA_USB2, + TOUPCAM_MODEL_E3CMOS03100KPB, + TOUPCAM_MODEL_E3CMOS03100KPB_USB2, + TOUPCAM_MODEL_UCMOS05100KPC, + TOUPCAM_MODEL_E3CMOS02300KPB, + TOUPCAM_MODEL_E3CMOS02300KPB_USB2, + TOUPCAM_MODEL_UHCCD05200KMA, + TOUPCAM_MODEL_G3CMOS02300KPA_2, + TOUPCAM_MODEL_G3CMOS02300KPA_USB2_2, + TOUPCAM_MODEL_GCMOS01200KMA_2, + TOUPCAM_MODEL_E3CMOS06300KPA, + TOUPCAM_MODEL_E3CMOS06300KPA_USB2, + TOUPCAM_MODEL_ICMOS14000KPC, + TOUPCAM_MODEL_EXCCD00300KMA_2_2, + TOUPCAM_MODEL_E3CMOS02300KPA, + TOUPCAM_MODEL_E3CMOS02300KPA_USB2, + TOUPCAM_MODEL_E3CMOS03100KPA, + TOUPCAM_MODEL_E3CMOS03100KPA_USB2, + TOUPCAM_MODEL_EXCCD00440KMB_2, + TOUPCAM_MODEL_EXCCD00440KPB_2_2, + TOUPCAM_MODEL_EXCCD00440KMA_2, + TOUPCAM_MODEL_AAICX429C, + TOUPCAM_MODEL_U3CMOS18000KPA, + TOUPCAM_MODEL_U3CMOS18000KPA_USB2, + TOUPCAM_MODEL_U3CMOS03100KPC, + TOUPCAM_MODEL_U3CMOS03100KPC_USB2, + TOUPCAM_MODEL_L3CMOS03100KPB, + TOUPCAM_MODEL_L3CMOS03100KPB_USB2, + TOUPCAM_MODEL_GCMOS03100KPA, + TOUPCAM_MODEL_UHCCD05200KPA, + TOUPCAM_MODEL_UHCCD05000KPA, + TOUPCAM_MODEL_UHCCD03100KPB, + TOUPCAM_MODEL_UHCCD02000KPA, + TOUPCAM_MODEL_UHCCD01400KPB, + TOUPCAM_MODEL_UHCCD01400KMB, + TOUPCAM_MODEL_EXCCD01400KPA_2, + TOUPCAM_MODEL_EXCCD01400KMA, + TOUPCAM_MODEL_ICMOS10000KPA, + TOUPCAM_MODEL_ICMOS14000KPA, + TOUPCAM_MODEL_LCMOS03100KPB, + TOUPCAM_MODEL_UCMOS02000KPC, + TOUPCAM_MODEL_WCMOS10000KPA, + TOUPCAM_MODEL_UCMOS03100KPB, + TOUPCAM_MODEL_GCMOS01200KMB_2, + TOUPCAM_MODEL_GCMOS01200KPB_2, + TOUPCAM_MODEL_GCMOS01200KPB_2_2, + TOUPCAM_MODEL_UCMOS01200KPB, + TOUPCAM_MODEL_U3CMOS14000KPB, + TOUPCAM_MODEL_U3CMOS14000KPB_USB2, + TOUPCAM_MODEL_LCMOS01200KPB, + TOUPCAM_MODEL_LCMOS14000KPA, + TOUPCAM_MODEL_LCMOS10000KPA, + TOUPCAM_MODEL_LCMOS09000KPA, + TOUPCAM_MODEL_LCMOS08000KPA, + TOUPCAM_MODEL_LCMOS05100KPA, + TOUPCAM_MODEL_LCMOS03100KPA, + TOUPCAM_MODEL_LCMOS02000KPA, + TOUPCAM_MODEL_LCMOS01300KPA, + TOUPCAM_MODEL_SCCCD01400KMB, + TOUPCAM_MODEL_UHCCD05200KPA_2, + TOUPCAM_MODEL_UHCCD05100KPA, + TOUPCAM_MODEL_UHCCD05100KPA_2, + TOUPCAM_MODEL_UHCCD05000KPA_2, + TOUPCAM_MODEL_UHCCD03100KPB_2, + TOUPCAM_MODEL_UHCCD02000KPA_2, + TOUPCAM_MODEL_UHCCD01400KPB_2, + TOUPCAM_MODEL_UHCCD01400KPA, + TOUPCAM_MODEL_UHCCD01400KMB_2, + TOUPCAM_MODEL_UHCCD01400KMA, + TOUPCAM_MODEL_UHCCD00800KPA, + TOUPCAM_MODEL_UCMOS05100KMA, + TOUPCAM_MODEL_UCMOS14000KPA, + TOUPCAM_MODEL_UCMOS10000KPA, + TOUPCAM_MODEL_UCMOS09000KPB, + TOUPCAM_MODEL_UCMOS09000KPA, + TOUPCAM_MODEL_UCMOS08000KPB, + TOUPCAM_MODEL_UCMOS08000KPA, + TOUPCAM_MODEL_UCMOS05100KPA, + TOUPCAM_MODEL_UCMOS03100KPA, + TOUPCAM_MODEL_UCMOS02000KPB, + TOUPCAM_MODEL_UCMOS02000KPA, + TOUPCAM_MODEL_UCMOS01300KPA, + TOUPCAM_MODEL_UCMOS01300KMA, + TOUPCAM_MODEL_UCMOS00350KPA, + TOUPCAM_MODEL_U3CMOS14000KPA, + TOUPCAM_MODEL_U3CMOS14000KPA_USB2, + TOUPCAM_MODEL_U3CMOS10000KPA, + TOUPCAM_MODEL_U3CMOS10000KPA_USB2, + TOUPCAM_MODEL_U3CMOS08500KPA, + TOUPCAM_MODEL_U3CMOS08500KPA_USB2, + TOUPCAM_MODEL_U3CMOS05100KPA, + TOUPCAM_MODEL_U3CMOS05100KPA_USB2, + TOUPCAM_MODEL_U3CMOS03100KPB, + TOUPCAM_MODEL_U3CMOS03100KPB_USB2, + TOUPCAM_MODEL_U3CMOS03100KPA, + TOUPCAM_MODEL_U3CMOS03100KPA_USB2, + TOUPCAM_MODEL_SCCCD05200KPA, + TOUPCAM_MODEL_SCCCD01400KMA, + TOUPCAM_MODEL_SCCCD01400KPB, + TOUPCAM_MODEL_SCCCD01400KPA, + TOUPCAM_MODEL_EXCCD01400KPA_2_2, + TOUPCAM_MODEL_EXCCD01400KMA_2, + TOUPCAM_MODEL_EXCCD00300KMA_2_2_2, + TOUPCAM_MODEL_ICMOS03100KPA_2, + TOUPCAM_MODEL_ICMOS01300KMA, + TOUPCAM_MODEL_UCMOS01200KMA, + TOUPCAM_MODEL_L3CMOS14000KPA, + TOUPCAM_MODEL_L3CMOS14000KPA_USB2, + TOUPCAM_MODEL_L3CMOS10000KPA, + TOUPCAM_MODEL_L3CMOS10000KPA_USB2, + TOUPCAM_MODEL_L3CMOS05100KPA, + TOUPCAM_MODEL_L3CMOS05100KPA_USB2, + TOUPCAM_MODEL_L3CMOS03100KPA, + TOUPCAM_MODEL_L3CMOS03100KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS20000KPA, + TOUPCAM_MODEL_MTR3CMOS20000KPA_USB2, + TOUPCAM_MODEL_ATR3CMOS20000KPA, + TOUPCAM_MODEL_ATR3CMOS20000KPA_USB2, + TOUPCAM_MODEL_MTR3CCD12000KPA, + TOUPCAM_MODEL_MTR3CCD12000KPA_USB2, + TOUPCAM_MODEL_E3ISPM01500KPA, + TOUPCAM_MODEL_E3ISPM01500KPA_USB2, + TOUPCAM_MODEL_E3CMOS20000KMA, + TOUPCAM_MODEL_E3CMOS20000KMA_USB2, + TOUPCAM_MODEL_G3CMOS20000KPA_2_2, + TOUPCAM_MODEL_G3CMOS20000KPA_USB2_2_2, + TOUPCAM_MODEL_BIGEYE10000KPA, + TOUPCAM_MODEL_BIGEYE10000KPA_USB2, + TOUPCAM_MODEL_BIGEYE4200KMB, + TOUPCAM_MODEL_BIGEYE4200KMB_USB2, + TOUPCAM_MODEL_G3CMOS20000KMA_2, + TOUPCAM_MODEL_G3CMOS20000KMA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS20000KMA, + TOUPCAM_MODEL_ATR3CMOS20000KMA_USB2, + TOUPCAM_MODEL_MTR3CMOS20000KMA, + TOUPCAM_MODEL_MTR3CMOS20000KMA_USB2, + TOUPCAM_MODEL_MTR3CMOS16000KPA_2, + TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2_2, + TOUPCAM_MODEL_E3CMOS01200KPA_2, + TOUPCAM_MODEL_E3CMOS01200KPA_USB2_2, + TOUPCAM_MODEL_UCMOS01300KPA_2, + TOUPCAM_MODEL_ATR3CMOS16000KPA_2, + TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2_2, + TOUPCAM_MODEL_E3CMOS12300KMA, + TOUPCAM_MODEL_E3CMOS12300KMA_USB2, + TOUPCAM_MODEL_E3ISPM08300KPB, + TOUPCAM_MODEL_E3ISPM08300KPB_USB2, + TOUPCAM_MODEL_ATR3CMOS16000KMA_2, + TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS10300KPA, + TOUPCAM_MODEL_ATR3CMOS10300KPA_USB2, + TOUPCAM_MODEL_LCMOS01300KPA_2, + TOUPCAM_MODEL_MTR3CCD12000KMA, + TOUPCAM_MODEL_MTR3CCD12000KMA_USB2, + TOUPCAM_MODEL_I3ISPM01500KPA, + TOUPCAM_MODEL_I3ISPM01500KPA_USB2, + TOUPCAM_MODEL_I3ISPM01500KPA_2, + TOUPCAM_MODEL_I3ISPM01500KPA_USB2_2, + TOUPCAM_MODEL_MTR3CMOS10300KPA, + TOUPCAM_MODEL_MTR3CMOS10300KPA_USB2, + TOUPCAM_MODEL_I3ISPM02000KPA, + TOUPCAM_MODEL_I3ISPM02000KPA_USB2, + TOUPCAM_MODEL_ECMOS05000KPA, + TOUPCAM_MODEL_G3CMOS16000KPA_2_2, + TOUPCAM_MODEL_G3CMOS16000KPA_USB2_2_2, + TOUPCAM_MODEL_G3CMOS16000KMA_2_2, + TOUPCAM_MODEL_G3CMOS16000KMA_USB2_2_2, + TOUPCAM_MODEL_E3ISPM06300KPB, + TOUPCAM_MODEL_E3ISPM06300KPB_USB2, + TOUPCAM_MODEL_G3CMOS10300KPA_2, + TOUPCAM_MODEL_G3CMOS10300KPA_USB2_2, + TOUPCAM_MODEL_C3CMOS05100KPA, + TOUPCAM_MODEL_C3CMOS05100KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS16000KMA_2, + TOUPCAM_MODEL_MTR3CMOS16000KMA_USB2_2, + TOUPCAM_MODEL_MTR3CMOS16000KPA_2_2, + TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2_2_2, + TOUPCAM_MODEL_I3CMOS01500KMA, + TOUPCAM_MODEL_I3CMOS01500KMA_USB2, + TOUPCAM_MODEL_I3CMOS01500KMA_2, + TOUPCAM_MODEL_I3CMOS01500KMA_USB2_2, + TOUPCAM_MODEL_BIGEYE4200KMA, + TOUPCAM_MODEL_BIGEYE4200KMA_USB2, + TOUPCAM_MODEL_E3CMOS20000KPB, + TOUPCAM_MODEL_E3CMOS20000KPB_USB2, + TOUPCAM_MODEL_ATR3CMOS01700KMA, + TOUPCAM_MODEL_ATR3CMOS01700KMA_USB2, + TOUPCAM_MODEL_ATR3CMOS01700KPA, + TOUPCAM_MODEL_ATR3CMOS01700KPA_USB2, + TOUPCAM_MODEL_ATR3CMOS07100KMA, + TOUPCAM_MODEL_ATR3CMOS07100KMA_USB2, + TOUPCAM_MODEL_ATR3CMOS07100KPA, + TOUPCAM_MODEL_ATR3CMOS07100KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS07100KPA, + TOUPCAM_MODEL_MTR3CMOS07100KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS07100KMA, + TOUPCAM_MODEL_MTR3CMOS07100KMA_USB2, + TOUPCAM_MODEL_MTR3CMOS01700KPA, + TOUPCAM_MODEL_MTR3CMOS01700KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS01700KMA, + TOUPCAM_MODEL_MTR3CMOS01700KMA_USB2, + TOUPCAM_MODEL_SL170_C_M, + TOUPCAM_MODEL_SL170_C_M_USB2, + TOUPCAM_MODEL_PUM02000KPA, + TOUPCAM_MODEL_GPCMOS02000KPB, + TOUPCAM_MODEL_I3CMOS03100KMA, + TOUPCAM_MODEL_I3CMOS03100KMA_USB2, + TOUPCAM_MODEL_I3CMOS03100KMA_2, + TOUPCAM_MODEL_I3CMOS03100KMA_USB2_2, + TOUPCAM_MODEL_I3CMOS05000KMA, + TOUPCAM_MODEL_I3CMOS05000KMA_USB2, + TOUPCAM_MODEL_I3CMOS05000KMA_2, + TOUPCAM_MODEL_I3CMOS05000KMA_USB2_2, + TOUPCAM_MODEL_C3CMOS10000KPA, + TOUPCAM_MODEL_C3CMOS10000KPA_USB2, + TOUPCAM_MODEL_I3ISPM05000KPA, + TOUPCAM_MODEL_I3ISPM05000KPA_USB2, + TOUPCAM_MODEL_I3ISPM05000KPA_2, + TOUPCAM_MODEL_I3ISPM05000KPA_USB2_2, + TOUPCAM_MODEL_I3ISPM03100KPA, + TOUPCAM_MODEL_I3ISPM03100KPA_USB2, + TOUPCAM_MODEL_I3ISPM03100KPA_2, + TOUPCAM_MODEL_I3ISPM03100KPA_USB2_2, + TOUPCAM_MODEL_E3ISPM18000KPA, + TOUPCAM_MODEL_E3ISPM18000KPA_USB2, + TOUPCAM_MODEL_E3ISPM20000KPB, + TOUPCAM_MODEL_E3ISPM20000KPB_USB2, + TOUPCAM_MODEL_I3ISPM05000KPB, + TOUPCAM_MODEL_I3ISPM05000KPB_USB2, + TOUPCAM_MODEL_I3ISPM05000KPB_2, + TOUPCAM_MODEL_I3ISPM05000KPB_USB2_2, + TOUPCAM_MODEL_I3ISPM03100KPB, + TOUPCAM_MODEL_I3ISPM03100KPB_USB2, + TOUPCAM_MODEL_I3ISPM03100KPB_2, + TOUPCAM_MODEL_I3ISPM03100KPB_USB2_2, + TOUPCAM_MODEL_I3CMOS05000KMB, + TOUPCAM_MODEL_I3CMOS05000KMB_USB2, + TOUPCAM_MODEL_I3CMOS05000KMB_2, + TOUPCAM_MODEL_I3CMOS05000KMB_USB2_2, + TOUPCAM_MODEL_I3CMOS03100KMB, + TOUPCAM_MODEL_I3CMOS03100KMB_USB2, + TOUPCAM_MODEL_I3CMOS03100KMB_2, + TOUPCAM_MODEL_I3CMOS03100KMB_USB2_2, + TOUPCAM_MODEL_E3ISPM21000KPA, + TOUPCAM_MODEL_E3ISPM21000KPA_USB2, + TOUPCAM_MODEL_ECMOS05100KPA, + TOUPCAM_MODEL_E3ISPM15600KPA, + TOUPCAM_MODEL_E3ISPM15600KPA_USB2, + TOUPCAM_MODEL_I3CMOS00500KMA, + TOUPCAM_MODEL_I3CMOS00500KMA_USB2, + TOUPCAM_MODEL_I3ISPM00500KPA, + TOUPCAM_MODEL_I3ISPM00500KPA_USB2, + TOUPCAM_MODEL_IUA6300KPA, + TOUPCAM_MODEL_IUA6300KPA_USB2, + TOUPCAM_MODEL_IUB4200KMB, + TOUPCAM_MODEL_IUB4200KMB_USB2, + TOUPCAM_MODEL_IUC31000KMA, + TOUPCAM_MODEL_IUC31000KMA_USB2, + TOUPCAM_MODEL_IUA6300KMA, + TOUPCAM_MODEL_IUA6300KMA_USB2, + TOUPCAM_MODEL_IUA1700KPA, + TOUPCAM_MODEL_IUA1700KPA_USB2, + TOUPCAM_MODEL_IUA7100KPA, + TOUPCAM_MODEL_IUA7100KPA_USB2, + TOUPCAM_MODEL_IUC31000KPA, + TOUPCAM_MODEL_IUC31000KPA_USB2, + TOUPCAM_MODEL_ATR3CMOS21000KPA, + TOUPCAM_MODEL_ATR3CMOS21000KPA_USB2, + TOUPCAM_MODEL_IUA20000KPA, + TOUPCAM_MODEL_IUA20000KPA_USB2, + TOUPCAM_MODEL_T3CMOS20000KPA, + TOUPCAM_MODEL_T3CMOS20000KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS21000KPA, + TOUPCAM_MODEL_MTR3CMOS21000KPA_USB2, + TOUPCAM_MODEL_GPCMOS01200KPF, + TOUPCAM_MODEL_I3CMOS06300KMA, + TOUPCAM_MODEL_I3CMOS06300KMA_USB2, + TOUPCAM_MODEL_I3ISPM06300KPA, + TOUPCAM_MODEL_I3ISPM06300KPA_USB2, + TOUPCAM_MODEL_IUA20000KMA, + TOUPCAM_MODEL_IUA20000KMA_USB2, + TOUPCAM_MODEL_IUB43000KMA, + TOUPCAM_MODEL_IUB43000KMA_USB2, + TOUPCAM_MODEL_IUC60000KMA, + TOUPCAM_MODEL_IUC60000KMA_USB2, + TOUPCAM_MODEL_IUC60000KPA, + TOUPCAM_MODEL_IUC60000KPA_USB2, + TOUPCAM_MODEL_IUA2300KPB, + TOUPCAM_MODEL_IUA2300KPB_USB2, + TOUPCAM_MODEL_IUC26000KPA, + TOUPCAM_MODEL_IUC26000KPA_USB2, + TOUPCAM_MODEL_MTR3CMOS45000KMA, + TOUPCAM_MODEL_MTR3CMOS45000KMA_USB2, + TOUPCAM_MODEL_C3CMOS05100KPB, + TOUPCAM_MODEL_C3CMOS05100KPB_USB2, + TOUPCAM_MODEL_C3CMOS03500KPA, + TOUPCAM_MODEL_C3CMOS03500KPA_USB2, + TOUPCAM_MODEL_MAX60000KPA, + TOUPCAM_MODEL_MAX60000KPA_USB2, + TOUPCAM_MODEL_BIGEYE4200KMB_2, + TOUPCAM_MODEL_BIGEYE4200KMB_USB2_2, + TOUPCAM_MODEL_IUA1700KMA, + TOUPCAM_MODEL_IUA1700KMA_USB2, + TOUPCAM_MODEL_IUA7100KMA, + TOUPCAM_MODEL_IUA7100KMA_USB2, + TOUPCAM_MODEL_ATR3CMOS26000KPA, + TOUPCAM_MODEL_ATR3CMOS26000KPA_USB2, + TOUPCAM_MODEL_E3ISPM09000KPB, + TOUPCAM_MODEL_E3ISPM09000KPB_USB2, + TOUPCAM_MODEL_ATR3CMOS09000KPA, + TOUPCAM_MODEL_ATR3CMOS09000KPA_USB2, + TOUPCAM_MODEL_G3CMOS21000KPA, + TOUPCAM_MODEL_G3CMOS21000KPA_USB2, + TOUPCAM_MODEL_ITR3CMOS16000KMA, + TOUPCAM_MODEL_ITR3CMOS16000KMA_USB2, + TOUPCAM_MODEL_MTR3CMOS26000KPA, + TOUPCAM_MODEL_MTR3CMOS26000KPA_USB2, + TOUPCAM_MODEL_BIGEYE4200KMB_2_2, + TOUPCAM_MODEL_BIGEYE4200KMB_USB2_2_2, + TOUPCAM_MODEL_SKYEYE62AM, + TOUPCAM_MODEL_SKYEYE62AM_USB2, + TOUPCAM_MODEL_MTR3CMOS09000KPA, + TOUPCAM_MODEL_MTR3CMOS09000KPA_USB2, + TOUPCAM_MODEL_BIGEYE4200KMD, + TOUPCAM_MODEL_BIGEYE4200KMD_USB2, + TOUPCAM_MODEL_IUA4100KPA, + TOUPCAM_MODEL_IUA4100KPA_USB2, + TOUPCAM_MODEL_IUA2100KPA, + TOUPCAM_MODEL_IUA2100KPA_USB2, + TOUPCAM_MODEL_E3CMOS45000KMA, + TOUPCAM_MODEL_E3CMOS45000KMA_USB2, + TOUPCAM_MODEL_SKYEYE62AC, + TOUPCAM_MODEL_SKYEYE62AC_USB2, + TOUPCAM_MODEL_SKYEYE24AC, + TOUPCAM_MODEL_SKYEYE24AC_USB2, + TOUPCAM_MODEL_MAX62AM, + TOUPCAM_MODEL_MAX62AM_USB2, + TOUPCAM_MODEL_MTR3CMOS08300KPA, + TOUPCAM_MODEL_MTR3CMOS08300KPA_USB2, + TOUPCAM_MODEL_G3M462C, + TOUPCAM_MODEL_G3M462C_USB2, + TOUPCAM_MODEL_E3ISPM08300KPC, + TOUPCAM_MODEL_E3ISPM08300KPC_USB2, + TOUPCAM_MODEL_BIGEYE4200KMA_2, + TOUPCAM_MODEL_BIGEYE4200KMA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS10300KMA, + TOUPCAM_MODEL_ATR3CMOS10300KMA_USB2, + TOUPCAM_MODEL_E3ISPM45000KPA, + TOUPCAM_MODEL_E3ISPM45000KPA_USB2, + TOUPCAM_MODEL_E3ISPM02100KPA, + TOUPCAM_MODEL_E3ISPM02100KPA_USB2, + TOUPCAM_MODEL_G3CMOS08300KPA, + TOUPCAM_MODEL_G3CMOS08300KPA_USB2, + TOUPCAM_MODEL_BIGEYE4200KME, + TOUPCAM_MODEL_BIGEYE4200KME_USB2, + TOUPCAM_MODEL_ITR3CMOS08300KPA, + TOUPCAM_MODEL_ITR3CMOS08300KPA_USB2, + TOUPCAM_MODEL_MAX04AM, + TOUPCAM_MODEL_MAX04AM_USB2, + TOUPCAM_MODEL_G3M287C, + TOUPCAM_MODEL_G3M287C_USB2, + TOUPCAM_MODEL_ATR3CMOS16000KPB, + TOUPCAM_MODEL_ATR3CMOS16000KPB_USB2, + TOUPCAM_MODEL_ATR3CMOS10300KPA_2, + TOUPCAM_MODEL_ATR3CMOS10300KPA_USB2_2, + TOUPCAM_MODEL_L3CMOS08500KPA, + TOUPCAM_MODEL_L3CMOS08500KPA_USB2, +}; + +/* This table was dumped from the touptek library */ +static const struct toupcam_model_pid toupcam_models[] = { + [TOUPCAM_MODEL_UA130CA ] = { 0x1238, { "UA130CA ", 0x0000000081000001, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{1280, 720},}}}, + [TOUPCAM_MODEL_G3CMOS10300KPA ] = { 0x11c6, { "G3CMOS10300KPA ", 0x0000000087694649, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_G3CMOS10300KPA_USB2 ] = { 0x11c7, { "G3CMOS10300KPA(USB2.0) ", 0x0000000087694709, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_E3CMOS01500KMA ] = { 0x11ce, { "E3CMOS01500KMA ", 0x0000001081002459, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS01500KMA_USB2 ] = { 0x11cf, { "E3CMOS01500KMA(USB2.0) ", 0x0000001081002519, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPB ] = { 0x11d4, { "MTR3CCD01400KPB ", 0x00000010811b44c2, 2, 2, 0, 4, 0, 6.450000, 6.450000, {{1376, 1040},{688, 520},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPB_USB2 ] = { 0x11d5, { "MTR3CCD01400KPB(USB2.0) ", 0x00000010811b4582, 2, 2, 0, 4, 0, 6.450000, 6.450000, {{1376, 1040},{688, 520},}}}, + [TOUPCAM_MODEL_UA1600CA ] = { 0x1189, { "UA1600CA ", 0x0000000081000001, 2, 3, 3, 0, 0, 1.335000, 1.335000, {{4632, 3488},{2320, 1740},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CCD09000KPA ] = { 0x101d, { "MTR3CCD09000KPA ", 0x00000010811b44c2, 1, 2, 0, 4, 0, 3.690000, 3.690000, {{3388, 2712},{1694, 1356},}}}, + [TOUPCAM_MODEL_MTR3CCD09000KPA_USB2 ] = { 0x1031, { "MTR3CCD09000KPA(USB2.0) ", 0x00000010811b4582, 1, 2, 0, 4, 0, 3.690000, 3.690000, {{3388, 2712},{1694, 1356},}}}, + [TOUPCAM_MODEL_G3M178M ] = { 0x11cc, { "G3M178M ", 0x0000000081484659, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178M_USB2 ] = { 0x11cd, { "G3M178M(USB2.0) ", 0x0000000081484719, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C ] = { 0x11ca, { "G3M178C ", 0x0000000081484649, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_USB2 ] = { 0x11cb, { "G3M178C(USB2.0) ", 0x0000000081484709, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPB ] = { 0x11c8, { "U3CMOS16000KPB ", 0x0000000081002049, 3, 5, 5, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3840, 2160},{2304, 1750},{1920, 1080},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPB_USB2 ] = { 0x11c9, { "U3CMOS16000KPB(USB2.0) ", 0x0000000081002109, 3, 5, 5, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3840, 2160},{2304, 1750},{1920, 1080},{1536, 1168},}}}, + [TOUPCAM_MODEL_E3ISPM02000KPA ] = { 0x11c0, { "E3ISPM02000KPA ", 0x0000000081041449, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM02000KPA_USB2 ] = { 0x11c1, { "E3ISPM02000KPA(USB2.0) ", 0x0000000081041509, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3CMOS20000KMA ] = { 0x11a0, { "G3CMOS20000KMA ", 0x0000000081492659, 2, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KMA_USB2 ] = { 0x11a1, { "G3CMOS20000KMA(USB2.0) ", 0x0000000081492719, 2, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_U3CCD12000KPA ] = { 0x1090, { "U3CCD12000KPA ", 0x0000001081084042, 1, 2, 0, 0, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_U3CCD12000KPA_USB2 ] = { 0x10a4, { "U3CCD12000KPA(USB2.0) ", 0x0000001081084102, 1, 2, 0, 0, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA ] = { 0x106d, { "ATR3CMOS16000KMA ", 0x00000000816b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2 ] = { 0x1076, { "ATR3CMOS16000KMA(USB2.0) ", 0x00000000816b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA ] = { 0x11a2, { "G3CMOS20000KPA ", 0x0000000081492649, 2, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA_USB2 ] = { 0x11a3, { "G3CMOS20000KPA(USB2.0) ", 0x0000000081492709, 2, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPA ] = { 0x11c2, { "G3CMOS02300KPA ", 0x0000000081492249, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPA_USB2 ] = { 0x11c3, { "G3CMOS02300KPA(USB2.0) ", 0x0000000081492309, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_I3ISPM12000KPA ] = { 0x11c4, { "I3ISPM12000KPA ", 0x00000000810c2041, 3, 4, 4, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},{2000, 1500},{1280, 1000},}}}, + [TOUPCAM_MODEL_I3ISPM12000KPA_USB2 ] = { 0x11c5, { "I3ISPM12000KPA(USB2.0) ", 0x00000000810c2101, 3, 4, 4, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},{2000, 1500},{1280, 1000},}}}, + [TOUPCAM_MODEL_U3CCD09000KPA ] = { 0x108c, { "U3CCD09000KPA ", 0x0000001081084042, 1, 2, 0, 0, 0, 3.690000, 3.690000, {{3388, 2712},{1694, 1356},}}}, + [TOUPCAM_MODEL_U3CCD09000KPA_USB2 ] = { 0x10a0, { "U3CCD09000KPA(USB2.0) ", 0x0000001081084102, 1, 2, 0, 0, 0, 3.690000, 3.690000, {{3388, 2712},{1694, 1356},}}}, + [TOUPCAM_MODEL_G3CMOS02300KMC ] = { 0x119c, { "G3CMOS02300KMC ", 0x0000001081492259, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_G3CMOS02300KMC_USB2 ] = { 0x119d, { "G3CMOS02300KMC(USB2.0) ", 0x0000001081492319, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_E3ISPM12300KPA ] = { 0x118a, { "E3ISPM12300KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 3000},{2048, 1500},}}}, + [TOUPCAM_MODEL_E3ISPM12300KPA_USB2 ] = { 0x118b, { "E3ISPM12300KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 3000},{2048, 1500},}}}, + [TOUPCAM_MODEL_ECMOS06600KPA ] = { 0x117d, { "ECMOS06600KPA ", 0x0000000081000009, 2, 4, 4, 0, 0, 1.620000, 1.620000, {{3072, 2160},{2592, 1944},{3072, 1728},{2160, 2160},}}}, + [TOUPCAM_MODEL_ECMOS08300KPA ] = { 0x117c, { "ECMOS08300KPA ", 0x0000000081000009, 2, 2, 2, 0, 0, 1.620000, 1.620000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_UA1000CA ] = { 0x1237, { "UA1000CA ", 0x0000000081000029, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3664, 2748},{1832, 1374},{912, 686},}}}, + [TOUPCAM_MODEL_UA1000CA_2 ] = { 0x1188, { "UA1000CA ", 0x0000000081000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2748},{1792, 1374},{896, 684},}}}, + [TOUPCAM_MODEL_UA510CA ] = { 0x1236, { "UA510CA ", 0x0000000081000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UA510CA_2 ] = { 0x1187, { "UA510CA ", 0x0000000081000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UA310CA ] = { 0x1235, { "UA310CA ", 0x0000000081000009, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_UA310CA_2 ] = { 0x1186, { "UA310CA ", 0x0000000081000009, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPA ] = { 0x116c, { "E3ISPM08300KPA ", 0x0000000081042049, 2, 2, 2, 0, 0, 1.620000, 1.620000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPA_USB2 ] = { 0x116d, { "E3ISPM08300KPA(USB2.0) ", 0x0000000081042109, 2, 2, 2, 0, 0, 1.620000, 1.620000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA ] = { 0x1184, { "G3CMOS16000KMA ", 0x0000000081692259, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA_USB2 ] = { 0x1185, { "G3CMOS16000KMA(USB2.0) ", 0x0000000081692319, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA ] = { 0x1182, { "G3CMOS16000KPA ", 0x0000000081692249, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA_USB2 ] = { 0x1183, { "G3CMOS16000KPA(USB2.0) ", 0x0000000081692309, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3M287M ] = { 0x1178, { "G3M287M ", 0x0000001081482659, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_G3M287M_USB2 ] = { 0x1179, { "G3M287M(USB2.0) ", 0x0000001081482719, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_G3M385C ] = { 0x117a, { "G3M385C ", 0x0000000085482649, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M385C_USB2 ] = { 0x117b, { "G3M385C(USB2.0) ", 0x0000000085482709, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_EP3CMOS00400KMA ] = { 0x117e, { "EP3CMOS00400KMA ", 0x0000001081482459, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_EP3CMOS00400KMA_USB2 ] = { 0x117f, { "EP3CMOS00400KMA(USB2.0) ", 0x0000001081482519, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_EP3CMOS00400KPA ] = { 0x1180, { "EP3CMOS00400KPA ", 0x0000001081482449, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_EP3CMOS00400KPA_USB2 ] = { 0x1181, { "EP3CMOS00400KPA(USB2.0) ", 0x0000001081482509, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS00400KMA ] = { 0x116e, { "E3CMOS00400KMA ", 0x0000001081002459, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS00400KMA_USB2 ] = { 0x116f, { "E3CMOS00400KMA(USB2.0) ", 0x0000001081002519, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS00400KPA ] = { 0x1170, { "E3CMOS00400KPA ", 0x0000001081002449, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS00400KPA_USB2 ] = { 0x1171, { "E3CMOS00400KPA(USB2.0) ", 0x0000001081002509, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_G3M290C ] = { 0x115e, { "G3M290C ", 0x0000000085482649, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M290C_USB2 ] = { 0x115f, { "G3M290C(USB2.0) ", 0x0000000085482709, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M290M ] = { 0x1160, { "G3M290M ", 0x0000000085482659, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M290M_USB2 ] = { 0x1161, { "G3M290M(USB2.0) ", 0x0000000085482719, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M224C ] = { 0x1162, { "G3M224C ", 0x0000000085482669, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3M224C_USB2 ] = { 0x1163, { "G3M224C(USB2.0) ", 0x0000000085482729, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3ISPM16000KPB ] = { 0x113e, { "U3ISPM16000KPB ", 0x0000000081041049, 3, 4, 4, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3360, 2526},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3ISPM16000KPB_USB2 ] = { 0x113f, { "U3ISPM16000KPB(USB2.0) ", 0x0000000081041109, 3, 4, 4, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3360, 2526},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_E3CMOS05000KMA ] = { 0x1172, { "E3CMOS05000KMA ", 0x0000001081002459, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS05000KMA_USB2 ] = { 0x1173, { "E3CMOS05000KMA(USB2.0) ", 0x0000001081002519, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS03100KMC ] = { 0x1174, { "E3CMOS03100KMC ", 0x0000001081002459, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3CMOS03100KMC_USB2 ] = { 0x1175, { "E3CMOS03100KMC(USB2.0) ", 0x0000001081002519, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3ISPM09000KPA ] = { 0x116a, { "E3ISPM09000KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 2160},{2048, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM09000KPA_USB2 ] = { 0x116b, { "E3ISPM09000KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 2160},{2048, 1080},}}}, + [TOUPCAM_MODEL_I3CMOS01200KPA ] = { 0x10c1, { "I3CMOS01200KPA ", 0x0000000081002069, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_I3CMOS01200KPA_USB2 ] = { 0x10ce, { "I3CMOS01200KPA(USB2.0) ", 0x0000000081002129, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3ISPM16000KPA ] = { 0x113c, { "U3ISPM16000KPA ", 0x0000000081042041, 2, 3, 3, 0, 0, 1.335000, 1.335000, {{4632, 3488},{2320, 1740},{1536, 1160},}}}, + [TOUPCAM_MODEL_U3ISPM16000KPA_USB2 ] = { 0x113d, { "U3ISPM16000KPA(USB2.0) ", 0x0000000081042101, 2, 3, 3, 0, 0, 1.335000, 1.335000, {{4632, 3488},{2320, 1740},{1536, 1160},}}}, + [TOUPCAM_MODEL_U3CMOS16000KMB ] = { 0x1168, { "U3CMOS16000KMB ", 0x0000000081002059, 3, 5, 5, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3840, 2160},{2304, 1750},{1920, 1080},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3CMOS16000KMB_USB2 ] = { 0x1169, { "U3CMOS16000KMB(USB2.0) ", 0x0000000081002119, 3, 5, 5, 0, 0, 3.800000, 3.800000, {{4640, 3506},{3840, 2160},{2304, 1750},{1920, 1080},{1536, 1168},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPC ] = { 0x1009, { "G3CMOS02300KPC ", 0x0000001081492249, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPC_USB2 ] = { 0x100e, { "G3CMOS02300KPC(USB2.0) ", 0x0000001081492309, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_G3M178M_2 ] = { 0x115c, { "G3M178M ", 0x0000000081484259, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178M_USB2_2 ] = { 0x115d, { "G3M178M(USB2.0) ", 0x0000000081484319, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_2 ] = { 0x115a, { "G3M178C ", 0x0000000081484249, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_USB2_2 ] = { 0x115b, { "G3M178C(USB2.0) ", 0x0000000081484309, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM03100KPA ] = { 0x1138, { "E3ISPM03100KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3ISPM03100KPA_USB2 ] = { 0x1139, { "E3ISPM03100KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3ISPM05000KPA ] = { 0x114c, { "E3ISPM05000KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM05000KPA_USB2 ] = { 0x114d, { "E3ISPM05000KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_MG3CMOS16000KPA ] = { 0x1158, { "MG3CMOS16000KPA ", 0x0000000081012041, 2, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_MG3CMOS16000KPA_USB2 ] = { 0x1159, { "MG3CMOS16000KPA(USB2.0) ", 0x0000000081012101, 2, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_MG3CMOS02300KPA ] = { 0x1156, { "MG3CMOS02300KPA ", 0x0000000081012041, 2, 2, 2, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_MG3CMOS02300KPA_USB2 ] = { 0x1157, { "MG3CMOS02300KPA(USB2.0) ", 0x0000000081012101, 2, 2, 2, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_U3ISPM18000KPA ] = { 0x1142, { "U3ISPM18000KPA ", 0x0000000081042469, 3, 3, 3, 0, 0, 1.250000, 1.250000, {{4912, 3684},{2456, 1842},{1228, 922},}}}, + [TOUPCAM_MODEL_U3ISPM18000KPA_USB2 ] = { 0x1143, { "U3ISPM18000KPA(USB2.0) ", 0x0000000081042529, 3, 3, 3, 0, 0, 1.250000, 1.250000, {{4912, 3684},{2456, 1842},{1228, 922},}}}, + [TOUPCAM_MODEL_E3ISPM03100KPB ] = { 0x113a, { "E3ISPM03100KPB ", 0x0000000081042049, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM03100KPB_USB2 ] = { 0x113b, { "E3ISPM03100KPB(USB2.0) ", 0x0000000081042109, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KPC ] = { 0x1154, { "EP3CMOS02300KPC ", 0x0000001081082049, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KPC_USB2 ] = { 0x1155, { "EP3CMOS02300KPC(USB2.0) ", 0x0000001081082109, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KMC ] = { 0x1152, { "EP3CMOS02300KMC ", 0x0000001081082059, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KMC_USB2 ] = { 0x1153, { "EP3CMOS02300KMC(USB2.0) ", 0x0000001081082119, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_EP3CMOS06300KMA ] = { 0x1150, { "EP3CMOS06300KMA ", 0x0000000081084051, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_EP3CMOS06300KMA_USB2 ] = { 0x1151, { "EP3CMOS06300KMA(USB2.0) ", 0x0000000081084111, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_EP3CMOS20000KPA ] = { 0x114e, { "EP3CMOS20000KPA ", 0x0000000081492241, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_EP3CMOS20000KPA_USB2 ] = { 0x114f, { "EP3CMOS20000KPA(USB2.0) ", 0x0000000081492301, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_GPCMOS02000KMA ] = { 0x10ff, { "GPCMOS02000KMA ", 0x0000000085482219, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_EXCCD01400KPA ] = { 0x814d, { "EXCCD01400KPA ", 0x0000001080082002, 3, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS03100KPA ] = { 0x10c7, { "I3CMOS03100KPA ", 0x0000001081004041, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_I3CMOS03100KPA_USB2 ] = { 0x10d4, { "I3CMOS03100KPA(USB2.0) ", 0x0000001081004101, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_U3CMOS10000KMA ] = { 0x1148, { "U3CMOS10000KMA ", 0x0000000081000071, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_U3CMOS10000KMA_USB2 ] = { 0x1149, { "U3CMOS10000KMA(USB2.0) ", 0x0000000081000131, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_E3ISPM12000KPA ] = { 0x1134, { "E3ISPM12000KPA ", 0x0000000081042041, 3, 2, 2, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM12000KPA_USB2 ] = { 0x1135, { "E3ISPM12000KPA(USB2.0) ", 0x0000000081042101, 3, 2, 2, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM05000KPA_2 ] = { 0x111c, { "E3ISPM05000KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1216, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM05000KPA_USB2_2 ] = { 0x111d, { "E3ISPM05000KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1216, 1024},}}}, + [TOUPCAM_MODEL_AF3CMOS06300KPA ] = { 0x1146, { "AF3CMOS06300KPA ", 0x00000420930c2049, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3080, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_AF3CMOS06300KPA_USB2 ] = { 0x1147, { "AF3CMOS06300KPA(USB2.0) ", 0x00000420930c2109, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3080, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM20000KPA ] = { 0x1122, { "E3ISPM20000KPA ", 0x0000000081042041, 2, 3, 3, 0, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_E3ISPM20000KPA_USB2 ] = { 0x1123, { "E3ISPM20000KPA(USB2.0) ", 0x0000000081042101, 2, 3, 3, 0, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA_2 ] = { 0x1112, { "G3CMOS20000KPA ", 0x0000000081492241, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA_USB2_2 ] = { 0x1113, { "G3CMOS20000KPA(USB2.0) ", 0x0000000081492301, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_E3CMOS02300KMC ] = { 0x1144, { "E3CMOS02300KMC ", 0x0000001081002059, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_E3CMOS02300KMC_USB2 ] = { 0x1145, { "E3CMOS02300KMC(USB2.0) ", 0x0000001081002119, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_ATR3CMOS02300KMB ] = { 0x1071, { "ATR3CMOS02300KMB ", 0x00000010814b26d9, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_ATR3CMOS02300KMB_USB2 ] = { 0x107a, { "ATR3CMOS02300KMB(USB2.0) ", 0x00000010814b2799, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_E3CMOS20000KPA ] = { 0x1110, { "E3CMOS20000KPA ", 0x0000000081002041, 2, 3, 3, 0, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_E3CMOS20000KPA_USB2 ] = { 0x1111, { "E3CMOS20000KPA(USB2.0) ", 0x0000000081002101, 2, 3, 3, 0, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA ] = { 0x1063, { "MTR3CMOS16000KPA ", 0x00000000810b24c9, 2, 3, 0, 1, 0, 3.800000, 3.800000, {{4632, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2 ] = { 0x1067, { "MTR3CMOS16000KPA(USB2.0) ", 0x00000000810b2589, 2, 3, 0, 1, 0, 3.800000, 3.800000, {{4632, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KMA ] = { 0x1064, { "MTR3CMOS16000KMA ", 0x00000000810b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4632, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KMA_USB2 ] = { 0x1068, { "MTR3CMOS16000KMA(USB2.0) ", 0x00000000810b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4632, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_ECMOS05300KPA ] = { 0x1108, { "ECMOS05300KPA ", 0x0000000080000009, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 1728},{1280, 720},}}}, + [TOUPCAM_MODEL_ECMOS03100KPA ] = { 0x1107, { "ECMOS03100KPA ", 0x0000000080000009, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM06300KPA ] = { 0x111a, { "E3ISPM06300KPA ", 0x0000000081042049, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM06300KPA_USB2 ] = { 0x111b, { "E3ISPM06300KPA(USB2.0) ", 0x0000000081042109, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_ECMOS01200KPA ] = { 0x110f, { "ECMOS01200KPA ", 0x0000000081000029, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS01200KPA ] = { 0x110d, { "E3CMOS01200KPA ", 0x0000000081002069, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS01200KPA_USB2 ] = { 0x110e, { "E3CMOS01200KPA(USB2.0) ", 0x0000000081002129, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA_2 ] = { 0x1104, { "G3CMOS16000KMA ", 0x0000000081492251, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA_USB2_2 ] = { 0x1105, { "G3CMOS16000KMA(USB2.0) ", 0x0000000081492311, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_ATR3CMOS02300KPB ] = { 0x1070, { "ATR3CMOS02300KPB ", 0x00000010814b26c9, 3, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_ATR3CMOS02300KPB_USB2 ] = { 0x1079, { "ATR3CMOS02300KPB(USB2.0) ", 0x00000010814b2789, 3, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_ATR3CMOS06300KPA ] = { 0x1072, { "ATR3CMOS06300KPA ", 0x00000000814b44c9, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_ATR3CMOS06300KPA_USB2 ] = { 0x107b, { "ATR3CMOS06300KPA(USB2.0) ", 0x00000000814b4589, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA ] = { 0x106b, { "ATR3CMOS16000KPA ", 0x00000000816b24c9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2 ] = { 0x1075, { "ATR3CMOS16000KPA(USB2.0) ", 0x00000000816b2589, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA_2 ] = { 0x1102, { "G3CMOS16000KPA ", 0x0000000081492241, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA_USB2_2 ] = { 0x1103, { "G3CMOS16000KPA(USB2.0) ", 0x0000000081492301, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_ECMOS02000KPA ] = { 0x1106, { "ECMOS02000KPA ", 0x0000000080000009, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_EP3CMOS06300KPA ] = { 0x1100, { "EP3CMOS06300KPA ", 0x0000000081084041, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_EP3CMOS06300KPA_USB2 ] = { 0x1101, { "EP3CMOS06300KPA(USB2.0) ", 0x0000000081084101, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS05000KMA_2 ] = { 0x10a9, { "E3CMOS05000KMA ", 0x0000001081002479, 4, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS05000KMA_USB2_2 ] = { 0x10ab, { "E3CMOS05000KMA(USB2.0) ", 0x0000001081002539, 4, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS05000KPA ] = { 0x10a8, { "E3CMOS05000KPA ", 0x0000001081002449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS05000KPA_USB2 ] = { 0x10aa, { "E3CMOS05000KPA(USB2.0) ", 0x0000001081002509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_GPCMOS02000KPA ] = { 0x10fe, { "GPCMOS02000KPA ", 0x0000000085482209, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_EXCCD00440KPB ] = { 0x805a, { "EXCCD00440KPB ", 0x0000001300080004, 3, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 576},}}}, + [TOUPCAM_MODEL_GPCMOS01200KMA ] = { 0x1002, { "GPCMOS01200KMA ", 0x0000000080682219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_EXCCD00300KPA ] = { 0x830a, { "EXCCD00300KPA ", 0x0000001080082002, 3, 1, 0, 0, 0, 5.600000, 5.600000, {{640, 480},}}}, + [TOUPCAM_MODEL_U3CMOS16000KMB_2 ] = { 0x107d, { "U3CMOS16000KMB ", 0x0000000081001051, 2, 3, 3, 0, 0, 3.800000, 3.800000, {{4648, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3CMOS16000KMB_USB2_2 ] = { 0x107f, { "U3CMOS16000KMB(USB2.0) ", 0x0000000081001111, 2, 3, 3, 0, 0, 3.800000, 3.800000, {{4648, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3CCD01400KPB ] = { 0x1082, { "U3CCD01400KPB ", 0x0000001081084042, 2, 1, 0, 0, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_U3CCD01400KPB_USB2 ] = { 0x1096, { "U3CCD01400KPB(USB2.0) ", 0x0000001081084102, 2, 1, 0, 0, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_U3CCD01400KMB ] = { 0x1083, { "U3CCD01400KMB ", 0x0000001081084052, 2, 1, 0, 0, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_U3CCD01400KMB_USB2 ] = { 0x1097, { "U3CCD01400KMB(USB2.0) ", 0x0000001081084112, 2, 1, 0, 0, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_G3CMOS06300KMA ] = { 0x10f6, { "G3CMOS06300KMA ", 0x0000000081494259, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3CMOS06300KMA_USB2 ] = { 0x10f7, { "G3CMOS06300KMA(USB2.0) ", 0x0000000081494319, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KMB ] = { 0x101c, { "MTR3CCD01400KMB ", 0x00000010811b44d2, 2, 1, 0, 4, 2, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KMB_USB2 ] = { 0x1030, { "MTR3CCD01400KMB(USB2.0) ", 0x00000010811b4592, 2, 1, 0, 4, 2, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPB_2 ] = { 0x101b, { "MTR3CCD01400KPB ", 0x00000010811b44c2, 2, 1, 0, 4, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPB_USB2_2] = { 0x102f, { "MTR3CCD01400KPB(USB2.0) ", 0x00000010811b4582, 2, 1, 0, 4, 0, 6.450000, 6.450000, {{1376, 1040},}}}, + [TOUPCAM_MODEL_GPCMOS01200KMB ] = { 0x1004, { "GPCMOS01200KMB ", 0x0000000080682219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPB_2 ] = { 0x107c, { "U3CMOS16000KPB ", 0x0000000081001041, 2, 3, 3, 0, 0, 3.800000, 3.800000, {{4648, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPB_USB2_2 ] = { 0x107e, { "U3CMOS16000KPB(USB2.0) ", 0x0000000081001101, 2, 3, 3, 0, 0, 3.800000, 3.800000, {{4648, 3506},{2304, 1750},{1536, 1168},}}}, + [TOUPCAM_MODEL_GPCMOS01200KPB ] = { 0x1003, { "GPCMOS01200KPB ", 0x0000000080682209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3CMOS01200KPA ] = { 0x1007, { "G3CMOS01200KPA ", 0x0000000085492269, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3CMOS01200KPA_USB2 ] = { 0x100c, { "G3CMOS01200KPA(USB2.0) ", 0x0000000085492329, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3CMOS06300KPA ] = { 0x100b, { "G3CMOS06300KPA ", 0x0000000081494249, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3CMOS06300KPA_USB2 ] = { 0x1010, { "G3CMOS06300KPA(USB2.0) ", 0x0000000081494309, 2, 2, 0, 1, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS06300KMA ] = { 0x10f8, { "E3CMOS06300KMA ", 0x0000000081004051, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS06300KMA_USB2 ] = { 0x10f9, { "E3CMOS06300KMA(USB2.0) ", 0x0000000081004111, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_X05100KPA ] = { 0x0a51, { "X05100KPA ", 0x0000000080000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_X01200KPA ] = { 0x0a12, { "X01200KPA ", 0x0000000080000209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_GPCMOS01200KPC ] = { 0x1005, { "GPCMOS01200KPC ", 0x0000000084482229, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_ATR3CCD06000KPA ] = { 0x1039, { "ATR3CCD06000KPA ", 0x00000010815b44c2, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_ATR3CCD06000KPA_USB2 ] = { 0x104d, { "ATR3CCD06000KPA(USB2.0) ", 0x00000010815b4582, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_ATR3CCD06000KMA ] = { 0x103a, { "ATR3CCD06000KMA ", 0x00000010815b44d2, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_ATR3CCD06000KMA_USB2 ] = { 0x104e, { "ATR3CCD06000KMA(USB2.0) ", 0x00000010815b4592, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD02800KMA ] = { 0x1016, { "MTR3CCD02800KMA ", 0x00000010811b44d2, 1, 3, 0, 4, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD02800KMA_USB2 ] = { 0x102a, { "MTR3CCD02800KMA(USB2.0) ", 0x00000010811b4592, 1, 3, 0, 4, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD02800KPA ] = { 0x1015, { "MTR3CCD02800KPA ", 0x00000010811b44c2, 1, 3, 0, 4, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD02800KPA_USB2 ] = { 0x1029, { "MTR3CCD02800KPA(USB2.0) ", 0x00000010811b4582, 1, 3, 0, 4, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_U3CCD06000KMA ] = { 0x1089, { "U3CCD06000KMA ", 0x0000001081084052, 1, 2, 0, 0, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_U3CCD06000KMA_USB2 ] = { 0x109d, { "U3CCD06000KMA(USB2.0) ", 0x0000001081084112, 1, 2, 0, 0, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KMA ] = { 0x101a, { "MTR3CCD01400KMA ", 0x00000010811b44d2, 1, 1, 0, 4, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KMA_USB2 ] = { 0x102e, { "MTR3CCD01400KMA(USB2.0) ", 0x00000010811b4592, 1, 1, 0, 4, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_G3CMOS02300KMC_2 ] = { 0x100a, { "G3CMOS02300KMC ", 0x0000001081492259, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_G3CMOS02300KMC_USB2_2 ] = { 0x100f, { "G3CMOS02300KMC(USB2.0) ", 0x0000001081492319, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_MTR3CCD06000KMA ] = { 0x1012, { "MTR3CCD06000KMA ", 0x00000010811b44d2, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD06000KMA_USB2 ] = { 0x1026, { "MTR3CCD06000KMA(USB2.0) ", 0x00000010811b4592, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_U3CCD02800KMA ] = { 0x1085, { "U3CCD02800KMA ", 0x0000001081084052, 1, 3, 0, 0, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_U3CCD02800KMA_USB2 ] = { 0x1099, { "U3CCD02800KMA(USB2.0) ", 0x0000001081084112, 1, 3, 0, 0, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_GCMOS01200KMA ] = { 0xb135, { "GCMOS01200KMA ", 0x0000000080682219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_GCMOS01200KMB ] = { 0xb134, { "GCMOS01200KMB ", 0x0000000080682219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPB ] = { 0x1008, { "G3CMOS02300KPB ", 0x0000001081492241, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPB_USB2 ] = { 0x100d, { "G3CMOS02300KPB(USB2.0) ", 0x0000001081492301, 2, 1, 0, 1, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_GCMOS01200KPB ] = { 0xb133, { "GCMOS01200KPB ", 0x0000000080682209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3CCD02800KPA ] = { 0x4004, { "U3CCD02800KPA ", 0x0000001081084042, 1, 3, 0, 0, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_U3CCD02800KPA_USB2 ] = { 0x4005, { "U3CCD02800KPA(USB2.0) ", 0x0000001081084102, 1, 3, 0, 0, 0, 4.540000, 4.540000, {{1938, 1460},{1610, 1212},{1930, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPA ] = { 0x4020, { "MTR3CCD01400KPA ", 0x00000010811b44c2, 1, 1, 0, 4, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_MTR3CCD01400KPA_USB2 ] = { 0x4021, { "MTR3CCD01400KPA(USB2.0) ", 0x00000010811b4582, 1, 1, 0, 4, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPA ] = { 0x3016, { "U3CMOS16000KPA ", 0x0000000081002041, 2, 3, 3, 0, 0, 1.335000, 1.335000, {{4632, 3488},{2320, 1740},{1536, 1160},}}}, + [TOUPCAM_MODEL_U3CMOS16000KPA_USB2 ] = { 0x4016, { "U3CMOS16000KPA(USB2.0) ", 0x0000000081002101, 2, 3, 3, 0, 0, 1.335000, 1.335000, {{4632, 3488},{2320, 1740},{1536, 1160},}}}, + [TOUPCAM_MODEL_U3CCD06000KPA ] = { 0x2106, { "U3CCD06000KPA ", 0x0000001081084042, 1, 2, 0, 0, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_U3CCD06000KPA_USB2 ] = { 0x2107, { "U3CCD06000KPA(USB2.0) ", 0x0000001081084102, 1, 2, 0, 0, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_EXCCD00300KMA ] = { 0x8309, { "EXCCD00300KMA ", 0x0000001080082012, 3, 1, 0, 0, 0, 5.600000, 5.600000, {{640, 480},}}}, + [TOUPCAM_MODEL_EXCCD00300KMA_2 ] = { 0x8307, { "EXCCD00300KMA ", 0x0000001080080012, 1, 1, 0, 0, 0, 5.600000, 5.600000, {{640, 480},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KPA ] = { 0x400c, { "EP3CMOS02300KPA ", 0x0000000081082041, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_EP3CMOS02300KPA_USB2 ] = { 0x400d, { "EP3CMOS02300KPA(USB2.0) ", 0x0000000081082101, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_EXCCD00440KPA ] = { 0x804b, { "EXCCD00440KPA ", 0x0000001100080004, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 576},}}}, + [TOUPCAM_MODEL_EXCCD00440KMB ] = { 0x804c, { "EXCCD00440KMB ", 0x0000001080080014, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 578},}}}, + [TOUPCAM_MODEL_EXCCD00440KMA ] = { 0x804d, { "EXCCD00440KMA ", 0x0000001080080014, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 578},}}}, + [TOUPCAM_MODEL_MTR3CCD06000KPA ] = { 0x400a, { "MTR3CCD06000KPA ", 0x00000010811b44c2, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_MTR3CCD06000KPA_USB2 ] = { 0x400b, { "MTR3CCD06000KPA(USB2.0) ", 0x00000010811b4582, 1, 2, 0, 4, 0, 4.540000, 4.540000, {{2748, 2200},{2748, 1092},}}}, + [TOUPCAM_MODEL_EXCCD00440KPB_2 ] = { 0x804a, { "EXCCD00440KPB ", 0x0000001100080004, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 576},}}}, + [TOUPCAM_MODEL_ICMOS03100KPA ] = { 0xa312, { "ICMOS03100KPA ", 0x0000000080380009, 5, 3, 0, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_E3CMOS12000KPA ] = { 0x4002, { "E3CMOS12000KPA ", 0x0000000081002041, 2, 2, 2, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},}}}, + [TOUPCAM_MODEL_E3CMOS12000KPA_USB2 ] = { 0x4003, { "E3CMOS12000KPA(USB2.0) ", 0x0000000081002101, 2, 2, 2, 0, 0, 1.850000, 1.850000, {{4000, 3000},{2048, 1080},}}}, + [TOUPCAM_MODEL_E3CMOS03100KPB ] = { 0x4008, { "E3CMOS03100KPB ", 0x0000000081004041, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3CMOS03100KPB_USB2 ] = { 0x4009, { "E3CMOS03100KPB(USB2.0) ", 0x0000000081004101, 2, 2, 0, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1920, 1080},}}}, + [TOUPCAM_MODEL_UCMOS05100KPC ] = { 0x6518, { "UCMOS05100KPC ", 0x0000000080000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS02300KPB ] = { 0x4006, { "E3CMOS02300KPB ", 0x0000001081002041, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_E3CMOS02300KPB_USB2 ] = { 0x4007, { "E3CMOS02300KPB(USB2.0) ", 0x0000001081002101, 2, 1, 0, 0, 0, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_UHCCD05200KMA ] = { 0x8527, { "UHCCD05200KMA ", 0x0000001080000012, 1, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2040},{816, 680},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPA_2 ] = { 0xe317, { "G3CMOS02300KPA ", 0x0000000081492241, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_G3CMOS02300KPA_USB2_2 ] = { 0xe217, { "G3CMOS02300KPA(USB2.0) ", 0x0000000081492301, 2, 2, 0, 1, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_GCMOS01200KMA_2 ] = { 0xb121, { "GCMOS01200KMA ", 0x0000000080402219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS06300KPA ] = { 0x4000, { "E3CMOS06300KPA ", 0x0000000081004041, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_E3CMOS06300KPA_USB2 ] = { 0x4001, { "E3CMOS06300KPA(USB2.0) ", 0x0000000081004101, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_ICMOS14000KPC ] = { 0xfc15, { "ICMOS14000KPC ", 0x0000000081000001, 1, 8, 0, 0, 0, 1.400000, 1.400000, {{1280, 720},{1280, 720},{1100, 800},{1100, 800},{1100, 800},{1024, 768},{1024, 768},{1024, 768},}}}, + [TOUPCAM_MODEL_EXCCD00300KMA_2_2 ] = { 0x8306, { "EXCCD00300KMA ", 0x0000001080000012, 1, 1, 0, 0, 0, 5.600000, 5.600000, {{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS02300KPA ] = { 0x3723, { "E3CMOS02300KPA ", 0x0000000081002041, 2, 2, 2, 0, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_E3CMOS02300KPA_USB2 ] = { 0x4723, { "E3CMOS02300KPA(USB2.0) ", 0x0000000081002101, 2, 2, 2, 0, 0, 3.750000, 3.750000, {{1920, 1200},{960, 600},}}}, + [TOUPCAM_MODEL_E3CMOS03100KPA ] = { 0x3731, { "E3CMOS03100KPA ", 0x0000000081002041, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3CMOS03100KPA_USB2 ] = { 0x4731, { "E3CMOS03100KPA(USB2.0) ", 0x0000000081002101, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_EXCCD00440KMB_2 ] = { 0x8047, { "EXCCD00440KMB ", 0x0000001080000014, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 578},}}}, + [TOUPCAM_MODEL_EXCCD00440KPB_2_2 ] = { 0x8046, { "EXCCD00440KPB ", 0x0000001100000004, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 576},}}}, + [TOUPCAM_MODEL_EXCCD00440KMA_2 ] = { 0x8045, { "EXCCD00440KMA ", 0x0000001080000014, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 578},}}}, + [TOUPCAM_MODEL_AAICX429C ] = { 0x8044, { "AAICX429C ", 0x0000001080000004, 1, 1, 0, 0, 0, 8.600000, 8.300000, {{748, 578},}}}, + [TOUPCAM_MODEL_U3CMOS18000KPA ] = { 0x3018, { "U3CMOS18000KPA ", 0x0000000081000461, 3, 3, 3, 0, 0, 1.250000, 1.250000, {{4912, 3684},{2456, 1842},{1228, 922},}}}, + [TOUPCAM_MODEL_U3CMOS18000KPA_USB2 ] = { 0x4018, { "U3CMOS18000KPA(USB2.0) ", 0x0000000081000521, 3, 3, 3, 0, 0, 1.250000, 1.250000, {{4912, 3684},{2456, 1842},{1228, 922},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPC ] = { 0x3314, { "U3CMOS03100KPC ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPC_USB2 ] = { 0x4314, { "U3CMOS03100KPC(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_L3CMOS03100KPB ] = { 0xc312, { "L3CMOS03100KPB ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_L3CMOS03100KPB_USB2 ] = { 0xd312, { "L3CMOS03100KPB(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_GCMOS03100KPA ] = { 0xb310, { "GCMOS03100KPA ", 0x0000000080400201, 2, 2, 0, 0, 0, 2.200000, 2.200000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_UHCCD05200KPA ] = { 0x8526, { "UHCCD05200KPA ", 0x0000001080000002, 1, 2, 2, 0, 0, 3.450000, 3.450000, {{2448, 2040},{816, 680},}}}, + [TOUPCAM_MODEL_UHCCD05000KPA ] = { 0x8506, { "UHCCD05000KPA ", 0x0000001080000004, 1, 2, 1, 0, 0, 3.400000, 3.400000, {{2560, 1920},{1280, 960},}}}, + [TOUPCAM_MODEL_UHCCD03100KPB ] = { 0x8316, { "UHCCD03100KPB ", 0x0000001080000004, 1, 2, 1, 0, 0, 3.450000, 3.450000, {{2048, 1536},{640, 480},}}}, + [TOUPCAM_MODEL_UHCCD02000KPA ] = { 0x8206, { "UHCCD02000KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.400000, 4.400000, {{1600, 1200},}}}, + [TOUPCAM_MODEL_UHCCD01400KPB ] = { 0x8148, { "UHCCD01400KPB ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD01400KMB ] = { 0x8149, { "UHCCD01400KMB ", 0x0000001080000012, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_EXCCD01400KPA_2 ] = { 0x814e, { "EXCCD01400KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_EXCCD01400KMA ] = { 0x814f, { "EXCCD01400KMA ", 0x0000001080000012, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_ICMOS10000KPA ] = { 0xa010, { "ICMOS10000KPA ", 0x0000000080000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2748},{1792, 1374},{896, 684},}}}, + [TOUPCAM_MODEL_ICMOS14000KPA ] = { 0xa014, { "ICMOS14000KPA ", 0x0000000080000021, 5, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3288},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_LCMOS03100KPB ] = { 0xf312, { "LCMOS03100KPB ", 0x0000000081000001, 2, 3, 3, 0, 0, 2.500000, 2.500000, {{2048, 1536},{1024, 768},{684, 512},}}}, + [TOUPCAM_MODEL_UCMOS02000KPC ] = { 0x5002, { "UCMOS02000KPC ", 0x0000000080000001, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{1600, 1200},{800, 600},{400, 300},}}}, + [TOUPCAM_MODEL_WCMOS10000KPA ] = { 0x6b10, { "WCMOS10000KPA ", 0x0000000080000021, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2748},{1792, 1374},{896, 684},}}}, + [TOUPCAM_MODEL_UCMOS03100KPB ] = { 0x5003, { "UCMOS03100KPB ", 0x0000000080000001, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{512, 384},}}}, + [TOUPCAM_MODEL_GCMOS01200KMB_2 ] = { 0xb124, { "GCMOS01200KMB ", 0x0000000080402219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_GCMOS01200KPB_2 ] = { 0xb123, { "GCMOS01200KPB ", 0x0000000080402209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_GCMOS01200KPB_2_2 ] = { 0xb122, { "GCMOS01200KPB ", 0x0000000080400209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UCMOS01200KPB ] = { 0x6122, { "UCMOS01200KPB ", 0x0000000080000001, 4, 2, 2, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3CMOS14000KPB ] = { 0x3bb4, { "U3CMOS14000KPB ", 0x0000000081000061, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_U3CMOS14000KPB_USB2 ] = { 0x4bb4, { "U3CMOS14000KPB(USB2.0) ", 0x0000000081000121, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_LCMOS01200KPB ] = { 0xf132, { "LCMOS01200KPB ", 0x0000000080000001, 5, 2, 2, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_LCMOS14000KPA ] = { 0xf014, { "LCMOS14000KPA ", 0x0000000081000021, 5, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3288},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_LCMOS10000KPA ] = { 0xf010, { "LCMOS10000KPA ", 0x0000000081000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2748},{1792, 1374},{896, 684},}}}, + [TOUPCAM_MODEL_LCMOS09000KPA ] = { 0xf900, { "LCMOS09000KPA ", 0x0000000081000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3488, 2616},{1744, 1308},{872, 654},}}}, + [TOUPCAM_MODEL_LCMOS08000KPA ] = { 0xf800, { "LCMOS08000KPA ", 0x0000000081000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3264, 2448},{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_LCMOS05100KPA ] = { 0xf510, { "LCMOS05100KPA ", 0x0000000081000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_LCMOS03100KPA ] = { 0xf310, { "LCMOS03100KPA ", 0x0000000081000009, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_LCMOS02000KPA ] = { 0xf200, { "LCMOS02000KPA ", 0x0000000080000001, 5, 2, 2, 0, 0, 3.200000, 3.200000, {{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_LCMOS01300KPA ] = { 0xf130, { "LCMOS01300KPA ", 0x0000000080000001, 2, 3, 0, 0, 0, 3.600000, 3.600000, {{1280, 1024},{640, 512},{320, 256},}}}, + [TOUPCAM_MODEL_SCCCD01400KMB ] = { 0x9143, { "SCCCD01400KMB ", 0x0000001080000092, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD05200KPA_2 ] = { 0x8520, { "UHCCD05200KPA ", 0x0000001080000002, 1, 2, 1, 0, 0, 3.450000, 3.450000, {{2448, 2040},{816, 680},}}}, + [TOUPCAM_MODEL_UHCCD05100KPA ] = { 0x8516, { "UHCCD05100KPA ", 0x0000001080000004, 1, 2, 1, 0, 0, 2.775000, 2.775000, {{2592, 1944},{560, 420},}}}, + [TOUPCAM_MODEL_UHCCD05100KPA_2 ] = { 0x8510, { "UHCCD05100KPA ", 0x0000001080000004, 1, 2, 1, 0, 0, 2.775000, 2.775000, {{2592, 1944},{560, 420},}}}, + [TOUPCAM_MODEL_UHCCD05000KPA_2 ] = { 0x8500, { "UHCCD05000KPA ", 0x0000001080000004, 1, 2, 1, 0, 0, 3.400000, 3.400000, {{2560, 1920},{1280, 960},}}}, + [TOUPCAM_MODEL_UHCCD03100KPB_2 ] = { 0x8311, { "UHCCD03100KPB ", 0x0000001080000004, 1, 2, 1, 0, 0, 3.450000, 3.450000, {{2048, 1536},{640, 480},}}}, + [TOUPCAM_MODEL_UHCCD02000KPA_2 ] = { 0x8200, { "UHCCD02000KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.400000, 4.400000, {{1600, 1200},}}}, + [TOUPCAM_MODEL_UHCCD01400KPB_2 ] = { 0x8146, { "UHCCD01400KPB ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD01400KPA ] = { 0x8140, { "UHCCD01400KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD01400KMB_2 ] = { 0x7141, { "UHCCD01400KMB ", 0x0000001080000012, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD01400KMA ] = { 0x7140, { "UHCCD01400KMA ", 0x0000001080000012, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_UHCCD00800KPA ] = { 0x8080, { "UHCCD00800KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1024, 768},}}}, + [TOUPCAM_MODEL_UCMOS05100KMA ] = { 0x6511, { "UCMOS05100KMA ", 0x0000000080000039, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UCMOS14000KPA ] = { 0x6014, { "UCMOS14000KPA ", 0x0000000080000021, 5, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3288},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_UCMOS10000KPA ] = { 0x6010, { "UCMOS10000KPA ", 0x0000000080000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2748},{1792, 1374},{896, 684},}}}, + [TOUPCAM_MODEL_UCMOS09000KPB ] = { 0x6901, { "UCMOS09000KPB ", 0x0000000080000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3488, 2616},{1744, 1308},{872, 654},}}}, + [TOUPCAM_MODEL_UCMOS09000KPA ] = { 0x6900, { "UCMOS09000KPA ", 0x0000000080000021, 6, 3, 3, 0, 0, 1.750000, 1.750000, {{3488, 2616},{1744, 1308},{872, 654},}}}, + [TOUPCAM_MODEL_UCMOS08000KPB ] = { 0x6801, { "UCMOS08000KPB ", 0x0000000080000029, 5, 3, 3, 0, 0, 1.670000, 1.670000, {{3264, 2448},{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_UCMOS08000KPA ] = { 0x6800, { "UCMOS08000KPA ", 0x0000000080000021, 6, 3, 3, 0, 0, 1.750000, 1.750000, {{3264, 2448},{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_UCMOS05100KPA ] = { 0x6510, { "UCMOS05100KPA ", 0x0000000080000029, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UCMOS03100KPA ] = { 0x6310, { "UCMOS03100KPA ", 0x0000000080000009, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_UCMOS02000KPB ] = { 0x6201, { "UCMOS02000KPB ", 0x0000000080000001, 5, 2, 2, 0, 0, 3.200000, 3.200000, {{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_UCMOS02000KPA ] = { 0x6200, { "UCMOS02000KPA ", 0x0000000400000001, 6, 2, 0, 0, 0, 2.800000, 2.800000, {{1600, 1200},{800, 600},}}}, + [TOUPCAM_MODEL_UCMOS01300KPA ] = { 0x6130, { "UCMOS01300KPA ", 0x0000000080000001, 1, 3, 0, 0, 0, 3.600000, 3.600000, {{1280, 1024},{640, 512},{320, 256},}}}, + [TOUPCAM_MODEL_UCMOS01300KMA ] = { 0x6131, { "UCMOS01300KMA ", 0x0000000080000011, 1, 1, 0, 0, 0, 5.200000, 5.200000, {{1280, 1024},}}}, + [TOUPCAM_MODEL_UCMOS00350KPA ] = { 0x6035, { "UCMOS00350KPA ", 0x0000000080000001, 2, 2, 0, 0, 0, 5.600000, 5.600000, {{640, 480},{320, 240},}}}, + [TOUPCAM_MODEL_U3CMOS14000KPA ] = { 0x3014, { "U3CMOS14000KPA ", 0x0000000081000061, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_U3CMOS14000KPA_USB2 ] = { 0x4014, { "U3CMOS14000KPA(USB2.0) ", 0x0000000081000121, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_U3CMOS10000KPA ] = { 0x3010, { "U3CMOS10000KPA ", 0x0000000081000061, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_U3CMOS10000KPA_USB2 ] = { 0x4010, { "U3CMOS10000KPA(USB2.0) ", 0x0000000081000121, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_U3CMOS08500KPA ] = { 0x3850, { "U3CMOS08500KPA ", 0x0000000081000061, 3, 2, 2, 0, 0, 1.670000, 1.670000, {{3328, 2548},{1664, 1272},}}}, + [TOUPCAM_MODEL_U3CMOS08500KPA_USB2 ] = { 0x4850, { "U3CMOS08500KPA(USB2.0) ", 0x0000000081000121, 3, 2, 2, 0, 0, 1.670000, 1.670000, {{3328, 2548},{1664, 1272},}}}, + [TOUPCAM_MODEL_U3CMOS05100KPA ] = { 0x3510, { "U3CMOS05100KPA ", 0x0000000081000061, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2560, 1922},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3CMOS05100KPA_USB2 ] = { 0x4510, { "U3CMOS05100KPA(USB2.0) ", 0x0000000081000121, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2560, 1922},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPB ] = { 0x3312, { "U3CMOS03100KPB ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{1920, 1080},{1280, 720},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPB_USB2 ] = { 0x4312, { "U3CMOS03100KPB(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{1920, 1080},{1280, 720},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPA ] = { 0x3310, { "U3CMOS03100KPA ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{2048, 1534},{1024, 770},}}}, + [TOUPCAM_MODEL_U3CMOS03100KPA_USB2 ] = { 0x4310, { "U3CMOS03100KPA(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{2048, 1534},{1024, 770},}}}, + [TOUPCAM_MODEL_SCCCD05200KPA ] = { 0x9520, { "SCCCD05200KPA ", 0x0000001080000082, 1, 2, 1, 0, 0, 3.450000, 3.450000, {{2448, 2040},{816, 680},}}}, + [TOUPCAM_MODEL_SCCCD01400KMA ] = { 0x9142, { "SCCCD01400KMA ", 0x0000001080000092, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_SCCCD01400KPB ] = { 0x9146, { "SCCCD01400KPB ", 0x0000001080000082, 1, 1, 0, 0, 0, 4.650000, 4.650000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_SCCCD01400KPA ] = { 0x9141, { "SCCCD01400KPA ", 0x0000001080000082, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_EXCCD01400KPA_2_2 ] = { 0x8141, { "EXCCD01400KPA ", 0x0000001080000002, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_EXCCD01400KMA_2 ] = { 0x8142, { "EXCCD01400KMA ", 0x0000001080000012, 1, 1, 0, 0, 0, 6.450000, 6.450000, {{1360, 1024},}}}, + [TOUPCAM_MODEL_EXCCD00300KMA_2_2_2 ] = { 0x8031, { "EXCCD00300KMA ", 0x0000001080000012, 1, 1, 0, 0, 0, 5.600000, 5.600000, {{640, 480},}}}, + [TOUPCAM_MODEL_ICMOS03100KPA_2 ] = { 0xa310, { "ICMOS03100KPA ", 0x0000000080000009, 5, 3, 3, 0, 0, 3.200000, 3.200000, {{2048, 1536},{1024, 768},{680, 510},}}}, + [TOUPCAM_MODEL_ICMOS01300KMA ] = { 0xa131, { "ICMOS01300KMA ", 0x0000000080000011, 1, 1, 0, 0, 0, 5.200000, 5.200000, {{1280, 1024},}}}, + [TOUPCAM_MODEL_UCMOS01200KMA ] = { 0x6121, { "UCMOS01200KMA ", 0x0000000080000011, 1, 1, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},}}}, + [TOUPCAM_MODEL_L3CMOS14000KPA ] = { 0xc014, { "L3CMOS14000KPA ", 0x0000000081000061, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_L3CMOS14000KPA_USB2 ] = { 0xd014, { "L3CMOS14000KPA(USB2.0) ", 0x0000000081000121, 3, 3, 3, 0, 0, 1.400000, 1.400000, {{4096, 3286},{2048, 1644},{1024, 822},}}}, + [TOUPCAM_MODEL_L3CMOS10000KPA ] = { 0xc010, { "L3CMOS10000KPA ", 0x0000000081000061, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_L3CMOS10000KPA_USB2 ] = { 0xd010, { "L3CMOS10000KPA(USB2.0) ", 0x0000000081000121, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3584, 2746},{1792, 1372},{896, 680},}}}, + [TOUPCAM_MODEL_L3CMOS05100KPA ] = { 0xc510, { "L3CMOS05100KPA ", 0x0000000081000061, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2560, 1922},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_L3CMOS05100KPA_USB2 ] = { 0xd510, { "L3CMOS05100KPA(USB2.0) ", 0x0000000081000121, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2560, 1922},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_L3CMOS03100KPA ] = { 0xc310, { "L3CMOS03100KPA ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{2048, 1534},{1024, 770},}}}, + [TOUPCAM_MODEL_L3CMOS03100KPA_USB2 ] = { 0xd310, { "L3CMOS03100KPA(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.200000, 2.200000, {{2048, 1534},{1024, 770},}}}, + [TOUPCAM_MODEL_MTR3CMOS20000KPA ] = { 0x1116, { "MTR3CMOS20000KPA ", 0x00000000836b24c9, 3, 4, 4, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS20000KPA_USB2 ] = { 0x1117, { "MTR3CMOS20000KPA(USB2.0) ", 0x00000000836b2589, 3, 4, 4, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_ATR3CMOS20000KPA ] = { 0x1114, { "ATR3CMOS20000KPA ", 0x00000000836b24c9, 3, 4, 0, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_ATR3CMOS20000KPA_USB2 ] = { 0x1115, { "ATR3CMOS20000KPA(USB2.0) ", 0x00000000836b2589, 3, 4, 0, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CCD12000KPA ] = { 0x1021, { "MTR3CCD12000KPA ", 0x00000010811b44c2, 1, 2, 0, 4, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_MTR3CCD12000KPA_USB2 ] = { 0x1035, { "MTR3CCD12000KPA(USB2.0) ", 0x00000010811b4582, 1, 2, 0, 4, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_E3ISPM01500KPA ] = { 0x11d0, { "E3ISPM01500KPA ", 0x0000001081042449, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_E3ISPM01500KPA_USB2 ] = { 0x11d1, { "E3ISPM01500KPA(USB2.0) ", 0x0000001081042509, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_E3CMOS20000KMA ] = { 0x11de, { "E3CMOS20000KMA ", 0x0000000081002059, 2, 4, 4, 0, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_E3CMOS20000KMA_USB2 ] = { 0x11df, { "E3CMOS20000KMA(USB2.0) ", 0x0000000081002119, 2, 4, 4, 0, 0, 2.400000, 2.400000, {{5440, 3648},{4080, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA_2_2 ] = { 0x11e6, { "G3CMOS20000KPA ", 0x0000000083492649, 3, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KPA_USB2_2_2] = { 0x11e7, { "G3CMOS20000KPA(USB2.0) ", 0x0000000083492709, 3, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_BIGEYE10000KPA ] = { 0x11e4, { "BigEye10000KPA ", 0x0000000081042449, 2, 5, 5, 0, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2760, 2072},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_BIGEYE10000KPA_USB2 ] = { 0x11e5, { "BigEye10000KPA(USB2.0) ", 0x0000000081042509, 2, 5, 5, 0, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2760, 2072},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB ] = { 0x1203, { "BigEye4200KMB ", 0x0000000887002051, 3, 2, 0, 0, 0, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB_USB2 ] = { 0x1204, { "BigEye4200KMB(USB2.0) ", 0x0000000887002111, 3, 2, 0, 0, 0, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_G3CMOS20000KMA_2 ] = { 0x11ec, { "G3CMOS20000KMA ", 0x0000000083492659, 3, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_G3CMOS20000KMA_USB2_2 ] = { 0x11ed, { "G3CMOS20000KMA(USB2.0) ", 0x0000000083492719, 3, 4, 4, 2, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_ATR3CMOS20000KMA ] = { 0x11d2, { "ATR3CMOS20000KMA ", 0x00000000836b24d9, 3, 4, 0, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_ATR3CMOS20000KMA_USB2 ] = { 0x11d3, { "ATR3CMOS20000KMA(USB2.0) ", 0x00000000836b2599, 3, 4, 0, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS20000KMA ] = { 0x11ee, { "MTR3CMOS20000KMA ", 0x00000000836b24d9, 3, 4, 4, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS20000KMA_USB2 ] = { 0x11ef, { "MTR3CMOS20000KMA(USB2.0) ", 0x00000000836b2599, 3, 4, 4, 1, 0, 2.400000, 2.400000, {{5440, 3648},{4096, 2160},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA_2 ] = { 0x11f0, { "MTR3CMOS16000KPA ", 0x00000000812b24c9, 2, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2_2] = { 0x11f1, { "MTR3CMOS16000KPA(USB2.0) ", 0x00000000812b2589, 2, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_E3CMOS01200KPA_2 ] = { 0x11f8, { "E3CMOS01200KPA ", 0x0000000081001049, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3CMOS01200KPA_USB2_2 ] = { 0x11f9, { "E3CMOS01200KPA(USB2.0) ", 0x0000000081001109, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_UCMOS01300KPA_2 ] = { 0x11fc, { "UCMOS01300KPA ", 0x0000000080000001, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{1280, 720},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_2 ] = { 0x11ea, { "ATR3CMOS16000KPA ", 0x00000000836b24c9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2_2] = { 0x11eb, { "ATR3CMOS16000KPA(USB2.0) ", 0x00000000836b2589, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_E3CMOS12300KMA ] = { 0x1201, { "E3CMOS12300KMA ", 0x0000001081002459, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 3000},{2048, 1500},}}}, + [TOUPCAM_MODEL_E3CMOS12300KMA_USB2 ] = { 0x1202, { "E3CMOS12300KMA(USB2.0) ", 0x0000001081002519, 2, 2, 2, 0, 0, 3.450000, 3.450000, {{4096, 3000},{2048, 1500},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPB ] = { 0x11fa, { "E3ISPM08300KPB ", 0x0000000081042449, 2, 2, 2, 0, 0, 2.000000, 2.000000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPB_USB2 ] = { 0x11fb, { "E3ISPM08300KPB(USB2.0) ", 0x0000000081042509, 2, 2, 2, 0, 0, 2.000000, 2.000000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA_2 ] = { 0x11f6, { "ATR3CMOS16000KMA ", 0x00000000836b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2_2] = { 0x11f7, { "ATR3CMOS16000KMA(USB2.0) ", 0x00000000836b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KPA ] = { 0x11fd, { "ATR3CMOS10300KPA ", 0x00000000876b44c9, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KPA_USB2 ] = { 0x11fe, { "ATR3CMOS10300KPA(USB2.0) ", 0x00000000876b4589, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_LCMOS01300KPA_2 ] = { 0x1207, { "LCMOS01300KPA ", 0x0000000080000001, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{1280, 720},}}}, + [TOUPCAM_MODEL_MTR3CCD12000KMA ] = { 0x1022, { "MTR3CCD12000KMA ", 0x00000010811b44d2, 1, 2, 0, 4, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_MTR3CCD12000KMA_USB2 ] = { 0x1036, { "MTR3CCD12000KMA(USB2.0) ", 0x00000010811b4592, 1, 2, 0, 4, 0, 3.100000, 3.100000, {{4248, 2836},{2124, 1418},}}}, + [TOUPCAM_MODEL_I3ISPM01500KPA ] = { 0x1209, { "I3ISPM01500KPA ", 0x00000050811c1449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3ISPM01500KPA_USB2 ] = { 0x120a, { "I3ISPM01500KPA(USB2.0) ", 0x00000050811c1509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3ISPM01500KPA_2 ] = { 0x127a, { "I3ISPM01500KPA ", 0x00000050831c1449, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3ISPM01500KPA_USB2_2 ] = { 0x127b, { "I3ISPM01500KPA(USB2.0) ", 0x00000050831c1509, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_MTR3CMOS10300KPA ] = { 0x11ff, { "MTR3CMOS10300KPA ", 0x00000000876b44c9, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_MTR3CMOS10300KPA_USB2 ] = { 0x1200, { "MTR3CMOS10300KPA(USB2.0) ", 0x00000000876b4589, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{3704, 2778},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_I3ISPM02000KPA ] = { 0x120d, { "I3ISPM02000KPA ", 0x00000000810c1449, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_I3ISPM02000KPA_USB2 ] = { 0x120e, { "I3ISPM02000KPA(USB2.0) ", 0x00000000810c1509, 2, 1, 0, 0, 0, 3.750000, 3.750000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_ECMOS05000KPA ] = { 0x1208, { "ECMOS05000KPA ", 0x0000000081000009, 2, 2, 2, 0, 0, 2.000000, 2.000000, {{2592, 1944},{1296, 972},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA_2_2 ] = { 0x1213, { "G3CMOS16000KPA ", 0x0000000083692249, 3, 3, 0, 2, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KPA_USB2_2_2] = { 0x1214, { "G3CMOS16000KPA(USB2.0) ", 0x0000000083692309, 3, 3, 0, 2, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA_2_2 ] = { 0x1215, { "G3CMOS16000KMA ", 0x0000000083692259, 3, 3, 0, 2, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3CMOS16000KMA_USB2_2_2] = { 0x1216, { "G3CMOS16000KMA(USB2.0) ", 0x0000000083692319, 3, 3, 0, 2, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_E3ISPM06300KPB ] = { 0x1217, { "E3ISPM06300KPB ", 0x0000000083041049, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_E3ISPM06300KPB_USB2 ] = { 0x1218, { "E3ISPM06300KPB(USB2.0) ", 0x0000000083041109, 2, 2, 2, 0, 0, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_G3CMOS10300KPA_2 ] = { 0x121e, { "G3CMOS10300KPA ", 0x0000000087694649, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{4128, 2808},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_G3CMOS10300KPA_USB2_2 ] = { 0x121f, { "G3CMOS10300KPA(USB2.0) ", 0x0000000087694709, 2, 4, 4, 1, 0, 4.630000, 4.630000, {{4128, 2808},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_C3CMOS05100KPA ] = { 0x120f, { "C3CMOS05100KPA ", 0x0000000081000069, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_C3CMOS05100KPA_USB2 ] = { 0x1210, { "C3CMOS05100KPA(USB2.0) ", 0x0000000081000129, 6, 3, 3, 0, 0, 2.200000, 2.200000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KMA_2 ] = { 0x11f4, { "MTR3CMOS16000KMA ", 0x00000000836b24d9, 3, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KMA_USB2_2] = { 0x11f5, { "MTR3CMOS16000KMA(USB2.0) ", 0x00000000836b2599, 3, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA_2_2 ] = { 0x11f2, { "MTR3CMOS16000KPA ", 0x00000000836b24c9, 3, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CMOS16000KPA_USB2_2_2] = { 0x11f3, { "MTR3CMOS16000KPA(USB2.0) ", 0x00000000836b2589, 3, 3, 3, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_I3CMOS01500KMA ] = { 0x120b, { "I3CMOS01500KMA ", 0x0000005081182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3CMOS01500KMA_USB2 ] = { 0x120c, { "I3CMOS01500KMA(USB2.0) ", 0x0000005081182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3CMOS01500KMA_2 ] = { 0x126e, { "I3CMOS01500KMA ", 0x0000005083182459, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_I3CMOS01500KMA_USB2_2 ] = { 0x126f, { "I3CMOS01500KMA(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{1440, 1080},{720, 540},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMA ] = { 0x1205, { "BigEye4200KMA ", 0x0000000887002059, 3, 2, 0, 0, 0, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMA_USB2 ] = { 0x1206, { "BigEye4200KMA(USB2.0) ", 0x0000000887002119, 3, 2, 0, 0, 0, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_E3CMOS20000KPB ] = { 0x1233, { "E3CMOS20000KPB ", 0x0000000081002041, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{5200, 3888},{2592, 1944},{1728, 1296},}}}, + [TOUPCAM_MODEL_E3CMOS20000KPB_USB2 ] = { 0x1234, { "E3CMOS20000KPB(USB2.0) ", 0x0000000081002101, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{5200, 3888},{2592, 1944},{1728, 1296},}}}, + [TOUPCAM_MODEL_ATR3CMOS01700KMA ] = { 0x124d, { "ATR3CMOS01700KMA ", 0x00000010876b24d9, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS01700KMA_USB2 ] = { 0x124e, { "ATR3CMOS01700KMA(USB2.0) ", 0x00000010876b2599, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS01700KPA ] = { 0x1249, { "ATR3CMOS01700KPA ", 0x00000010876b24c9, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS01700KPA_USB2 ] = { 0x124a, { "ATR3CMOS01700KPA(USB2.0) ", 0x00000010876b2589, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS07100KMA ] = { 0x1245, { "ATR3CMOS07100KMA ", 0x00000010876b24d9, 2, 2, 0, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS07100KMA_USB2 ] = { 0x1246, { "ATR3CMOS07100KMA(USB2.0) ", 0x00000010876b2599, 2, 2, 0, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS07100KPA ] = { 0x1241, { "ATR3CMOS07100KPA ", 0x00000010876b24c9, 2, 2, 0, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS07100KPA_USB2 ] = { 0x1242, { "ATR3CMOS07100KPA(USB2.0) ", 0x00000010876b2589, 2, 2, 0, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS07100KPA ] = { 0x1243, { "MTR3CMOS07100KPA ", 0x00000010876b24c9, 2, 2, 2, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS07100KPA_USB2 ] = { 0x1244, { "MTR3CMOS07100KPA(USB2.0) ", 0x00000010876b2589, 2, 2, 2, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS07100KMA ] = { 0x1247, { "MTR3CMOS07100KMA ", 0x00000010876b24d9, 2, 2, 2, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS07100KMA_USB2 ] = { 0x1248, { "MTR3CMOS07100KMA(USB2.0) ", 0x00000010876b2599, 2, 2, 2, 1, 0, 4.500000, 4.500000, {{3200, 2200},{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS01700KPA ] = { 0x124b, { "MTR3CMOS01700KPA ", 0x00000010876b24c9, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS01700KPA_USB2 ] = { 0x124c, { "MTR3CMOS01700KPA(USB2.0) ", 0x00000010876b2589, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS01700KMA ] = { 0x124f, { "MTR3CMOS01700KMA ", 0x00000010876b24d9, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_MTR3CMOS01700KMA_USB2 ] = { 0x1250, { "MTR3CMOS01700KMA(USB2.0) ", 0x00000010876b2599, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_SL170_C_M ] = { 0x129f, { "SL170-C-M ", 0x00000010876b24d9, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_SL170_C_M_USB2 ] = { 0x12a0, { "SL170-C-M(USB2.0) ", 0x00000010876b2599, 2, 1, 0, 1, 0, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_PUM02000KPA ] = { 0x1251, { "PUM02000KPA ", 0x0000000081000001, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_GPCMOS02000KPB ] = { 0x1219, { "GPCMOS02000KPB ", 0x0000000084482209, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMA ] = { 0x10c8, { "I3CMOS03100KMA ", 0x0000005081182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMA_USB2 ] = { 0x10d5, { "I3CMOS03100KMA(USB2.0) ", 0x0000005081182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMA_2 ] = { 0x1270, { "I3CMOS03100KMA ", 0x0000005083182459, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMA_USB2_2 ] = { 0x1271, { "I3CMOS03100KMA(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMA ] = { 0x10ca, { "I3CMOS05000KMA ", 0x0000005081182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMA_USB2 ] = { 0x10d7, { "I3CMOS05000KMA(USB2.0) ", 0x0000005081182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMA_2 ] = { 0x1274, { "I3CMOS05000KMA ", 0x0000005083182459, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMA_USB2_2 ] = { 0x1275, { "I3CMOS05000KMA(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_C3CMOS10000KPA ] = { 0x123b, { "C3CMOS10000KPA ", 0x0000000081000069, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3664, 2748},{1832, 1374},{912, 686},}}}, + [TOUPCAM_MODEL_C3CMOS10000KPA_USB2 ] = { 0x123c, { "C3CMOS10000KPA(USB2.0) ", 0x0000000081000129, 3, 3, 3, 0, 0, 1.670000, 1.670000, {{3664, 2748},{1832, 1374},{912, 686},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPA ] = { 0x123d, { "I3ISPM05000KPA ", 0x00000050811c2449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPA_USB2 ] = { 0x123e, { "I3ISPM05000KPA(USB2.0) ", 0x00000050811c2509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPA_2 ] = { 0x1280, { "I3ISPM05000KPA ", 0x00000050831c2449, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPA_USB2_2 ] = { 0x1281, { "I3ISPM05000KPA(USB2.0) ", 0x00000050831c2509, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPA ] = { 0x123f, { "I3ISPM03100KPA ", 0x00000050811c2449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPA_USB2 ] = { 0x1240, { "I3ISPM03100KPA(USB2.0) ", 0x00000050811c2509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPA_2 ] = { 0x127c, { "I3ISPM03100KPA ", 0x00000050831c2449, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPA_USB2_2 ] = { 0x127d, { "I3ISPM03100KPA(USB2.0) ", 0x00000050831c2509, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3ISPM18000KPA ] = { 0x1252, { "E3ISPM18000KPA ", 0x0000000081042041, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{4880, 3720},{2448, 1836},{1632, 1224},}}}, + [TOUPCAM_MODEL_E3ISPM18000KPA_USB2 ] = { 0x1253, { "E3ISPM18000KPA(USB2.0) ", 0x0000000081042101, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{4880, 3720},{2448, 1836},{1632, 1224},}}}, + [TOUPCAM_MODEL_E3ISPM20000KPB ] = { 0x1254, { "E3ISPM20000KPB ", 0x0000000081042041, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{5200, 3888},{2592, 1944},{1728, 1296},}}}, + [TOUPCAM_MODEL_E3ISPM20000KPB_USB2 ] = { 0x1255, { "E3ISPM20000KPB(USB2.0) ", 0x0000000081042101, 2, 3, 3, 0, 0, 1.200000, 1.200000, {{5200, 3888},{2592, 1944},{1728, 1296},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPB ] = { 0x1262, { "I3ISPM05000KPB ", 0x00000050811c2449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPB_USB2 ] = { 0x1263, { "I3ISPM05000KPB(USB2.0) ", 0x00000050811c2509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPB_2 ] = { 0x1282, { "I3ISPM05000KPB ", 0x00000050831c2449, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM05000KPB_USB2_2 ] = { 0x1283, { "I3ISPM05000KPB(USB2.0) ", 0x00000050831c2509, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPB ] = { 0x1260, { "I3ISPM03100KPB ", 0x00000050811c2449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPB_USB2 ] = { 0x1261, { "I3ISPM03100KPB(USB2.0) ", 0x00000050811c2509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPB_2 ] = { 0x127e, { "I3ISPM03100KPB ", 0x00000050831c2449, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3ISPM03100KPB_USB2_2 ] = { 0x127f, { "I3ISPM03100KPB(USB2.0) ", 0x00000050831c2509, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMB ] = { 0x125e, { "I3CMOS05000KMB ", 0x0000005081182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMB_USB2 ] = { 0x125f, { "I3CMOS05000KMB(USB2.0) ", 0x0000005081182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMB_2 ] = { 0x1276, { "I3CMOS05000KMB ", 0x0000005083182459, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS05000KMB_USB2_2 ] = { 0x1277, { "I3CMOS05000KMB(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2448, 2048},{1224, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMB ] = { 0x125c, { "I3CMOS03100KMB ", 0x0000005081182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMB_USB2 ] = { 0x125d, { "I3CMOS03100KMB(USB2.0) ", 0x0000005081182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMB_2 ] = { 0x1272, { "I3CMOS03100KMB ", 0x0000005083182459, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_I3CMOS03100KMB_USB2_2 ] = { 0x1273, { "I3CMOS03100KMB(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 3, 3.450000, 3.450000, {{2048, 1536},{1024, 768},}}}, + [TOUPCAM_MODEL_E3ISPM21000KPA ] = { 0x1256, { "E3ISPM21000KPA ", 0x0000000085042049, 3, 5, 5, 0, 0, 3.300000, 3.300000, {{5280, 3954},{3952, 3952},{2640, 1976},{1760, 1316},{584, 438},}}}, + [TOUPCAM_MODEL_E3ISPM21000KPA_USB2 ] = { 0x1257, { "E3ISPM21000KPA(USB2.0) ", 0x0000000085042109, 3, 5, 5, 0, 0, 3.300000, 3.300000, {{5280, 3954},{3952, 3952},{2640, 1976},{1760, 1316},{584, 438},}}}, + [TOUPCAM_MODEL_ECMOS05100KPA ] = { 0x128c, { "ECMOS05100KPA ", 0x0000000080000009, 2, 3, 3, 0, 0, 2.400000, 2.400000, {{2592, 1944},{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_E3ISPM15600KPA ] = { 0x128d, { "E3ISPM15600KPA ", 0x0000000085042049, 3, 3, 3, 0, 0, 3.300000, 3.300000, {{3952, 3952},{1976, 1976},{1316, 1316},}}}, + [TOUPCAM_MODEL_E3ISPM15600KPA_USB2 ] = { 0x128e, { "E3ISPM15600KPA(USB2.0) ", 0x0000000085042109, 3, 3, 3, 0, 0, 3.300000, 3.300000, {{3952, 3952},{1976, 1976},{1316, 1316},}}}, + [TOUPCAM_MODEL_I3CMOS00500KMA ] = { 0x1264, { "I3CMOS00500KMA ", 0x0000005081182459, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{800, 620},}}}, + [TOUPCAM_MODEL_I3CMOS00500KMA_USB2 ] = { 0x1265, { "I3CMOS00500KMA(USB2.0) ", 0x0000005081182519, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{800, 620},}}}, + [TOUPCAM_MODEL_I3ISPM00500KPA ] = { 0x1266, { "I3ISPM00500KPA ", 0x00000050811c2449, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{800, 620},}}}, + [TOUPCAM_MODEL_I3ISPM00500KPA_USB2 ] = { 0x1267, { "I3ISPM00500KPA(USB2.0) ", 0x00000050811c2509, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{800, 620},}}}, + [TOUPCAM_MODEL_IUA6300KPA ] = { 0x1221, { "IUA6300KPA ", 0x00000040831c2049, 9, 2, 0, 0, 4, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_IUA6300KPA_USB2 ] = { 0x1222, { "IUA6300KPA(USB2.0) ", 0x00000040831c2109, 9, 2, 0, 0, 4, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_IUB4200KMB ] = { 0x122b, { "IUB4200KMB ", 0x0000000887182059, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_IUB4200KMB_USB2 ] = { 0x122c, { "IUB4200KMB(USB2.0) ", 0x0000000887182119, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2046},{1024, 1022},}}}, + [TOUPCAM_MODEL_IUC31000KMA ] = { 0x122f, { "IUC31000KMA ", 0x0000005083182459, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{6464, 4852},{3216, 2426},}}}, + [TOUPCAM_MODEL_IUC31000KMA_USB2 ] = { 0x1230, { "IUC31000KMA(USB2.0) ", 0x0000005083182519, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{6464, 4852},{3216, 2426},}}}, + [TOUPCAM_MODEL_IUA6300KMA ] = { 0x1223, { "IUA6300KMA ", 0x0000004083182059, 9, 2, 0, 0, 4, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_IUA6300KMA_USB2 ] = { 0x1224, { "IUA6300KMA(USB2.0) ", 0x0000004083182119, 9, 2, 0, 0, 4, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_IUA1700KPA ] = { 0x1288, { "IUA1700KPA ", 0x00000450831c2449, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_IUA1700KPA_USB2 ] = { 0x1289, { "IUA1700KPA(USB2.0) ", 0x00000450831c2509, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_IUA7100KPA ] = { 0x1284, { "IUA7100KPA ", 0x00000450831c2449, 9, 2, 0, 0, 4, 4.500000, 4.500000, {{3200, 2200},{1584, 1100},}}}, + [TOUPCAM_MODEL_IUA7100KPA_USB2 ] = { 0x1285, { "IUA7100KPA(USB2.0) ", 0x00000450831c2509, 9, 2, 0, 0, 4, 4.500000, 4.500000, {{3200, 2200},{1584, 1100},}}}, + [TOUPCAM_MODEL_IUC31000KPA ] = { 0x1231, { "IUC31000KPA ", 0x00000050831c2449, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{6464, 4852},{3216, 2426},}}}, + [TOUPCAM_MODEL_IUC31000KPA_USB2 ] = { 0x1232, { "IUC31000KPA(USB2.0) ", 0x00000050831c2509, 9, 2, 0, 0, 4, 3.450000, 3.450000, {{6464, 4852},{3216, 2426},}}}, + [TOUPCAM_MODEL_ATR3CMOS21000KPA ] = { 0x1258, { "ATR3CMOS21000KPA ", 0x00000000876b24c9, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_ATR3CMOS21000KPA_USB2 ] = { 0x1259, { "ATR3CMOS21000KPA(USB2.0) ", 0x00000000876b2589, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_IUA20000KPA ] = { 0x1225, { "IUA20000KPA ", 0x00000040831c2049, 9, 3, 0, 0, 4, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_IUA20000KPA_USB2 ] = { 0x1226, { "IUA20000KPA(USB2.0) ", 0x00000040831c2109, 9, 3, 0, 0, 4, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_T3CMOS20000KPA ] = { 0x1295, { "T3CMOS20000KPA ", 0x00000000836f24c9, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_T3CMOS20000KPA_USB2 ] = { 0x1296, { "T3CMOS20000KPA(USB2.0) ", 0x00000000836f2589, 2, 3, 3, 1, 0, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_MTR3CMOS21000KPA ] = { 0x125a, { "MTR3CMOS21000KPA ", 0x00000000876b24c9, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_MTR3CMOS21000KPA_USB2 ] = { 0x125b, { "MTR3CMOS21000KPA(USB2.0) ", 0x00000000876b2589, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_GPCMOS01200KPF ] = { 0x129e, { "GPCMOS01200KPF ", 0x0000000084482229, 2, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_I3CMOS06300KMA ] = { 0x1268, { "I3CMOS06300KMA ", 0x0000004083182059, 9, 2, 0, 0, 3, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_I3CMOS06300KMA_USB2 ] = { 0x1269, { "I3CMOS06300KMA(USB2.0) ", 0x0000004083182119, 9, 2, 0, 0, 3, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM06300KPA ] = { 0x126a, { "I3ISPM06300KPA ", 0x00000040831c2049, 9, 2, 0, 0, 3, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_I3ISPM06300KPA_USB2 ] = { 0x126b, { "I3ISPM06300KPA(USB2.0) ", 0x00000040831c2109, 9, 2, 0, 0, 3, 2.400000, 2.400000, {{3072, 2048},{1536, 1024},}}}, + [TOUPCAM_MODEL_IUA20000KMA ] = { 0x1227, { "IUA20000KMA ", 0x0000004083182059, 9, 3, 0, 0, 4, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_IUA20000KMA_USB2 ] = { 0x1228, { "IUA20000KMA(USB2.0) ", 0x0000004083182119, 9, 3, 0, 0, 4, 2.400000, 2.400000, {{5440, 3648},{2736, 1824},{1824, 1216},}}}, + [TOUPCAM_MODEL_IUB43000KMA ] = { 0x122d, { "IUB43000KMA ", 0x0000000083182059, 3, 1, 0, 0, 4, 2.800000, 2.800000, {{7904, 5432},}}}, + [TOUPCAM_MODEL_IUB43000KMA_USB2 ] = { 0x122e, { "IUB43000KMA(USB2.0) ", 0x0000000083182119, 3, 1, 0, 0, 4, 2.800000, 2.800000, {{7904, 5432},}}}, + [TOUPCAM_MODEL_IUC60000KMA ] = { 0x128f, { "IUC60000KMA ", 0x0000004083188059, 9, 4, 4, 0, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_IUC60000KMA_USB2 ] = { 0x1290, { "IUC60000KMA(USB2.0) ", 0x0000004083188119, 9, 4, 4, 0, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_IUC60000KPA ] = { 0x1291, { "IUC60000KPA ", 0x00000040831c8049, 9, 4, 4, 0, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_IUC60000KPA_USB2 ] = { 0x1292, { "IUC60000KPA(USB2.0) ", 0x00000040831c8109, 9, 4, 4, 0, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_IUA2300KPB ] = { 0x12a5, { "IUA2300KPB ", 0x00000050831c2049, 9, 1, 0, 0, 4, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_IUA2300KPB_USB2 ] = { 0x12a6, { "IUA2300KPB(USB2.0) ", 0x00000050831c2109, 9, 1, 0, 0, 4, 5.860000, 5.860000, {{1920, 1200},}}}, + [TOUPCAM_MODEL_IUC26000KPA ] = { 0x1293, { "IUC26000KPA ", 0x00000040831c8049, 9, 3, 3, 0, 4, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_IUC26000KPA_USB2 ] = { 0x1294, { "IUC26000KPA(USB2.0) ", 0x00000040831c8109, 9, 3, 3, 0, 4, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_MTR3CMOS45000KMA ] = { 0x12ab, { "MTR3CMOS45000KMA ", 0x00000000834b24d9, 2, 2, 0, 1, 0, 2.315000, 2.315000, {{8256, 5616},{4128, 2808},}}}, + [TOUPCAM_MODEL_MTR3CMOS45000KMA_USB2 ] = { 0x12ac, { "MTR3CMOS45000KMA(USB2.0) ", 0x00000000834b2599, 2, 2, 0, 1, 0, 2.315000, 2.315000, {{8256, 5616},{4128, 2808},}}}, + [TOUPCAM_MODEL_C3CMOS05100KPB ] = { 0x12ad, { "C3CMOS05100KPB ", 0x0000000081000049, 2, 2, 2, 0, 0, 2.000000, 2.000000, {{2592, 1944},{1296, 972},}}}, + [TOUPCAM_MODEL_C3CMOS05100KPB_USB2 ] = { 0x12ae, { "C3CMOS05100KPB(USB2.0) ", 0x0000000081000109, 2, 2, 2, 0, 0, 2.000000, 2.000000, {{2592, 1944},{1296, 972},}}}, + [TOUPCAM_MODEL_C3CMOS03500KPA ] = { 0x1239, { "C3CMOS03500KPA ", 0x0000000081000041, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2304, 1536},{1152, 768},}}}, + [TOUPCAM_MODEL_C3CMOS03500KPA_USB2 ] = { 0x123a, { "C3CMOS03500KPA(USB2.0) ", 0x0000000081000101, 2, 2, 2, 0, 0, 2.500000, 2.500000, {{2304, 1536},{1152, 768},}}}, + [TOUPCAM_MODEL_MAX60000KPA ] = { 0x12b1, { "MAX60000KPA ", 0x000000c0835f84c9, 9, 4, 4, 4, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_MAX60000KPA_USB2 ] = { 0x12b2, { "MAX60000KPA(USB2.0) ", 0x000000c0835f8589, 9, 4, 4, 4, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB_2 ] = { 0x12af, { "BigEye4200KMB ", 0x0000000887182051, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB_USB2_2 ] = { 0x12b0, { "BigEye4200KMB(USB2.0) ", 0x0000000887182111, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_IUA1700KMA ] = { 0x128a, { "IUA1700KMA ", 0x0000045083182459, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_IUA1700KMA_USB2 ] = { 0x128b, { "IUA1700KMA(USB2.0) ", 0x0000045083182519, 9, 1, 0, 0, 4, 9.000000, 9.000000, {{1600, 1100},}}}, + [TOUPCAM_MODEL_IUA7100KMA ] = { 0x1286, { "IUA7100KMA ", 0x0000045083182459, 9, 2, 0, 0, 4, 4.500000, 4.500000, {{3200, 2200},{1584, 1100},}}}, + [TOUPCAM_MODEL_IUA7100KMA_USB2 ] = { 0x1287, { "IUA7100KMA(USB2.0) ", 0x0000045083182519, 9, 2, 0, 0, 4, 4.500000, 4.500000, {{3200, 2200},{1584, 1100},}}}, + [TOUPCAM_MODEL_ATR3CMOS26000KPA ] = { 0x12b7, { "ATR3CMOS26000KPA ", 0x00000180876b84c9, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_ATR3CMOS26000KPA_USB2 ] = { 0x12b8, { "ATR3CMOS26000KPA(USB2.0) ", 0x00000180876b8589, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_E3ISPM09000KPB ] = { 0x12c7, { "E3ISPM09000KPB ", 0x0000010087044069, 3, 3, 3, 0, 0, 3.760000, 3.760000, {{3008, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_E3ISPM09000KPB_USB2 ] = { 0x12c8, { "E3ISPM09000KPB(USB2.0) ", 0x0000010087044129, 3, 3, 3, 0, 0, 3.760000, 3.760000, {{3008, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_ATR3CMOS09000KPA ] = { 0x12bb, { "ATR3CMOS09000KPA ", 0x00000180876b44c9, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{3008, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_ATR3CMOS09000KPA_USB2 ] = { 0x12bc, { "ATR3CMOS09000KPA(USB2.0) ", 0x00000180876b4589, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{3008, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_G3CMOS21000KPA ] = { 0x12cd, { "G3CMOS21000KPA ", 0x0000000087692649, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_G3CMOS21000KPA_USB2 ] = { 0x12ce, { "G3CMOS21000KPA(USB2.0) ", 0x0000000087692709, 3, 5, 0, 1, 0, 3.300000, 3.300000, {{5280, 3956},{3952, 3952},{2640, 1978},{1760, 1318},{584, 440},}}}, + [TOUPCAM_MODEL_ITR3CMOS16000KMA ] = { 0x12d4, { "ITR3CMOS16000KMA ", 0x00000000832b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ITR3CMOS16000KMA_USB2 ] = { 0x12d5, { "ITR3CMOS16000KMA(USB2.0) ", 0x00000000832b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_MTR3CMOS26000KPA ] = { 0x12b9, { "MTR3CMOS26000KPA ", 0x00000180876f84c9, 2, 3, 3, 1, 0, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_MTR3CMOS26000KPA_USB2 ] = { 0x12ba, { "MTR3CMOS26000KPA(USB2.0) ", 0x00000180876f8589, 2, 3, 3, 1, 0, 3.760000, 3.760000, {{6224, 4168},{3104, 2084},{2064, 1386},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB_2_2 ] = { 0x12d6, { "BigEye4200KMB ", 0x0000020887182059, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMB_USB2_2_2] = { 0x12d7, { "BigEye4200KMB(USB2.0) ", 0x0000020887182119, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_SKYEYE62AM ] = { 0x12e2, { "SkyEye62AM ", 0x00000180876b84d9, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},}}}, + [TOUPCAM_MODEL_SKYEYE62AM_USB2 ] = { 0x12e3, { "SkyEye62AM(USB2.0) ", 0x00000180876b8599, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},}}}, + [TOUPCAM_MODEL_MTR3CMOS09000KPA ] = { 0x12bd, { "MTR3CMOS09000KPA ", 0x00000180876f44c9, 2, 3, 3, 1, 0, 3.760000, 3.760000, {{2992, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_MTR3CMOS09000KPA_USB2 ] = { 0x12be, { "MTR3CMOS09000KPA(USB2.0) ", 0x00000180876f4589, 2, 3, 3, 1, 0, 3.760000, 3.760000, {{2992, 3000},{1488, 1500},{992, 998},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMD ] = { 0x12f4, { "BigEye4200KMD ", 0x0000000887188059, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMD_USB2 ] = { 0x12f5, { "BigEye4200KMD(USB2.0) ", 0x0000000887188119, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_IUA4100KPA ] = { 0x12d8, { "IUA4100KPA ", 0x00000040871c2449, 9, 1, 0, 0, 4, 2.900000, 2.900000, {{2688, 1520},}}}, + [TOUPCAM_MODEL_IUA4100KPA_USB2 ] = { 0x12d9, { "IUA4100KPA(USB2.0) ", 0x00000040871c2509, 9, 1, 0, 0, 4, 2.900000, 2.900000, {{2688, 1520},}}}, + [TOUPCAM_MODEL_IUA2100KPA ] = { 0x12da, { "IUA2100KPA ", 0x00000040871c2449, 9, 1, 0, 0, 4, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_IUA2100KPA_USB2 ] = { 0x12db, { "IUA2100KPA(USB2.0) ", 0x00000040871c2509, 9, 1, 0, 0, 4, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_E3CMOS45000KMA ] = { 0x12e6, { "E3CMOS45000KMA ", 0x0000000083002459, 2, 2, 2, 0, 0, 2.315000, 2.315000, {{8256, 5616},{4128, 2808},}}}, + [TOUPCAM_MODEL_E3CMOS45000KMA_USB2 ] = { 0x12e7, { "E3CMOS45000KMA(USB2.0) ", 0x0000000083002519, 2, 2, 2, 0, 0, 2.315000, 2.315000, {{8256, 5616},{4128, 2808},}}}, + [TOUPCAM_MODEL_SKYEYE62AC ] = { 0x12e0, { "SkyEye62AC ", 0x00000180876b84c9, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},}}}, + [TOUPCAM_MODEL_SKYEYE62AC_USB2 ] = { 0x12e1, { "SkyEye62AC(USB2.0) ", 0x00000180876b8589, 2, 3, 0, 1, 0, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},}}}, + [TOUPCAM_MODEL_SKYEYE24AC ] = { 0x12e4, { "SkyEye24AC ", 0x00000080876b44c9, 2, 3, 0, 1, 0, 5.940000, 5.940000, {{6064, 4040},{3024, 2012},{2016, 1342},}}}, + [TOUPCAM_MODEL_SKYEYE24AC_USB2 ] = { 0x12e5, { "SkyEye24AC(USB2.0) ", 0x00000080876b4589, 2, 3, 0, 1, 0, 5.940000, 5.940000, {{6064, 4040},{3024, 2012},{2016, 1342},}}}, + [TOUPCAM_MODEL_MAX62AM ] = { 0x12ea, { "MAX62AM ", 0x00000180875f84d9, 2, 4, 4, 4, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_MAX62AM_USB2 ] = { 0x12eb, { "MAX62AM(USB2.0) ", 0x00000180875f8599, 2, 4, 4, 4, 4, 3.760000, 3.760000, {{9568, 6380},{4784, 3190},{3184, 2124},{1040, 706},}}}, + [TOUPCAM_MODEL_MTR3CMOS08300KPA ] = { 0x12f6, { "MTR3CMOS08300KPA ", 0x00000000876f24c9, 2, 2, 2, 1, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_MTR3CMOS08300KPA_USB2 ] = { 0x12f7, { "MTR3CMOS08300KPA(USB2.0) ", 0x00000000876f2589, 2, 2, 2, 1, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M462C ] = { 0x12de, { "G3M462C ", 0x0000000085482649, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3M462C_USB2 ] = { 0x12df, { "G3M462C(USB2.0) ", 0x0000000085482709, 2, 1, 0, 0, 0, 2.900000, 2.900000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPC ] = { 0x12cb, { "E3ISPM08300KPC ", 0x0000000085042449, 2, 2, 2, 0, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM08300KPC_USB2 ] = { 0x12cc, { "E3ISPM08300KPC(USB2.0) ", 0x0000000085042509, 2, 2, 2, 0, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMA_2 ] = { 0x12fe, { "BigEye4200KMA ", 0x0000020887182059, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_BIGEYE4200KMA_USB2_2 ] = { 0x12ff, { "BigEye4200KMA(USB2.0) ", 0x0000020887182119, 3, 2, 0, 0, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KMA ] = { 0x12cf, { "ATR3CMOS10300KMA ", 0x00000000876b44d9, 2, 4, 0, 1, 0, 4.630000, 4.630000, {{4128, 2808},{8184, 5616},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KMA_USB2 ] = { 0x12d0, { "ATR3CMOS10300KMA(USB2.0) ", 0x00000000876b4599, 2, 4, 0, 1, 0, 4.630000, 4.630000, {{4128, 2808},{8184, 5616},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_E3ISPM45000KPA ] = { 0x1300, { "E3ISPM45000KPA ", 0x0000000083042449, 2, 8, 8, 0, 0, 4.630000, 4.630000, {{8176, 5616},{4088, 2808},{7408, 5556},{3704, 2778},{8176, 4320},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_E3ISPM45000KPA_USB2 ] = { 0x1301, { "E3ISPM45000KPA(USB2.0) ", 0x0000000083042509, 2, 8, 8, 0, 0, 4.630000, 4.630000, {{8176, 5616},{4088, 2808},{7408, 5556},{3704, 2778},{8176, 4320},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_E3ISPM02100KPA ] = { 0x1304, { "E3ISPM02100KPA ", 0x0000000085042449, 2, 1, 0, 0, 0, 5.800000, 5.800000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_E3ISPM02100KPA_USB2 ] = { 0x1305, { "E3ISPM02100KPA(USB2.0) ", 0x0000000085042509, 2, 1, 0, 0, 0, 5.800000, 5.800000, {{1920, 1080},}}}, + [TOUPCAM_MODEL_G3CMOS08300KPA ] = { 0x1302, { "G3CMOS08300KPA ", 0x0000000087692649, 2, 2, 0, 1, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_G3CMOS08300KPA_USB2 ] = { 0x1303, { "G3CMOS08300KPA(USB2.0) ", 0x0000000087692709, 2, 2, 0, 1, 0, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_BIGEYE4200KME ] = { 0x12fc, { "BigEye4200KME ", 0x0000020887182059, 3, 2, 0, 0, 4, 11.000000, 11.000000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_BIGEYE4200KME_USB2 ] = { 0x12fd, { "BigEye4200KME(USB2.0) ", 0x0000020887182119, 3, 2, 0, 0, 4, 11.000000, 11.000000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_ITR3CMOS08300KPA ] = { 0x1310, { "ITR3CMOS08300KPA ", 0x00000400875f24c9, 2, 2, 2, 1, 4, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_ITR3CMOS08300KPA_USB2 ] = { 0x1311, { "ITR3CMOS08300KPA(USB2.0) ", 0x00000400875f2589, 2, 2, 2, 1, 4, 2.900000, 2.900000, {{3840, 2160},{1920, 1080},}}}, + [TOUPCAM_MODEL_MAX04AM ] = { 0x12ee, { "MAX04AM ", 0x00000088871b24d9, 3, 2, 0, 4, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_MAX04AM_USB2 ] = { 0x12ef, { "MAX04AM(USB2.0) ", 0x00000088871b2599, 3, 2, 0, 4, 4, 6.500000, 6.500000, {{2048, 2048},{1024, 1024},}}}, + [TOUPCAM_MODEL_G3M287C ] = { 0x1176, { "G3M287C ", 0x0000001081482649, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_G3M287C_USB2 ] = { 0x1177, { "G3M287C(USB2.0) ", 0x0000001081482709, 2, 1, 0, 0, 0, 6.900000, 6.900000, {{720, 540},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPB ] = { 0x11e0, { "ATR3CMOS16000KPB ", 0x00000000836b44e1, 2, 2, 0, 1, 0, 4.780000, 4.780000, {{4944, 3260},{1640, 1060},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPB_USB2 ] = { 0x11e1, { "ATR3CMOS16000KPB(USB2.0) ", 0x00000000836b45a1, 2, 2, 0, 1, 0, 4.780000, 4.780000, {{4944, 3260},{1640, 1060},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KPA_2 ] = { 0x121a, { "ATR3CMOS10300KPA ", 0x00000000876b44c9, 2, 4, 0, 1, 0, 4.630000, 4.630000, {{4128, 2808},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_ATR3CMOS10300KPA_USB2_2] = { 0x121b, { "ATR3CMOS10300KPA(USB2.0) ", 0x00000000876b4589, 2, 4, 0, 1, 0, 4.630000, 4.630000, {{4128, 2808},{4096, 2160},{2048, 1080},{1360, 720},}}}, + [TOUPCAM_MODEL_L3CMOS08500KPA ] = { 0xc850, { "L3CMOS08500KPA ", 0x0000000081000061, 3, 2, 2, 0, 0, 1.670000, 1.670000, {{3328, 2548},{1664, 1272},}}}, + [TOUPCAM_MODEL_L3CMOS08500KPA_USB2 ] = { 0xd850, { "L3CMOS08500KPA(USB2.0) ", 0x0000000081000121, 3, 2, 2, 0, 0, 1.670000, 1.670000, {{3328, 2548},{1664, 1272},}}}, +}; +#endif + +#define XP(x) Toupcam##x + +struct toupcam_model_pid { + uint16_t pid; + XP(ModelV2) model; +}; + +enum { + TOUPCAM_MODEL_ATR3CMOS16000KMA_2, + TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS16000KPA_2, + TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2_2, + TOUPCAM_MODEL_ATR3CMOS16000KMA, + TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2, + TOUPCAM_MODEL_ATR3CMOS16000KPA, + TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2, + TOUPCAM_MODEL_G3M178M, + TOUPCAM_MODEL_G3M178M_USB2, + TOUPCAM_MODEL_G3M178C, + TOUPCAM_MODEL_G3M178C_USB2, + TOUPCAM_MODEL_G3M178M_2, + TOUPCAM_MODEL_G3M178M_USB2_2, + TOUPCAM_MODEL_G3M178C_2, + TOUPCAM_MODEL_G3M178C_USB2_2, + TOUPCAM_MODEL_GPCMOS01200KMB, + TOUPCAM_MODEL_GPCMOS01200KPB, +}; +static const struct toupcam_model_pid toupcam_models[] = { + [TOUPCAM_MODEL_ATR3CMOS16000KMA_2 ] = { 0x11f6, { "DSI IV Mono", 0x00000000836b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2_2] = { 0x11f7, { "DSI IV Mono (USB2.0)", 0x00000000836b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_2 ] = { 0x11ea, { "DSI IV Color", 0x00000000836b24c9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2_2] = { 0x11eb, { "DSI IV Color (USB2.0)", 0x00000000836b2589, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA ] = { 0x106d, { "DSI IV Mono", 0x00000000816b24d9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2 ] = { 0x1076, { "DSI IV Mono (USB2.0)", 0x00000000816b2599, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA ] = { 0x106b, { "DSI IV Color", 0x00000000816b24c9, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2 ] = { 0x1075, { "DSI IV Color (USB2.0)", 0x00000000816b2589, 3, 3, 0, 1, 0, 3.800000, 3.800000, {{4640, 3506},{2304, 1750},{1536, 1160},}}}, + [TOUPCAM_MODEL_G3M178M ] = { 0x11cc, { "LPI-GM Advanced", 0x0000000081484659, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178M_USB2 ] = { 0x11cd, { "LPI-GM Advanced (USB2.0)", 0x0000000081484719, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C ] = { 0x11ca, { "LPI-GC Advanced", 0x0000000081484649, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_USB2 ] = { 0x11cb, { "LPI-GC Advanced (USB2.0)", 0x0000000081484709, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178M_2 ] = { 0x115c, { "LPI-GM Advanced", 0x0000000081484259, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178M_USB2_2 ] = { 0x115d, { "LPI-GM Advanced (USB2.0)", 0x0000000081484319, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_2 ] = { 0x115a, { "LPI-GC Advanced", 0x0000000081484249, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_G3M178C_USB2_2 ] = { 0x115b, { "LPI-GC Advanced (USB2.0)", 0x0000000081484309, 2, 2, 0, 0, 0, 2.400000, 2.400000, {{3040, 2048},{1520, 1024},}}}, + [TOUPCAM_MODEL_GPCMOS01200KMB ] = { 0x1004, { "LPI-GM", 0x0000000080682219, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, + [TOUPCAM_MODEL_GPCMOS01200KPB ] = { 0x1003, { "LPI-GC", 0x0000000080682209, 4, 2, 0, 0, 0, 3.750000, 3.750000, {{1280, 960},{640, 480},}}}, +}; + +struct oem_camera { + const char *name; /* The OEM camera name */ + uint16_t vid; /* The OEM vendor ID */ + uint16_t pid; /* The OEM product ID */ + const struct toupcam_model_pid *toupcam; /* Pointer to the Toupcam equivalent */ +}; + +static const struct oem_camera oem_cameras[] = { + /* DSI IV */ + { + .name = "Meade DSI IV Mono", + .vid = 0x547, + .pid = 0xe079, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KMA_2], + }, + { + .name = "Meade DSI IV Mono (USB2.0)", + .vid = 0x547, + .pid = 0xe07a, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2_2], + }, + { + .name = "Meade DSI IV Color", + .vid = 0x547, + .pid = 0xe077, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KPA_2], + }, + { + .name = "Meade DSI IV Color (USB2.0)", + .vid = 0x547, + .pid = 0xe078, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2_2], + }, + /* DSI IV without DDR buffer */ + { + .name = "Meade DSI IV Mono", + .vid = 0x547, + .pid = 0xe06d, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KMA], + }, + { + .name = "Meade DSI IV Mono (USB2.0)", + .vid = 0x547, + .pid = 0xe076, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KMA_USB2], + }, + { + .name = "Meade DSI IV Color", + .vid = 0x547, + .pid = 0xe06b, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KPA], + }, + { + .name = "Meade DSI IV Color (USB2.0)", + .vid = 0x547, + .pid = 0xe075, + .toupcam = &toupcam_models[TOUPCAM_MODEL_ATR3CMOS16000KPA_USB2], + }, + /* LPI-G Advanced */ + { + .name = "Meade LPI-GM Advanced", + .vid = 0x547, + .pid = 0xe00d, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178M], + }, + { + .name = "Meade LPI-GM Advanced (USB2.0)", + .vid = 0x547, + .pid = 0xe00e, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178M_USB2], + }, + { + .name = "Meade LPI-GC Advanced", + .vid = 0x547, + .pid = 0xe00b, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178C], + }, + { + .name = "Meade LPI-GC Advanced (USB2.0)", + .vid = 0x547, + .pid = 0xe00e, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178C_USB2], + }, + /* LPI-G Advanced with temperature sensor */ + { + .name = "Meade LPI-GM Advanced", + .vid = 0x547, + .pid = 0xe009, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178M_2], + }, + { + .name = "Meade LPI-GM Advanced (USB2.0)", + .vid = 0x547, + .pid = 0xe00a, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178M_USB2_2], + }, + { + .name = "Meade LPI-GC Advanced", + .vid = 0x547, + .pid = 0xe007, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178C_2], + }, + { + .name = "Meade LPI-GC Advanced (USB2.0)", + .vid = 0x547, + .pid = 0xe008, + .toupcam = &toupcam_models[TOUPCAM_MODEL_G3M178C_USB2_2], + }, + /* LPI-G */ + { + .name = "Meade LPI-GM", + .vid = 0x549, + .pid = 0xe004, + .toupcam = &toupcam_models[TOUPCAM_MODEL_GPCMOS01200KMB], + }, + { + .name = "Meade LPI-GC", + .vid = 0x549, + .pid = 0xe003, + .toupcam = &toupcam_models[TOUPCAM_MODEL_GPCMOS01200KPB], + } +}; +#ifndef countof +#define countof(x) (sizeof(x)/sizeof(x[0])) +#endif +static const struct oem_camera *vid_pid_to_oem_cam(int vid, int pid) +{ + unsigned i; + for (i = 0; i < countof(oem_cameras); i++) { + if ((oem_cameras[i].vid == vid) && + (oem_cameras[i].pid == pid)) { + return &oem_cameras[i]; + } + } + + return NULL; +} + +int OEMCamEnum(XP(DeviceV2) *cam_infos, int cam_infos_count) +{ + int cnt = 0; + libusb_device **list; + ssize_t usb_cnt; + ssize_t i = 0; + + libusb_init(NULL); + usb_cnt = libusb_get_device_list(NULL, &list); + if (usb_cnt < 0) + return 0; + + for (i = 0; (i < usb_cnt) && (cnt < cam_infos_count); i++) { + libusb_device *dev = list[i]; + const struct oem_camera *cam; + struct libusb_device_descriptor desc; + + libusb_get_device_descriptor(dev, &desc); + cam = vid_pid_to_oem_cam(desc.idVendor, desc.idProduct); + if (!cam) + continue; + + cam_infos[cnt].model = &cam->toupcam->model; + strcpy(cam_infos[cnt].displayname, cam->name); + sprintf(cam_infos[cnt].id, "tp-%d-%d-%d-%d", libusb_get_bus_number(dev), + libusb_get_device_address(dev), desc.idVendor, cam->toupcam->pid); + cnt++; + } + libusb_free_device_list(list, 1); + + return cnt; +} + +/** + * This is the entire point of this library. We need to find the Meade-branded + * toupcams and enumerate them. + */ +TOUPCAM_API(unsigned) Toupcam_EnumV2(ToupcamDeviceV2 arr[TOUPCAM_MAX]) +{ + return OEMCamEnum(arr, TOUPCAM_MAX); +} diff --git a/libmeadecam/meadecam.h b/libmeadecam/meadecam.h new file mode 100644 index 000000000..4ae6c6019 --- /dev/null +++ b/libmeadecam/meadecam.h @@ -0,0 +1,1458 @@ +#ifndef __toupcam_h__ +#define __toupcam_h__ + +/* Version: 54.23231.20230823 */ +/* + Platform & Architecture: + (1) Win32: + (a) x64: Win7 or above + (b) x86: XP SP3 or above; CPU supports SSE2 instruction set or above + (c) arm64: Win10 or above + (d) arm: Win10 or above + (2) WinRT: x64, x86, arm64, arm; Win10 or above + (3) macOS: + (a) x64+x86: macOS 10.10 or above + (b) x64+arm64: macOS 11.0 or above, support x64 and Apple silicon (such as M1, M2, etc) + (4) Linux: kernel 2.6.27 or above + (a) x64: GLIBC 2.14 or above + (b) x86: CPU supports SSE3 instruction set or above; GLIBC 2.8 or above + (c) arm64: GLIBC 2.17 or above; built by toolchain aarch64-linux-gnu (version 5.4.0) + (d) armhf: GLIBC 2.8 or above; built by toolchain arm-linux-gnueabihf (version 5.4.0) + (e) armel: GLIBC 2.8 or above; built by toolchain arm-linux-gnueabi (version 5.4.0) + (5) Android: __ANDROID_API__ >= 24 (Android 7.0); built by android-ndk-r18b; see https://developer.android.com/ndk/guides/abis + (a) arm64: arm64-v8a + (b) arm: armeabi-v7a + (c) x64: x86_64 + (d) x86 +*/ +/* + doc: + (1) en.html, English + (2) hans.html, Simplified Chinese +*/ + +#if defined(_WIN32) +#ifndef _INC_WINDOWS +#include +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(__cplusplus) && (__cplusplus >= 201402L) +#define TOUPCAM_DEPRECATED [[deprecated]] +#elif defined(_MSC_VER) +#define TOUPCAM_DEPRECATED __declspec(deprecated) +#elif defined(__GNUC__) || defined(__clang__) +#define TOUPCAM_DEPRECATED __attribute__((deprecated)) +#else +#define TOUPCAM_DEPRECATED +#endif + +#if defined(_WIN32) /* Windows */ +#pragma pack(push, 8) +#ifdef TOUPCAM_EXPORTS +#define TOUPCAM_API(x) __declspec(dllexport) x __stdcall /* in Windows, we use __stdcall calling convention, see https://docs.microsoft.com/en-us/cpp/cpp/stdcall */ +#elif !defined(TOUPCAM_NOIMPORTS) +#define TOUPCAM_API(x) __declspec(dllimport) x __stdcall +#else +#define TOUPCAM_API(x) x __stdcall +#endif +#else /* Linux or macOS */ +#define TOUPCAM_API(x) x +#if (!defined(HRESULT)) && (!defined(__COREFOUNDATION_CFPLUGINCOM__)) /* CFPlugInCOM.h */ +#define HRESULT int +#endif +#ifndef SUCCEEDED +#define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0) +#endif +#ifndef FAILED +#define FAILED(hr) (((HRESULT)(hr)) < 0) +#endif +#ifndef __stdcall +#define __stdcall +#endif +#endif + +#ifndef TDIBWIDTHBYTES +#define TDIBWIDTHBYTES(bits) ((unsigned)(((bits) + 31) & (~31)) / 8) +#endif + +/********************************************************************************/ +/* HRESULT: error code */ +/* Please note that the return value >= 0 means success */ +/* (especially S_FALSE is also successful, indicating that the internal value and the value set by the user is equivalent, which means "no operation"). */ +/* Therefore, the SUCCEEDED and FAILED macros should generally be used to determine whether the return value is successful or failed. */ +/* (Unless there are special needs, do not use "==S_OK" or "==0" to judge the return value) */ +/* */ +/* #define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0) */ +/* #define FAILED(hr) (((HRESULT)(hr)) < 0) */ +/* */ +/********************************************************************************/ +#if defined(TOUPCAM_HRESULT_ERRORCODE_NEEDED) +#define S_OK 0x00000000 /* Success */ +#define S_FALSE 0x00000001 /* Yet another success */ +#define E_UNEXPECTED 0x8000ffff /* Catastrophic failure */ +#define E_NOTIMPL 0x80004001 /* Not supported or not implemented */ +#define E_NOINTERFACE 0x80004002 +#define E_ACCESSDENIED 0x80070005 /* Permission denied */ +#define E_OUTOFMEMORY 0x8007000e /* Out of memory */ +#define E_INVALIDARG 0x80070057 /* One or more arguments are not valid */ +#define E_POINTER 0x80004003 /* Pointer that is not valid */ +#define E_FAIL 0x80004005 /* Generic failure */ +#define E_WRONG_THREAD 0x8001010e /* Call function in the wrong thread */ +#define E_GEN_FAILURE 0x8007001f /* Device not functioning */ +#define E_BUSY 0x800700aa /* The requested resource is in use */ +#define E_PENDING 0x8000000a /* The data necessary to complete this operation is not yet available */ +#define E_TIMEOUT 0x8001011f /* This operation returned because the timeout period expired */ +#endif + +/* handle */ +typedef struct Toupcam_t { int unused; } *HToupcam, *HToupCam; + +#define TOUPCAM_MAX 128 + +#define TOUPCAM_FLAG_CMOS 0x00000001 /* cmos sensor */ +#define TOUPCAM_FLAG_CCD_PROGRESSIVE 0x00000002 /* progressive ccd sensor */ +#define TOUPCAM_FLAG_CCD_INTERLACED 0x00000004 /* interlaced ccd sensor */ +#define TOUPCAM_FLAG_ROI_HARDWARE 0x00000008 /* support hardware ROI */ +#define TOUPCAM_FLAG_MONO 0x00000010 /* monochromatic */ +#define TOUPCAM_FLAG_BINSKIP_SUPPORTED 0x00000020 /* support bin/skip mode, see Toupcam_put_Mode and Toupcam_get_Mode */ +#define TOUPCAM_FLAG_USB30 0x00000040 /* usb3.0 */ +#define TOUPCAM_FLAG_TEC 0x00000080 /* Thermoelectric Cooler */ +#define TOUPCAM_FLAG_USB30_OVER_USB20 0x00000100 /* usb3.0 camera connected to usb2.0 port */ +#define TOUPCAM_FLAG_ST4 0x00000200 /* ST4 port */ +#define TOUPCAM_FLAG_GETTEMPERATURE 0x00000400 /* support to get the temperature of the sensor */ +#define TOUPCAM_FLAG_HIGH_FULLWELL 0x00000800 /* high fullwell capacity */ +#define TOUPCAM_FLAG_RAW10 0x00001000 /* pixel format, RAW 10bits */ +#define TOUPCAM_FLAG_RAW12 0x00002000 /* pixel format, RAW 12bits */ +#define TOUPCAM_FLAG_RAW14 0x00004000 /* pixel format, RAW 14bits */ +#define TOUPCAM_FLAG_RAW16 0x00008000 /* pixel format, RAW 16bits */ +#define TOUPCAM_FLAG_FAN 0x00010000 /* cooling fan */ +#define TOUPCAM_FLAG_TEC_ONOFF 0x00020000 /* Thermoelectric Cooler can be turn on or off, support to set the target temperature of TEC */ +#define TOUPCAM_FLAG_ISP 0x00040000 /* ISP (Image Signal Processing) chip */ +#define TOUPCAM_FLAG_TRIGGER_SOFTWARE 0x00080000 /* support software trigger */ +#define TOUPCAM_FLAG_TRIGGER_EXTERNAL 0x00100000 /* support external trigger */ +#define TOUPCAM_FLAG_TRIGGER_SINGLE 0x00200000 /* only support trigger single: one trigger, one image */ +#define TOUPCAM_FLAG_BLACKLEVEL 0x00400000 /* support set and get the black level */ +#define TOUPCAM_FLAG_AUTO_FOCUS 0x00800000 /* support auto focus */ +#define TOUPCAM_FLAG_BUFFER 0x01000000 /* frame buffer */ +#define TOUPCAM_FLAG_DDR 0x02000000 /* use very large capacity DDR (Double Data Rate SDRAM) for frame buffer. The capacity is not less than one full frame */ +#define TOUPCAM_FLAG_CG 0x04000000 /* Conversion Gain: HCG, LCG */ +#define TOUPCAM_FLAG_YUV411 0x08000000 /* pixel format, yuv411 */ +#define TOUPCAM_FLAG_VUYY 0x10000000 /* pixel format, yuv422, VUYY */ +#define TOUPCAM_FLAG_YUV444 0x20000000 /* pixel format, yuv444 */ +#define TOUPCAM_FLAG_RGB888 0x40000000 /* pixel format, RGB888 */ +#define TOUPCAM_FLAG_RAW8 0x80000000 /* pixel format, RAW 8 bits */ +#define TOUPCAM_FLAG_GMCY8 0x0000000100000000 /* pixel format, GMCY, 8bits */ +#define TOUPCAM_FLAG_GMCY12 0x0000000200000000 /* pixel format, GMCY, 12bits */ +#define TOUPCAM_FLAG_UYVY 0x0000000400000000 /* pixel format, yuv422, UYVY */ +#define TOUPCAM_FLAG_CGHDR 0x0000000800000000 /* Conversion Gain: HCG, LCG, HDR */ +#define TOUPCAM_FLAG_GLOBALSHUTTER 0x0000001000000000 /* global shutter */ +#define TOUPCAM_FLAG_FOCUSMOTOR 0x0000002000000000 /* support focus motor */ +#define TOUPCAM_FLAG_PRECISE_FRAMERATE 0x0000004000000000 /* support precise framerate & bandwidth, see TOUPCAM_OPTION_PRECISE_FRAMERATE & TOUPCAM_OPTION_BANDWIDTH */ +#define TOUPCAM_FLAG_HEAT 0x0000008000000000 /* support heat to prevent fogging up */ +#define TOUPCAM_FLAG_LOW_NOISE 0x0000010000000000 /* support low noise mode (Higher signal noise ratio, lower frame rate) */ +#define TOUPCAM_FLAG_LEVELRANGE_HARDWARE 0x0000020000000000 /* hardware level range, put(get)_LevelRangeV2 */ +#define TOUPCAM_FLAG_EVENT_HARDWARE 0x0000040000000000 /* hardware event, such as exposure start & stop */ +#define TOUPCAM_FLAG_LIGHTSOURCE 0x0000080000000000 /* embedded light source */ +#define TOUPCAM_FLAG_FILTERWHEEL 0x0000100000000000 /* astro filter wheel */ +#define TOUPCAM_FLAG_GIGE 0x0000200000000000 /* 1 Gigabit GigE */ +#define TOUPCAM_FLAG_10GIGE 0x0000400000000000 /* 10 Gigabit GigE */ +#define TOUPCAM_FLAG_5GIGE 0x0000800000000000 /* 5 Gigabit GigE */ +#define TOUPCAM_FLAG_25GIGE 0x0001000000000000 /* 2.5 Gigabit GigE */ +#define TOUPCAM_FLAG_AUTOFOCUSER 0x0002000000000000 /* astro auto focuser */ +#define TOUPCAM_FLAG_LIGHT_SOURCE 0x0004000000000000 /* stand alone light source */ +#define TOUPCAM_FLAG_CAMERALINK 0x0008000000000000 /* camera link */ +#define TOUPCAM_FLAG_CXP 0x0010000000000000 /* CXP: CoaXPress */ + +#define TOUPCAM_EXPOGAIN_DEF 100 /* exposure gain, default value */ +#define TOUPCAM_EXPOGAIN_MIN 100 /* exposure gain, minimum value */ +#define TOUPCAM_TEMP_DEF 6503 /* color temperature, default value */ +#define TOUPCAM_TEMP_MIN 2000 /* color temperature, minimum value */ +#define TOUPCAM_TEMP_MAX 15000 /* color temperature, maximum value */ +#define TOUPCAM_TINT_DEF 1000 /* tint */ +#define TOUPCAM_TINT_MIN 200 /* tint */ +#define TOUPCAM_TINT_MAX 2500 /* tint */ +#define TOUPCAM_HUE_DEF 0 /* hue */ +#define TOUPCAM_HUE_MIN (-180) /* hue */ +#define TOUPCAM_HUE_MAX 180 /* hue */ +#define TOUPCAM_SATURATION_DEF 128 /* saturation */ +#define TOUPCAM_SATURATION_MIN 0 /* saturation */ +#define TOUPCAM_SATURATION_MAX 255 /* saturation */ +#define TOUPCAM_BRIGHTNESS_DEF 0 /* brightness */ +#define TOUPCAM_BRIGHTNESS_MIN (-64) /* brightness */ +#define TOUPCAM_BRIGHTNESS_MAX 64 /* brightness */ +#define TOUPCAM_CONTRAST_DEF 0 /* contrast */ +#define TOUPCAM_CONTRAST_MIN (-100) /* contrast */ +#define TOUPCAM_CONTRAST_MAX 100 /* contrast */ +#define TOUPCAM_GAMMA_DEF 100 /* gamma */ +#define TOUPCAM_GAMMA_MIN 20 /* gamma */ +#define TOUPCAM_GAMMA_MAX 180 /* gamma */ +#define TOUPCAM_AETARGET_DEF 120 /* target of auto exposure */ +#define TOUPCAM_AETARGET_MIN 16 /* target of auto exposure */ +#define TOUPCAM_AETARGET_MAX 220 /* target of auto exposure */ +#define TOUPCAM_WBGAIN_DEF 0 /* white balance gain */ +#define TOUPCAM_WBGAIN_MIN (-127) /* white balance gain */ +#define TOUPCAM_WBGAIN_MAX 127 /* white balance gain */ +#define TOUPCAM_BLACKLEVEL_MIN 0 /* minimum black level */ +#define TOUPCAM_BLACKLEVEL8_MAX 31 /* maximum black level for bit depth = 8 */ +#define TOUPCAM_BLACKLEVEL10_MAX (31 * 4) /* maximum black level for bit depth = 10 */ +#define TOUPCAM_BLACKLEVEL12_MAX (31 * 16) /* maximum black level for bit depth = 12 */ +#define TOUPCAM_BLACKLEVEL14_MAX (31 * 64) /* maximum black level for bit depth = 14 */ +#define TOUPCAM_BLACKLEVEL16_MAX (31 * 256) /* maximum black level for bit depth = 16 */ +#define TOUPCAM_SHARPENING_STRENGTH_DEF 0 /* sharpening strength */ +#define TOUPCAM_SHARPENING_STRENGTH_MIN 0 /* sharpening strength */ +#define TOUPCAM_SHARPENING_STRENGTH_MAX 500 /* sharpening strength */ +#define TOUPCAM_SHARPENING_RADIUS_DEF 2 /* sharpening radius */ +#define TOUPCAM_SHARPENING_RADIUS_MIN 1 /* sharpening radius */ +#define TOUPCAM_SHARPENING_RADIUS_MAX 10 /* sharpening radius */ +#define TOUPCAM_SHARPENING_THRESHOLD_DEF 0 /* sharpening threshold */ +#define TOUPCAM_SHARPENING_THRESHOLD_MIN 0 /* sharpening threshold */ +#define TOUPCAM_SHARPENING_THRESHOLD_MAX 255 /* sharpening threshold */ +#define TOUPCAM_AUTOEXPO_THRESHOLD_DEF 5 /* auto exposure threshold */ +#define TOUPCAM_AUTOEXPO_THRESHOLD_MIN 2 /* auto exposure threshold */ +#define TOUPCAM_AUTOEXPO_THRESHOLD_MAX 15 /* auto exposure threshold */ +#define TOUPCAM_BANDWIDTH_DEF 100 /* bandwidth */ +#define TOUPCAM_BANDWIDTH_MIN 1 /* bandwidth */ +#define TOUPCAM_BANDWIDTH_MAX 100 /* bandwidth */ +#define TOUPCAM_DENOISE_DEF 0 /* denoise */ +#define TOUPCAM_DENOISE_MIN 0 /* denoise */ +#define TOUPCAM_DENOISE_MAX 100 /* denoise */ +#define TOUPCAM_TEC_TARGET_MIN (-500) /* TEC target: -50.0 degrees Celsius */ +#define TOUPCAM_TEC_TARGET_DEF 100 /* 0.0 degrees Celsius */ +#define TOUPCAM_TEC_TARGET_MAX 400 /* TEC target: 40.0 degrees Celsius */ +#define TOUPCAM_HEARTBEAT_MIN 100 /* millisecond */ +#define TOUPCAM_HEARTBEAT_MAX 10000 /* millisecond */ +#define TOUPCAM_AE_PERCENT_MIN 0 /* auto exposure percent, 0 => full roi average */ +#define TOUPCAM_AE_PERCENT_MAX 100 +#define TOUPCAM_AE_PERCENT_DEF 10 +#define TOUPCAM_NOPACKET_TIMEOUT_MIN 500 /* no packet timeout minimum: 500ms */ +#define TOUPCAM_NOFRAME_TIMEOUT_MIN 500 /* no frame timeout minimum: 500ms */ +#define TOUPCAM_DYNAMIC_DEFECT_T1_MIN 10 /* dynamic defect pixel correction, threshold, means: 1.0 */ +#define TOUPCAM_DYNAMIC_DEFECT_T1_MAX 100 /* means: 10.0 */ +#define TOUPCAM_DYNAMIC_DEFECT_T1_DEF 13 /* means: 1.3 */ +#define TOUPCAM_DYNAMIC_DEFECT_T2_MIN 0 /* dynamic defect pixel correction, value, means: 0.00 */ +#define TOUPCAM_DYNAMIC_DEFECT_T2_MAX 100 /* means: 1.00 */ +#define TOUPCAM_DYNAMIC_DEFECT_T2_DEF 100 +#define TOUPCAM_HDR_K_MIN 1 /* HDR synthesize */ +#define TOUPCAM_HDR_K_MAX 25500 +#define TOUPCAM_HDR_B_MIN 0 +#define TOUPCAM_HDR_B_MAX 65535 +#define TOUPCAM_HDR_THRESHOLD_MIN 0 +#define TOUPCAM_HDR_THRESHOLD_MAX 4094 + +typedef struct { + unsigned width; + unsigned height; +} ToupcamResolution; + +/* In Windows platform, we always use UNICODE wchar_t */ +/* In Linux or macOS, we use char */ + +typedef struct { +#if defined(_WIN32) + const wchar_t* name; /* model name, in Windows, we use unicode */ +#else + const char* name; /* model name */ +#endif + unsigned long long flag; /* TOUPCAM_FLAG_xxx, 64 bits */ + unsigned maxspeed; /* number of speed level, same as Toupcam_get_MaxSpeed(), speed range = [0, maxspeed], closed interval */ + unsigned preview; /* number of preview resolution, same as Toupcam_get_ResolutionNumber() */ + unsigned still; /* number of still resolution, same as Toupcam_get_StillResolutionNumber() */ + unsigned maxfanspeed; /* maximum fan speed, fan speed range = [0, max], closed interval */ + unsigned ioctrol; /* number of input/output control */ + float xpixsz; /* physical pixel size in micrometer */ + float ypixsz; /* physical pixel size in micrometer */ + ToupcamResolution res[16]; +} ToupcamModelV2; /* camera model v2 */ + +typedef struct { +#if defined(_WIN32) + wchar_t displayname[64]; /* display name */ + wchar_t id[64]; /* unique and opaque id of a connected camera, for Toupcam_Open */ +#else + char displayname[64]; /* display name */ + char id[64]; /* unique and opaque id of a connected camera, for Toupcam_Open */ +#endif + const ToupcamModelV2* model; +} ToupcamDeviceV2; /* camera instance for enumerating */ + +/* + get the version of this dll/so/dylib, which is: 54.23231.20230823 +*/ +#if defined(_WIN32) +TOUPCAM_API(const wchar_t*) Toupcam_Version(); +#else +TOUPCAM_API(const char*) Toupcam_Version(); +#endif + +/* + enumerate the cameras connected to the computer, return the number of enumerated. + + ToupcamDeviceV2 arr[TOUPCAM_MAX]; + unsigned cnt = Toupcam_EnumV2(arr); + for (unsigned i = 0; i < cnt; ++i) + ... + + if arr == NULL, then, only the number is returned. + Toupcam_Enum is obsolete. +*/ +TOUPCAM_API(unsigned) Toupcam_EnumV2(ToupcamDeviceV2 arr[TOUPCAM_MAX]); + +/* use the camId of ToupcamDeviceV2, which is enumerated by Toupcam_EnumV2. + if camId is NULL, Toupcam_Open will open the first enumerated camera. + For the issue of opening the camera on Android, please refer to the documentation +*/ +#if defined(_WIN32) +TOUPCAM_API(HToupcam) Toupcam_Open(const wchar_t* camId); +#else +TOUPCAM_API(HToupcam) Toupcam_Open(const char* camId); +#endif + +/* + the same with Toupcam_Open, but use the index as the parameter. such as: + index == 0, open the first camera, + index == 1, open the second camera, + etc +*/ +TOUPCAM_API(HToupcam) Toupcam_OpenByIndex(unsigned index); + +/* close the handle. After it is closed, never use the handle any more. */ +TOUPCAM_API(void) Toupcam_Close(HToupcam h); + +#define TOUPCAM_EVENT_EXPOSURE 0x0001 /* exposure time or gain changed */ +#define TOUPCAM_EVENT_TEMPTINT 0x0002 /* white balance changed, Temp/Tint mode */ +#define TOUPCAM_EVENT_IMAGE 0x0004 /* live image arrived, use Toupcam_PullImageXXXX to get this image */ +#define TOUPCAM_EVENT_STILLIMAGE 0x0005 /* snap (still) frame arrived, use Toupcam_PullStillImageXXXX to get this frame */ +#define TOUPCAM_EVENT_WBGAIN 0x0006 /* white balance changed, RGB Gain mode */ +#define TOUPCAM_EVENT_TRIGGERFAIL 0x0007 /* trigger failed */ +#define TOUPCAM_EVENT_BLACK 0x0008 /* black balance changed */ +#define TOUPCAM_EVENT_FFC 0x0009 /* flat field correction status changed */ +#define TOUPCAM_EVENT_DFC 0x000a /* dark field correction status changed */ +#define TOUPCAM_EVENT_ROI 0x000b /* roi changed */ +#define TOUPCAM_EVENT_LEVELRANGE 0x000c /* level range changed */ +#define TOUPCAM_EVENT_AUTOEXPO_CONV 0x000d /* auto exposure convergence */ +#define TOUPCAM_EVENT_AUTOEXPO_CONVFAIL 0x000e /* auto exposure once mode convergence failed */ +#define TOUPCAM_EVENT_ERROR 0x0080 /* generic error */ +#define TOUPCAM_EVENT_DISCONNECTED 0x0081 /* camera disconnected */ +#define TOUPCAM_EVENT_NOFRAMETIMEOUT 0x0082 /* no frame timeout error */ +#define TOUPCAM_EVENT_AFFEEDBACK 0x0083 /* auto focus feedback information */ +#define TOUPCAM_EVENT_FOCUSPOS 0x0084 /* focus positon */ +#define TOUPCAM_EVENT_NOPACKETTIMEOUT 0x0085 /* no packet timeout */ +#define TOUPCAM_EVENT_EXPO_START 0x4000 /* hardware event: exposure start */ +#define TOUPCAM_EVENT_EXPO_STOP 0x4001 /* hardware event: exposure stop */ +#define TOUPCAM_EVENT_TRIGGER_ALLOW 0x4002 /* hardware event: next trigger allow */ +#define TOUPCAM_EVENT_HEARTBEAT 0x4003 /* hardware event: heartbeat, can be used to monitor whether the camera is alive */ +#define TOUPCAM_EVENT_TRIGGER_IN 0x4004 /* hardware event: trigger in */ +#define TOUPCAM_EVENT_FACTORY 0x8001 /* restore factory settings */ + +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_StartPullModeWithWndMsg(HToupcam h, HWND hWnd, UINT nMsg); +#endif + +/* Do NOT call Toupcam_Close, Toupcam_Stop in this callback context, it deadlocks. */ +/* Do NOT call Toupcam_put_Option with TOUPCAM_OPTION_TRIGGER, TOUPCAM_OPTION_BITDEPTH, TOUPCAM_OPTION_PIXEL_FORMAT, TOUPCAM_OPTION_BINNING, TOUPCAM_OPTION_ROTATE, it will fail with error code E_WRONG_THREAD */ +typedef void (__stdcall* PTOUPCAM_EVENT_CALLBACK)(unsigned nEvent, void* ctxEvent); +TOUPCAM_API(HRESULT) Toupcam_StartPullModeWithCallback(HToupcam h, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent); + +#define TOUPCAM_FRAMEINFO_FLAG_SEQ 0x0001 /* frame sequence number */ +#define TOUPCAM_FRAMEINFO_FLAG_TIMESTAMP 0x0002 /* timestamp */ +#define TOUPCAM_FRAMEINFO_FLAG_EXPOTIME 0x0004 /* exposure time */ +#define TOUPCAM_FRAMEINFO_FLAG_EXPOGAIN 0x0008 /* exposure gain */ +#define TOUPCAM_FRAMEINFO_FLAG_BLACKLEVEL 0x0010 /* black level */ +#define TOUPCAM_FRAMEINFO_FLAG_SHUTTERSEQ 0x0020 /* sequence shutter counter */ +#define TOUPCAM_FRAMEINFO_FLAG_STILL 0x8000 /* still image */ + +typedef struct { + unsigned width; + unsigned height; + unsigned flag; /* TOUPCAM_FRAMEINFO_FLAG_xxxx */ + unsigned seq; /* frame sequence number */ + unsigned long long timestamp; /* microsecond */ + unsigned shutterseq; /* sequence shutter counter */ + unsigned expotime; /* exposure time */ + unsigned short expogain; /* exposure gain */ + unsigned short blacklevel; /* black level */ +} ToupcamFrameInfoV3; + +/* + nWaitMS: The timeout interval, in milliseconds. If a nonzero value is specified, the function waits until the image is ok or the interval elapses. + If nWaitMS is zero, the function does not enter a wait state if the image is not available; it always returns immediately; this is equal to Toupcam_PullImageV3. + bStill: to pull still image, set to 1, otherwise 0 + bits: 24 (RGB24), 32 (RGB32), 48 (RGB48), 8 (Grey), 16 (Grey), 64 (RGB64). + In RAW mode, this parameter is ignored. + bits = 0 means using default bits base on TOUPCAM_OPTION_RGB. + When bits and TOUPCAM_OPTION_RGB are inconsistent, format conversion will have to be performed, resulting in loss of efficiency. + See the following bits and TOUPCAM_OPTION_RGB correspondence table: + ---------------------------------------------------------------------------------------------------------------------- + | TOUPCAM_OPTION_RGB | 0 (RGB24) | 1 (RGB48) | 2 (RGB32) | 3 (Grey8) | 4 (Grey16) | 5 (RGB64) | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 0 | 24 | 48 | 32 | 8 | 16 | 64 | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 24 | 24 | NA | Convert to 24 | Convert to 24 | NA | NA | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 32 | Convert to 32 | NA | 32 | Convert to 32 | NA | NA | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 48 | NA | 48 | NA | NA | Convert to 48 | Convert to 48 | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 8 | Convert to 8 | NA | Convert to 8 | 8 | NA | NA | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + | bits = 16 | NA | Convert to 16 | NA | NA | 16 | Convert to 16 | + |--------------------|---------------|-----------|-------------------|---------------|---------------|---------------| + | bits = 64 | NA | Convert to 64 | NA | NA | Convert to 64 | 64 | + |--------------------|---------------|---------------|---------------|---------------|---------------|---------------| + + rowPitch: The distance from one row to the next row. rowPitch = 0 means using the default row pitch. rowPitch = -1 means zero padding, see below: + ---------------------------------------------------------------------------------------------- + | format | 0 means default row pitch | -1 means zero padding | + |------------------------------------|-------------------------------|-----------------------| + | RGB | RGB24 | TDIBWIDTHBYTES(24 * Width) | Width * 3 | + | | RGB32 | Width * 4 | Width * 4 | + | | RGB48 | TDIBWIDTHBYTES(48 * Width) | Width * 6 | + | | GREY8 | TDIBWIDTHBYTES(8 * Width) | Width | + | | GREY16 | TDIBWIDTHBYTES(16 * Width) | Width * 2 | + | | RGB64 | Width * 8 | Width * 8 | + |-----------|------------------------|-------------------------------|-----------------------| + | RAW | 8bits Mode | Width | Width | + | | 10/12/14/16bits Mode | Width * 2 | Width * 2 | + |-----------|------------------------|-------------------------------|-----------------------| +*/ +TOUPCAM_API(HRESULT) Toupcam_PullImageV3(HToupcam h, void* pImageData, int bStill, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo); +TOUPCAM_API(HRESULT) Toupcam_WaitImageV3(HToupcam h, unsigned nWaitMS, void* pImageData, int bStill, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo); + +typedef struct { + unsigned width; + unsigned height; + unsigned flag; /* TOUPCAM_FRAMEINFO_FLAG_xxxx */ + unsigned seq; /* frame sequence number */ + unsigned long long timestamp; /* microsecond */ +} ToupcamFrameInfoV2; + +TOUPCAM_API(HRESULT) Toupcam_PullImageV2(HToupcam h, void* pImageData, int bits, ToupcamFrameInfoV2* pInfo); +TOUPCAM_API(HRESULT) Toupcam_PullStillImageV2(HToupcam h, void* pImageData, int bits, ToupcamFrameInfoV2* pInfo); +TOUPCAM_API(HRESULT) Toupcam_PullImageWithRowPitchV2(HToupcam h, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV2* pInfo); +TOUPCAM_API(HRESULT) Toupcam_PullStillImageWithRowPitchV2(HToupcam h, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV2* pInfo); + +TOUPCAM_API(HRESULT) Toupcam_PullImage(HToupcam h, void* pImageData, int bits, unsigned* pnWidth, unsigned* pnHeight); +TOUPCAM_API(HRESULT) Toupcam_PullStillImage(HToupcam h, void* pImageData, int bits, unsigned* pnWidth, unsigned* pnHeight); +TOUPCAM_API(HRESULT) Toupcam_PullImageWithRowPitch(HToupcam h, void* pImageData, int bits, int rowPitch, unsigned* pnWidth, unsigned* pnHeight); +TOUPCAM_API(HRESULT) Toupcam_PullStillImageWithRowPitch(HToupcam h, void* pImageData, int bits, int rowPitch, unsigned* pnWidth, unsigned* pnHeight); + +/* + (NULL == pData) means something error + ctxData is the callback context which is passed by Toupcam_StartPushModeV3 + bSnap: TRUE if Toupcam_Snap + + funData is callbacked by an internal thread of toupcam.dll, so please pay attention to multithread problem. + Do NOT call Toupcam_Close, Toupcam_Stop in this callback context, it deadlocks. +*/ +typedef void (__stdcall* PTOUPCAM_DATA_CALLBACK_V4)(const void* pData, const ToupcamFrameInfoV3* pInfo, int bSnap, void* ctxData); +TOUPCAM_API(HRESULT) Toupcam_StartPushModeV4(HToupcam h, PTOUPCAM_DATA_CALLBACK_V4 funData, void* ctxData, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent); + +typedef void (__stdcall* PTOUPCAM_DATA_CALLBACK_V3)(const void* pData, const ToupcamFrameInfoV2* pInfo, int bSnap, void* ctxData); +TOUPCAM_API(HRESULT) Toupcam_StartPushModeV3(HToupcam h, PTOUPCAM_DATA_CALLBACK_V3 funData, void* ctxData, PTOUPCAM_EVENT_CALLBACK funEvent, void* ctxEvent); + +TOUPCAM_API(HRESULT) Toupcam_Stop(HToupcam h); +TOUPCAM_API(HRESULT) Toupcam_Pause(HToupcam h, int bPause); /* 1 => pause, 0 => continue */ + +/* for pull mode: TOUPCAM_EVENT_STILLIMAGE, and then Toupcam_PullStillImageXXXX/Toupcam_PullImageV3 + for push mode: the snapped image will be return by PTOUPCAM_DATA_CALLBACK(V2/V3), with the parameter 'bSnap' set to 'TRUE' + nResolutionIndex = 0xffffffff means use the cureent preview resolution +*/ +TOUPCAM_API(HRESULT) Toupcam_Snap(HToupcam h, unsigned nResolutionIndex); /* still image snap */ +TOUPCAM_API(HRESULT) Toupcam_SnapN(HToupcam h, unsigned nResolutionIndex, unsigned nNumber); /* multiple still image snap */ +TOUPCAM_API(HRESULT) Toupcam_SnapR(HToupcam h, unsigned nResolutionIndex, unsigned nNumber); /* multiple RAW still image snap */ +/* + soft trigger: + nNumber: 0xffff: trigger continuously + 0: cancel trigger + others: number of images to be triggered +*/ +TOUPCAM_API(HRESULT) Toupcam_Trigger(HToupcam h, unsigned short nNumber); + +/* + trigger synchronously + nTimeout: 0: by default, exposure * 102% + 4000 milliseconds + 0xffffffff: wait infinite + other: milliseconds to wait +*/ +TOUPCAM_API(HRESULT) Toupcam_TriggerSync(HToupcam h, unsigned nTimeout, void* pImageData, int bits, int rowPitch, ToupcamFrameInfoV3* pInfo); + +/* + put_Size, put_eSize, can be used to set the video output resolution BEFORE Toupcam_StartXXXX. + put_Size use width and height parameters, put_eSize use the index parameter. + for example, UCMOS03100KPA support the following resolutions: + index 0: 2048, 1536 + index 1: 1024, 768 + index 2: 680, 510 + so, we can use put_Size(h, 1024, 768) or put_eSize(h, 1). Both have the same effect. +*/ +TOUPCAM_API(HRESULT) Toupcam_put_Size(HToupcam h, int nWidth, int nHeight); +TOUPCAM_API(HRESULT) Toupcam_get_Size(HToupcam h, int* pWidth, int* pHeight); +TOUPCAM_API(HRESULT) Toupcam_put_eSize(HToupcam h, unsigned nResolutionIndex); +TOUPCAM_API(HRESULT) Toupcam_get_eSize(HToupcam h, unsigned* pnResolutionIndex); + +/* + final image size after ROI, rotate, binning +*/ +TOUPCAM_API(HRESULT) Toupcam_get_FinalSize(HToupcam h, int* pWidth, int* pHeight); + +TOUPCAM_API(HRESULT) Toupcam_get_ResolutionNumber(HToupcam h); +TOUPCAM_API(HRESULT) Toupcam_get_Resolution(HToupcam h, unsigned nResolutionIndex, int* pWidth, int* pHeight); +/* + numerator/denominator, such as: 1/1, 1/2, 1/3 +*/ +TOUPCAM_API(HRESULT) Toupcam_get_ResolutionRatio(HToupcam h, unsigned nResolutionIndex, int* pNumerator, int* pDenominator); +TOUPCAM_API(HRESULT) Toupcam_get_Field(HToupcam h); + +/* +see: http://www.siliconimaging.com/RGB%20Bayer.htm +FourCC: + MAKEFOURCC('G', 'B', 'R', 'G') + MAKEFOURCC('R', 'G', 'G', 'B') + MAKEFOURCC('B', 'G', 'G', 'R') + MAKEFOURCC('G', 'R', 'B', 'G') + MAKEFOURCC('Y', 'Y', 'Y', 'Y'), monochromatic sensor + MAKEFOURCC('Y', '4', '1', '1'), yuv411 + MAKEFOURCC('V', 'U', 'Y', 'Y'), yuv422 + MAKEFOURCC('U', 'Y', 'V', 'Y'), yuv422 + MAKEFOURCC('Y', '4', '4', '4'), yuv444 + MAKEFOURCC('R', 'G', 'B', '8'), RGB888 + +#ifndef MAKEFOURCC +#define MAKEFOURCC(a, b, c, d) ((unsigned)(unsigned char)(a) | ((unsigned)(unsigned char)(b) << 8) | ((unsigned)(unsigned char)(c) << 16) | ((unsigned)(unsigned char)(d) << 24)) +#endif +*/ +TOUPCAM_API(HRESULT) Toupcam_get_RawFormat(HToupcam h, unsigned* pFourCC, unsigned* pBitsPerPixel); + +/* + ------------------------------------------------------------------| + | Parameter | Range | Default | + |-----------------------------------------------------------------| + | Auto Exposure Target | 10~220 | 120 | + | Exposure Gain | 100~ | 100 | + | Temp | 2000~15000 | 6503 | + | Tint | 200~2500 | 1000 | + | LevelRange | 0~255 | Low = 0, High = 255 | + | Contrast | -100~100 | 0 | + | Hue | -180~180 | 0 | + | Saturation | 0~255 | 128 | + | Brightness | -64~64 | 0 | + | Gamma | 20~180 | 100 | + | WBGain | -127~127 | 0 | + ------------------------------------------------------------------| +*/ + +#ifndef __TOUPCAM_CALLBACK_DEFINED__ +#define __TOUPCAM_CALLBACK_DEFINED__ +typedef void (__stdcall* PITOUPCAM_EXPOSURE_CALLBACK)(void* ctxExpo); /* auto exposure */ +typedef void (__stdcall* PITOUPCAM_WHITEBALANCE_CALLBACK)(const int aGain[3], void* ctxWB); /* once white balance, RGB Gain mode */ +typedef void (__stdcall* PITOUPCAM_BLACKBALANCE_CALLBACK)(const unsigned short aSub[3], void* ctxBB); /* once black balance */ +typedef void (__stdcall* PITOUPCAM_TEMPTINT_CALLBACK)(const int nTemp, const int nTint, void* ctxTT); /* once white balance, Temp/Tint Mode */ +typedef void (__stdcall* PITOUPCAM_HISTOGRAM_CALLBACK)(const float aHistY[256], const float aHistR[256], const float aHistG[256], const float aHistB[256], void* ctxHistogram); +typedef void (__stdcall* PITOUPCAM_CHROME_CALLBACK)(void* ctxChrome); +typedef void (__stdcall* PITOUPCAM_PROGRESS)(int percent, void* ctxProgress); +#endif +/* +* nFlag & 0x00008000: mono or color +* nFlag & 0x0f: bitdepth +* so the size of aHist is: + int arraySize = 1 << (nFlag & 0x0f); + if ((nFlag & 0x00008000) == 0) + arraySize *= 3; +*/ +typedef void (__stdcall* PITOUPCAM_HISTOGRAM_CALLBACKV2)(const unsigned* aHist, unsigned nFlag, void* ctxHistogramV2); + +/* +* bAutoExposure: +* 0: disable auto exposure +* 1: auto exposure continue mode +* 2: auto exposure once mode +*/ +TOUPCAM_API(HRESULT) Toupcam_get_AutoExpoEnable(HToupcam h, int* bAutoExposure); +TOUPCAM_API(HRESULT) Toupcam_put_AutoExpoEnable(HToupcam h, int bAutoExposure); + +TOUPCAM_API(HRESULT) Toupcam_get_AutoExpoTarget(HToupcam h, unsigned short* Target); +TOUPCAM_API(HRESULT) Toupcam_put_AutoExpoTarget(HToupcam h, unsigned short Target); + +/*set the maximum/minimal auto exposure time and agin. The default maximum auto exposure time is 350ms */ +TOUPCAM_API(HRESULT) Toupcam_put_AutoExpoRange(HToupcam h, unsigned maxTime, unsigned minTime, unsigned short maxGain, unsigned short minGain); +TOUPCAM_API(HRESULT) Toupcam_get_AutoExpoRange(HToupcam h, unsigned* maxTime, unsigned* minTime, unsigned short* maxGain, unsigned short* minGain); +TOUPCAM_API(HRESULT) Toupcam_put_MaxAutoExpoTimeAGain(HToupcam h, unsigned maxTime, unsigned short maxGain); +TOUPCAM_API(HRESULT) Toupcam_get_MaxAutoExpoTimeAGain(HToupcam h, unsigned* maxTime, unsigned short* maxGain); +TOUPCAM_API(HRESULT) Toupcam_put_MinAutoExpoTimeAGain(HToupcam h, unsigned minTime, unsigned short minGain); +TOUPCAM_API(HRESULT) Toupcam_get_MinAutoExpoTimeAGain(HToupcam h, unsigned* minTime, unsigned short* minGain); + +TOUPCAM_API(HRESULT) Toupcam_get_ExpoTime(HToupcam h, unsigned* Time); /* in microseconds */ +TOUPCAM_API(HRESULT) Toupcam_put_ExpoTime(HToupcam h, unsigned Time); /* in microseconds */ +TOUPCAM_API(HRESULT) Toupcam_get_RealExpoTime(HToupcam h, unsigned* Time); /* in microseconds, based on 50HZ/60HZ/DC */ +TOUPCAM_API(HRESULT) Toupcam_get_ExpTimeRange(HToupcam h, unsigned* nMin, unsigned* nMax, unsigned* nDef); + +TOUPCAM_API(HRESULT) Toupcam_get_ExpoAGain(HToupcam h, unsigned short* Gain); /* percent, such as 300 */ +TOUPCAM_API(HRESULT) Toupcam_put_ExpoAGain(HToupcam h, unsigned short Gain); /* percent */ +TOUPCAM_API(HRESULT) Toupcam_get_ExpoAGainRange(HToupcam h, unsigned short* nMin, unsigned short* nMax, unsigned short* nDef); + +/* Auto White Balance "Once", Temp/Tint Mode */ +TOUPCAM_API(HRESULT) Toupcam_AwbOnce(HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT); /* auto white balance "once". This function must be called AFTER Toupcam_StartXXXX */ + +/* Auto White Balance "Once", RGB Gain Mode */ +TOUPCAM_API(HRESULT) Toupcam_AwbInit(HToupcam h, PITOUPCAM_WHITEBALANCE_CALLBACK funWB, void* ctxWB); + +/* White Balance, Temp/Tint mode */ +TOUPCAM_API(HRESULT) Toupcam_put_TempTint(HToupcam h, int nTemp, int nTint); +TOUPCAM_API(HRESULT) Toupcam_get_TempTint(HToupcam h, int* nTemp, int* nTint); + +/* White Balance, RGB Gain mode */ +TOUPCAM_API(HRESULT) Toupcam_put_WhiteBalanceGain(HToupcam h, int aGain[3]); +TOUPCAM_API(HRESULT) Toupcam_get_WhiteBalanceGain(HToupcam h, int aGain[3]); + +/* Black Balance */ +TOUPCAM_API(HRESULT) Toupcam_AbbOnce(HToupcam h, PITOUPCAM_BLACKBALANCE_CALLBACK funBB, void* ctxBB); /* auto black balance "once". This function must be called AFTER Toupcam_StartXXXX */ +TOUPCAM_API(HRESULT) Toupcam_put_BlackBalance(HToupcam h, unsigned short aSub[3]); +TOUPCAM_API(HRESULT) Toupcam_get_BlackBalance(HToupcam h, unsigned short aSub[3]); + +/* Flat Field Correction */ +TOUPCAM_API(HRESULT) Toupcam_FfcOnce(HToupcam h); +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_FfcExport(HToupcam h, const wchar_t* filepath); +TOUPCAM_API(HRESULT) Toupcam_FfcImport(HToupcam h, const wchar_t* filepath); +#else +TOUPCAM_API(HRESULT) Toupcam_FfcExport(HToupcam h, const char* filepath); +TOUPCAM_API(HRESULT) Toupcam_FfcImport(HToupcam h, const char* filepath); +#endif + +/* Dark Field Correction */ +TOUPCAM_API(HRESULT) Toupcam_DfcOnce(HToupcam h); + +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_DfcExport(HToupcam h, const wchar_t* filepath); +TOUPCAM_API(HRESULT) Toupcam_DfcImport(HToupcam h, const wchar_t* filepath); +#else +TOUPCAM_API(HRESULT) Toupcam_DfcExport(HToupcam h, const char* filepath); +TOUPCAM_API(HRESULT) Toupcam_DfcImport(HToupcam h, const char* filepath); +#endif + +TOUPCAM_API(HRESULT) Toupcam_put_Hue(HToupcam h, int Hue); +TOUPCAM_API(HRESULT) Toupcam_get_Hue(HToupcam h, int* Hue); +TOUPCAM_API(HRESULT) Toupcam_put_Saturation(HToupcam h, int Saturation); +TOUPCAM_API(HRESULT) Toupcam_get_Saturation(HToupcam h, int* Saturation); +TOUPCAM_API(HRESULT) Toupcam_put_Brightness(HToupcam h, int Brightness); +TOUPCAM_API(HRESULT) Toupcam_get_Brightness(HToupcam h, int* Brightness); +TOUPCAM_API(HRESULT) Toupcam_get_Contrast(HToupcam h, int* Contrast); +TOUPCAM_API(HRESULT) Toupcam_put_Contrast(HToupcam h, int Contrast); +TOUPCAM_API(HRESULT) Toupcam_get_Gamma(HToupcam h, int* Gamma); /* percent */ +TOUPCAM_API(HRESULT) Toupcam_put_Gamma(HToupcam h, int Gamma); /* percent */ + +TOUPCAM_API(HRESULT) Toupcam_get_Chrome(HToupcam h, int* bChrome); /* 1 => monochromatic mode, 0 => color mode */ +TOUPCAM_API(HRESULT) Toupcam_put_Chrome(HToupcam h, int bChrome); + +TOUPCAM_API(HRESULT) Toupcam_get_VFlip(HToupcam h, int* bVFlip); /* vertical flip */ +TOUPCAM_API(HRESULT) Toupcam_put_VFlip(HToupcam h, int bVFlip); +TOUPCAM_API(HRESULT) Toupcam_get_HFlip(HToupcam h, int* bHFlip); +TOUPCAM_API(HRESULT) Toupcam_put_HFlip(HToupcam h, int bHFlip); /* horizontal flip */ + +TOUPCAM_API(HRESULT) Toupcam_get_Negative(HToupcam h, int* bNegative); /* negative film */ +TOUPCAM_API(HRESULT) Toupcam_put_Negative(HToupcam h, int bNegative); + +TOUPCAM_API(HRESULT) Toupcam_put_Speed(HToupcam h, unsigned short nSpeed); +TOUPCAM_API(HRESULT) Toupcam_get_Speed(HToupcam h, unsigned short* pSpeed); +TOUPCAM_API(HRESULT) Toupcam_get_MaxSpeed(HToupcam h); /* get the maximum speed, see "Frame Speed Level", the speed range = [0, max], closed interval */ + +TOUPCAM_API(HRESULT) Toupcam_get_FanMaxSpeed(HToupcam h); /* get the maximum fan speed, the fan speed range = [0, max], closed interval */ + +TOUPCAM_API(HRESULT) Toupcam_get_MaxBitDepth(HToupcam h); /* get the max bit depth of this camera, such as 8, 10, 12, 14, 16 */ + +/* power supply of lighting: + 0 => 60HZ AC + 1 => 50Hz AC + 2 => DC +*/ +TOUPCAM_API(HRESULT) Toupcam_put_HZ(HToupcam h, int nHZ); +TOUPCAM_API(HRESULT) Toupcam_get_HZ(HToupcam h, int* nHZ); + +TOUPCAM_API(HRESULT) Toupcam_put_Mode(HToupcam h, int bSkip); /* skip or bin */ +TOUPCAM_API(HRESULT) Toupcam_get_Mode(HToupcam h, int* bSkip); /* If the model don't support bin/skip mode, return E_NOTIMPL */ + +#if !defined(_WIN32) +#ifndef __RECT_DEFINED__ +#define __RECT_DEFINED__ +typedef struct { + int left; + int top; + int right; + int bottom; +} RECT, *PRECT; +#endif +#endif + +TOUPCAM_API(HRESULT) Toupcam_put_AWBAuxRect(HToupcam h, const RECT* pAuxRect); /* auto white balance ROI */ +TOUPCAM_API(HRESULT) Toupcam_get_AWBAuxRect(HToupcam h, RECT* pAuxRect); +TOUPCAM_API(HRESULT) Toupcam_put_AEAuxRect(HToupcam h, const RECT* pAuxRect); /* auto exposure ROI */ +TOUPCAM_API(HRESULT) Toupcam_get_AEAuxRect(HToupcam h, RECT* pAuxRect); + +TOUPCAM_API(HRESULT) Toupcam_put_ABBAuxRect(HToupcam h, const RECT* pAuxRect); /* auto black balance ROI */ +TOUPCAM_API(HRESULT) Toupcam_get_ABBAuxRect(HToupcam h, RECT* pAuxRect); + +/* + S_FALSE: color mode + S_OK: mono mode, such as EXCCD00300KMA and UHCCD01400KMA +*/ +TOUPCAM_API(HRESULT) Toupcam_get_MonoMode(HToupcam h); + +TOUPCAM_API(HRESULT) Toupcam_get_StillResolutionNumber(HToupcam h); +TOUPCAM_API(HRESULT) Toupcam_get_StillResolution(HToupcam h, unsigned nResolutionIndex, int* pWidth, int* pHeight); + +/* 0: stop grab frame when frame buffer deque is full, until the frames in the queue are pulled away and the queue is not full + 1: realtime + use minimum frame buffer. When new frame arrive, drop all the pending frame regardless of whether the frame buffer is full. + If DDR present, also limit the DDR frame buffer to only one frame. + 2: soft realtime + Drop the oldest frame when the queue is full and then enqueue the new frame + default: 0 +*/ +TOUPCAM_API(HRESULT) Toupcam_put_RealTime(HToupcam h, int val); +TOUPCAM_API(HRESULT) Toupcam_get_RealTime(HToupcam h, int* val); + +/* discard the current internal frame cache. + If DDR present, also discard the frames in the DDR. + Toupcam_Flush is obsolete, recommend using Toupcam_put_Option(h, TOUPCAM_OPTION_FLUSH, 3) +*/ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_Flush(HToupcam h); + +/* get the temperature of the sensor, in 0.1 degrees Celsius (32 means 3.2 degrees Celsius, -35 means -3.5 degree Celsius) + return E_NOTIMPL if not supported +*/ +TOUPCAM_API(HRESULT) Toupcam_get_Temperature(HToupcam h, short* pTemperature); + +/* set the target temperature of the sensor or TEC, in 0.1 degrees Celsius (32 means 3.2 degrees Celsius, -35 means -3.5 degree Celsius) + return E_NOTIMPL if not supported +*/ +TOUPCAM_API(HRESULT) Toupcam_put_Temperature(HToupcam h, short nTemperature); + +/* + get the revision +*/ +TOUPCAM_API(HRESULT) Toupcam_get_Revision(HToupcam h, unsigned short* pRevision); + +/* + get the serial number which is always 32 chars which is zero-terminated such as "TP110826145730ABCD1234FEDC56787" +*/ +TOUPCAM_API(HRESULT) Toupcam_get_SerialNumber(HToupcam h, char sn[32]); + +/* + get the camera firmware version, such as: 3.2.1.20140922 +*/ +TOUPCAM_API(HRESULT) Toupcam_get_FwVersion(HToupcam h, char fwver[16]); + +/* + get the camera hardware version, such as: 3.12 +*/ +TOUPCAM_API(HRESULT) Toupcam_get_HwVersion(HToupcam h, char hwver[16]); + +/* + get the production date, such as: 20150327, YYYYMMDD, (YYYY: year, MM: month, DD: day) +*/ +TOUPCAM_API(HRESULT) Toupcam_get_ProductionDate(HToupcam h, char pdate[10]); + +/* + get the FPGA version, such as: 1.13 +*/ +TOUPCAM_API(HRESULT) Toupcam_get_FpgaVersion(HToupcam h, char fpgaver[16]); + +/* + get the sensor pixel size, such as: 2.4um x 2.4um +*/ +TOUPCAM_API(HRESULT) Toupcam_get_PixelSize(HToupcam h, unsigned nResolutionIndex, float* x, float* y); + +/* software level range */ +TOUPCAM_API(HRESULT) Toupcam_put_LevelRange(HToupcam h, unsigned short aLow[4], unsigned short aHigh[4]); +TOUPCAM_API(HRESULT) Toupcam_get_LevelRange(HToupcam h, unsigned short aLow[4], unsigned short aHigh[4]); + +/* hardware level range mode */ +#define TOUPCAM_LEVELRANGE_MANUAL 0x0000 /* manual */ +#define TOUPCAM_LEVELRANGE_ONCE 0x0001 /* once */ +#define TOUPCAM_LEVELRANGE_CONTINUE 0x0002 /* continue */ +#define TOUPCAM_LEVELRANGE_ROI 0xffff /* update roi rect only */ +TOUPCAM_API(HRESULT) Toupcam_put_LevelRangeV2(HToupcam h, unsigned short mode, const RECT* pRoiRect, unsigned short aLow[4], unsigned short aHigh[4]); +TOUPCAM_API(HRESULT) Toupcam_get_LevelRangeV2(HToupcam h, unsigned short* pMode, RECT* pRoiRect, unsigned short aLow[4], unsigned short aHigh[4]); + +/* + The following functions must be called AFTER Toupcam_StartPushMode or Toupcam_StartPullModeWithWndMsg or Toupcam_StartPullModeWithCallback +*/ +TOUPCAM_API(HRESULT) Toupcam_LevelRangeAuto(HToupcam h); /* software level range */ +TOUPCAM_API(HRESULT) Toupcam_GetHistogram(HToupcam h, PITOUPCAM_HISTOGRAM_CALLBACK funHistogram, void* ctxHistogram); +TOUPCAM_API(HRESULT) Toupcam_GetHistogramV2(HToupcam h, PITOUPCAM_HISTOGRAM_CALLBACKV2 funHistogramV2, void* ctxHistogramV2); + +/* led state: + iLed: Led index, (0, 1, 2, ...) + iState: 1 => Ever bright; 2 => Flashing; other => Off + iPeriod: Flashing Period (>= 500ms) +*/ +TOUPCAM_API(HRESULT) Toupcam_put_LEDState(HToupcam h, unsigned short iLed, unsigned short iState, unsigned short iPeriod); + +TOUPCAM_API(HRESULT) Toupcam_write_EEPROM(HToupcam h, unsigned addr, const unsigned char* pBuffer, unsigned nBufferLen); +TOUPCAM_API(HRESULT) Toupcam_read_EEPROM(HToupcam h, unsigned addr, unsigned char* pBuffer, unsigned nBufferLen); + +TOUPCAM_API(HRESULT) Toupcam_read_Pipe(HToupcam h, unsigned pipeId, void* pBuffer, unsigned nBufferLen); +TOUPCAM_API(HRESULT) Toupcam_write_Pipe(HToupcam h, unsigned pipeId, const void* pBuffer, unsigned nBufferLen); +TOUPCAM_API(HRESULT) Toupcam_feed_Pipe(HToupcam h, unsigned pipeId); + +#define TOUPCAM_OPTION_NOFRAME_TIMEOUT 0x01 /* no frame timeout: 0 => disable, positive value (>= TOUPCAM_NOFRAME_TIMEOUT_MIN) => timeout milliseconds. default: disable */ +#define TOUPCAM_OPTION_THREAD_PRIORITY 0x02 /* set the priority of the internal thread which grab data from the usb device. + Win: iValue: 0 => THREAD_PRIORITY_NORMAL; 1 => THREAD_PRIORITY_ABOVE_NORMAL; 2 => THREAD_PRIORITY_HIGHEST; 3 => THREAD_PRIORITY_TIME_CRITICAL; default: 1; see: https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setthreadpriority + Linux & macOS: The high 16 bits for the scheduling policy, and the low 16 bits for the priority; see: https://linux.die.net/man/3/pthread_setschedparam + */ +#define TOUPCAM_OPTION_PROCESSMODE 0x03 /* obsolete & useless, noop. 0 = better image quality, more cpu usage. this is the default value; 1 = lower image quality, less cpu usage */ +#define TOUPCAM_OPTION_RAW 0x04 /* raw data mode, read the sensor "raw" data. This can be set only while camea is NOT running. 0 = rgb, 1 = raw, default value: 0 */ +#define TOUPCAM_OPTION_HISTOGRAM 0x05 /* 0 = only one, 1 = continue mode */ +#define TOUPCAM_OPTION_BITDEPTH 0x06 /* 0 = 8 bits mode, 1 = 16 bits mode, subset of TOUPCAM_OPTION_PIXEL_FORMAT */ +#define TOUPCAM_OPTION_FAN 0x07 /* 0 = turn off the cooling fan, [1, max] = fan speed */ +#define TOUPCAM_OPTION_TEC 0x08 /* 0 = turn off the thermoelectric cooler, 1 = turn on the thermoelectric cooler */ +#define TOUPCAM_OPTION_LINEAR 0x09 /* 0 = turn off the builtin linear tone mapping, 1 = turn on the builtin linear tone mapping, default value: 1 */ +#define TOUPCAM_OPTION_CURVE 0x0a /* 0 = turn off the builtin curve tone mapping, 1 = turn on the builtin polynomial curve tone mapping, 2 = logarithmic curve tone mapping, default value: 2 */ +#define TOUPCAM_OPTION_TRIGGER 0x0b /* 0 = video mode, 1 = software or simulated trigger mode, 2 = external trigger mode, 3 = external + software trigger, default value = 0 */ +#define TOUPCAM_OPTION_RGB 0x0c /* 0 => RGB24; 1 => enable RGB48 format when bitdepth > 8; 2 => RGB32; 3 => 8 Bits Grey (only for mono camera); 4 => 16 Bits Grey (only for mono camera when bitdepth > 8); 5 => 64(RGB64) */ +#define TOUPCAM_OPTION_COLORMATIX 0x0d /* enable or disable the builtin color matrix, default value: 1 */ +#define TOUPCAM_OPTION_WBGAIN 0x0e /* enable or disable the builtin white balance gain, default value: 1 */ +#define TOUPCAM_OPTION_TECTARGET 0x0f /* get or set the target temperature of the thermoelectric cooler, in 0.1 degree Celsius. For example, 125 means 12.5 degree Celsius, -35 means -3.5 degree Celsius */ +#define TOUPCAM_OPTION_AUTOEXP_POLICY 0x10 /* auto exposure policy: + 0: Exposure Only + 1: Exposure Preferred + 2: Gain Only + 3: Gain Preferred + default value: 1 + */ +#define TOUPCAM_OPTION_FRAMERATE 0x11 /* limit the frame rate, range=[0, 63], the default value 0 means no limit */ +#define TOUPCAM_OPTION_DEMOSAIC 0x12 /* demosaic method for both video and still image: BILINEAR = 0, VNG(Variable Number of Gradients) = 1, PPG(Patterned Pixel Grouping) = 2, AHD(Adaptive Homogeneity Directed) = 3, EA(Edge Aware) = 4, see https://en.wikipedia.org/wiki/Demosaicing, default value: 0 */ +#define TOUPCAM_OPTION_DEMOSAIC_VIDEO 0x13 /* demosaic method for video */ +#define TOUPCAM_OPTION_DEMOSAIC_STILL 0x14 /* demosaic method for still image */ +#define TOUPCAM_OPTION_BLACKLEVEL 0x15 /* black level */ +#define TOUPCAM_OPTION_MULTITHREAD 0x16 /* multithread image processing */ +#define TOUPCAM_OPTION_BINNING 0x17 /* binning + 0x01: (no binning) + n: (saturating add, n*n), 0x02(2*2), 0x03(3*3), 0x04(4*4), 0x05(5*5), 0x06(6*6), 0x07(7*7), 0x08(8*8). The Bitdepth of the data remains unchanged. + 0x40 | n: (unsaturated add, n*n, works only in RAW mode), 0x42(2*2), 0x43(3*3), 0x44(4*4), 0x45(5*5), 0x46(6*6), 0x47(7*7), 0x48(8*8). The Bitdepth of the data is increased. For example, the original data with bitdepth of 12 will increase the bitdepth by 2 bits and become 14 after 2*2 binning. + 0x80 | n: (average, n*n), 0x82(2*2), 0x83(3*3), 0x84(4*4), 0x85(5*5), 0x86(6*6), 0x87(7*7), 0x88(8*8). The Bitdepth of the data remains unchanged. + The final image size is rounded down to an even number, such as 640/3 to get 212 + */ +#define TOUPCAM_OPTION_ROTATE 0x18 /* rotate clockwise: 0, 90, 180, 270 */ +#define TOUPCAM_OPTION_CG 0x19 /* Conversion Gain: 0 = LCG, 1 = HCG, 2 = HDR */ +#define TOUPCAM_OPTION_PIXEL_FORMAT 0x1a /* pixel format, TOUPCAM_PIXELFORMAT_xxxx */ +#define TOUPCAM_OPTION_FFC 0x1b /* flat field correction + set: + 0: disable + 1: enable + -1: reset + (0xff000000 | n): set the average number to n, [1~255] + get: + (val & 0xff): 0 => disable, 1 => enable, 2 => inited + ((val & 0xff00) >> 8): sequence + ((val & 0xff0000) >> 16): average number + */ +#define TOUPCAM_OPTION_DDR_DEPTH 0x1c /* the number of the frames that DDR can cache + 1: DDR cache only one frame + 0: Auto: + => one for video mode when auto exposure is enabled + => full capacity for others + -1: DDR can cache frames to full capacity + */ +#define TOUPCAM_OPTION_DFC 0x1d /* dark field correction + set: + 0: disable + 1: enable + -1: reset + (0xff000000 | n): set the average number to n, [1~255] + get: + (val & 0xff): 0 => disable, 1 => enable, 2 => inited + ((val & 0xff00) >> 8): sequence + ((val & 0xff0000) >> 16): average number + */ +#define TOUPCAM_OPTION_SHARPENING 0x1e /* Sharpening: (threshold << 24) | (radius << 16) | strength) + strength: [0, 500], default: 0 (disable) + radius: [1, 10] + threshold: [0, 255] + */ +#define TOUPCAM_OPTION_FACTORY 0x1f /* restore the factory settings */ +#define TOUPCAM_OPTION_TEC_VOLTAGE 0x20 /* get the current TEC voltage in 0.1V, 59 mean 5.9V; readonly */ +#define TOUPCAM_OPTION_TEC_VOLTAGE_MAX 0x21 /* TEC maximum voltage in 0.1V */ +#define TOUPCAM_OPTION_DEVICE_RESET 0x22 /* reset usb device, simulate a replug */ +#define TOUPCAM_OPTION_UPSIDE_DOWN 0x23 /* upsize down: + 1: yes + 0: no + default: 1 (win), 0 (linux/macos) + */ +#define TOUPCAM_OPTION_FOCUSPOS 0x24 /* focus positon */ +#define TOUPCAM_OPTION_AFMODE 0x25 /* auto focus mode (0:manul focus; 1:auto focus; 2:once focus; 3:conjugate calibration) */ +#define TOUPCAM_OPTION_AFZONE 0x26 /* auto focus zone */ +#define TOUPCAM_OPTION_AFFEEDBACK 0x27 /* auto focus information feedback; 0:unknown; 1:focused; 2:focusing; 3:defocus; 4:up; 5:down */ +#define TOUPCAM_OPTION_TESTPATTERN 0x28 /* test pattern: + 0: off + 3: monochrome diagonal stripes + 5: monochrome vertical stripes + 7: monochrome horizontal stripes + 9: chromatic diagonal stripes + */ +#define TOUPCAM_OPTION_AUTOEXP_THRESHOLD 0x29 /* threshold of auto exposure, default value: 5, range = [2, 15] */ +#define TOUPCAM_OPTION_BYTEORDER 0x2a /* Byte order, BGR or RGB: 0 => RGB, 1 => BGR, default value: 1(Win), 0(macOS, Linux, Android) */ +#define TOUPCAM_OPTION_NOPACKET_TIMEOUT 0x2b /* no packet timeout: 0 => disable, positive value (>= TOUPCAM_NOPACKET_TIMEOUT_MIN) => timeout milliseconds. default: disable */ +#define TOUPCAM_OPTION_MAX_PRECISE_FRAMERATE 0x2c /* get the precise frame rate maximum value in 0.1 fps, such as 115 means 11.5 fps */ +#define TOUPCAM_OPTION_PRECISE_FRAMERATE 0x2d /* precise frame rate current value in 0.1 fps */ +#define TOUPCAM_OPTION_BANDWIDTH 0x2e /* bandwidth, [1-100]% */ +#define TOUPCAM_OPTION_RELOAD 0x2f /* reload the last frame in trigger mode */ +#define TOUPCAM_OPTION_CALLBACK_THREAD 0x30 /* dedicated thread for callback */ +#define TOUPCAM_OPTION_FRONTEND_DEQUE_LENGTH 0x31 /* frontend (raw) frame buffer deque length, range: [2, 1024], default: 4 + All the memory will be pre-allocated when the camera starts, so, please attention to memory usage + */ +#define TOUPCAM_OPTION_FRAME_DEQUE_LENGTH 0x31 /* alias of TOUPCAM_OPTION_FRONTEND_DEQUE_LENGTH */ +#define TOUPCAM_OPTION_MIN_PRECISE_FRAMERATE 0x32 /* get the precise frame rate minimum value in 0.1 fps, such as 15 means 1.5 fps */ +#define TOUPCAM_OPTION_SEQUENCER_ONOFF 0x33 /* sequencer trigger: on/off */ +#define TOUPCAM_OPTION_SEQUENCER_NUMBER 0x34 /* sequencer trigger: number, range = [1, 255] */ +#define TOUPCAM_OPTION_SEQUENCER_EXPOTIME 0x01000000 /* sequencer trigger: exposure time, iOption = TOUPCAM_OPTION_SEQUENCER_EXPOTIME | index, iValue = exposure time + For example, to set the exposure time of the third group to 50ms, call: + Toupcam_put_Option(TOUPCAM_OPTION_SEQUENCER_EXPOTIME | 3, 50000) + */ +#define TOUPCAM_OPTION_SEQUENCER_EXPOGAIN 0x02000000 /* sequencer trigger: exposure gain, iOption = TOUPCAM_OPTION_SEQUENCER_EXPOGAIN | index, iValue = gain */ +#define TOUPCAM_OPTION_DENOISE 0x35 /* denoise, strength range: [0, 100], 0 means disable */ +#define TOUPCAM_OPTION_HEAT_MAX 0x36 /* get maximum level: heat to prevent fogging up */ +#define TOUPCAM_OPTION_HEAT 0x37 /* heat to prevent fogging up */ +#define TOUPCAM_OPTION_LOW_NOISE 0x38 /* low noise mode (Higher signal noise ratio, lower frame rate): 1 => enable */ +#define TOUPCAM_OPTION_POWER 0x39 /* get power consumption, unit: milliwatt */ +#define TOUPCAM_OPTION_GLOBAL_RESET_MODE 0x3a /* global reset mode */ +#define TOUPCAM_OPTION_OPEN_ERRORCODE 0x3b /* get the open camera error code */ +#define TOUPCAM_OPTION_FLUSH 0x3d /* 1 = hard flush, discard frames cached by camera DDR (if any) + 2 = soft flush, discard frames cached by toupcam.dll (if any) + 3 = both flush + Toupcam_Flush means 'both flush' + return the number of soft flushed frames if successful, HRESULT if failed + */ +#define TOUPCAM_OPTION_NUMBER_DROP_FRAME 0x3e /* get the number of frames that have been grabbed from the USB but dropped by the software */ +#define TOUPCAM_OPTION_DUMP_CFG 0x3f /* 0 = when camera is stopped, do not dump configuration automatically + 1 = when camera is stopped, dump configuration automatically + -1 = explicitly dump configuration once + default: 1 + */ +#define TOUPCAM_OPTION_DEFECT_PIXEL 0x40 /* Defect Pixel Correction: 0 => disable, 1 => enable; default: 1 */ +#define TOUPCAM_OPTION_BACKEND_DEQUE_LENGTH 0x41 /* backend (pipelined) frame buffer deque length (Only available in pull mode), range: [2, 1024], default: 3 + All the memory will be pre-allocated when the camera starts, so, please attention to memory usage + */ +#define TOUPCAM_OPTION_LIGHTSOURCE_MAX 0x42 /* get the light source range, [0 ~ max] */ +#define TOUPCAM_OPTION_LIGHTSOURCE 0x43 /* light source */ +#define TOUPCAM_OPTION_HEARTBEAT 0x44 /* Heartbeat interval in millisecond, range = [TOUPCAM_HEARTBEAT_MIN, TOUPCAM_HEARTBEAT_MAX], 0 = disable, default: disable */ +#define TOUPCAM_OPTION_FRONTEND_DEQUE_CURRENT 0x45 /* get the current number in frontend deque */ +#define TOUPCAM_OPTION_BACKEND_DEQUE_CURRENT 0x46 /* get the current number in backend deque */ +#define TOUPCAM_OPTION_EVENT_HARDWARE 0x04000000 /* enable or disable hardware event: 0 => disable, 1 => enable; default: disable + (1) iOption = TOUPCAM_OPTION_EVENT_HARDWARE, master switch for notification of all hardware events + (2) iOption = TOUPCAM_OPTION_EVENT_HARDWARE | (event type), a specific type of sub-switch + Only if both the master switch and the sub-switch of a particular type remain on are actually enabled for that type of event notification. + */ +#define TOUPCAM_OPTION_PACKET_NUMBER 0x47 /* get the received packet number */ +#define TOUPCAM_OPTION_FILTERWHEEL_SLOT 0x48 /* filter wheel slot number */ +#define TOUPCAM_OPTION_FILTERWHEEL_POSITION 0x49 /* filter wheel position: + set: + -1: reset + val & 0xff: position between 0 and N-1, where N is the number of filter slots + (val >> 8) & 0x1: direction, 0 => clockwise spinning, 1 => auto direction spinning + get: + -1: in motion + val: position arrived + */ +#define TOUPCAM_OPTION_AUTOEXPOSURE_PERCENT 0x4a /* auto exposure percent to average: + 1~99: peak percent average + 0 or 100: full roi average + */ +#define TOUPCAM_OPTION_ANTI_SHUTTER_EFFECT 0x4b /* anti shutter effect: 1 => disable, 0 => disable; default: 1 */ +#define TOUPCAM_OPTION_CHAMBER_HT 0x4c /* get chamber humidity & temperature: + high 16 bits: humidity, in 0.1%, such as: 325 means humidity is 32.5% + low 16 bits: temperature, in 0.1 degrees Celsius, such as: 32 means 3.2 degrees Celsius + */ +#define TOUPCAM_OPTION_ENV_HT 0x4d /* get environment humidity & temperature */ +#define TOUPCAM_OPTION_EXPOSURE_PRE_DELAY 0x4e /* exposure signal pre-delay, microsecond */ +#define TOUPCAM_OPTION_EXPOSURE_POST_DELAY 0x4f /* exposure signal post-delay, microsecond */ +#define TOUPCAM_OPTION_AUTOEXPO_CONV 0x50 /* get auto exposure convergence status: 1(YES) or 0(NO), -1(NA) */ +#define TOUPCAM_OPTION_AUTOEXPO_TRIGGER 0x51 /* auto exposure on trigger mode: 0 => disable, 1 => enable; default: 0 */ +#define TOUPCAM_OPTION_LINE_PRE_DELAY 0x52 /* specified line signal pre-delay, microsecond */ +#define TOUPCAM_OPTION_LINE_POST_DELAY 0x53 /* specified line signal post-delay, microsecond */ +#define TOUPCAM_OPTION_TEC_VOLTAGE_MAX_RANGE 0x54 /* get the tec maximum voltage range: + high 16 bits: max + low 16 bits: min + */ +#define TOUPCAM_OPTION_HIGH_FULLWELL 0x55 /* high fullwell capacity: 0 => disable, 1 => enable */ +#define TOUPCAM_OPTION_DYNAMIC_DEFECT 0x56 /* dynamic defect pixel correction: + threshold, t1: (high 16 bits): [10, 100], means: [1.0, 10.0] + value, t2: (low 16 bits): [0, 100], means: [0.00, 1.00] + */ +#define TOUPCAM_OPTION_HDR_KB 0x57 /* HDR synthesize + K (high 16 bits): [1, 25500] + B (low 16 bits): [0, 65535] + 0xffffffff => set to default + */ +#define TOUPCAM_OPTION_HDR_THRESHOLD 0x58 /* HDR synthesize + threshold: [1, 4094] + 0xffffffff => set to default + */ +#define TOUPCAM_OPTION_GIGETIMEOUT 0x5a /* For GigE cameras, the application periodically sends heartbeat signals to the camera to keep the connection to the camera alive. + If the camera doesn't receive heartbeat signals within the time period specified by the heartbeat timeout counter, the camera resets the connection. + When the application is stopped by the debugger, the application cannot create the heartbeat signals + 0 => auto: when the camera is opened, disable if debugger is present or enable if no debugger is present + 1 => enable + 2 => disable + default: auto + */ +#define TOUPCAM_OPTION_EEPROM_SIZE 0x5b /* get EEPROM size */ +#define TOUPCAM_OPTION_OVERCLOCK_MAX 0x5c /* get overclock range: [0, max] */ +#define TOUPCAM_OPTION_OVERCLOCK 0x5d /* overclock, default: 0 */ +#define TOUPCAM_OPTION_RESET_SENSOR 0x5e /* reset sensor */ +#define TOUPCAM_OPTION_ADC 0x08000000 /* Analog-Digital Conversion: + get: + (option | 'C'): get the current value + (option | 'N'): get the supported ADC number + (option | n): get the nth supported ADC value, such as 11bits, 12bits, etc; the first value is the default + set: val = ADC value, such as 11bits, 12bits, etc + */ + +/* pixel format */ +#define TOUPCAM_PIXELFORMAT_RAW8 0x00 +#define TOUPCAM_PIXELFORMAT_RAW10 0x01 +#define TOUPCAM_PIXELFORMAT_RAW12 0x02 +#define TOUPCAM_PIXELFORMAT_RAW14 0x03 +#define TOUPCAM_PIXELFORMAT_RAW16 0x04 +#define TOUPCAM_PIXELFORMAT_YUV411 0x05 +#define TOUPCAM_PIXELFORMAT_VUYY 0x06 +#define TOUPCAM_PIXELFORMAT_YUV444 0x07 +#define TOUPCAM_PIXELFORMAT_RGB888 0x08 +#define TOUPCAM_PIXELFORMAT_GMCY8 0x09 /* map to RGGB 8 bits */ +#define TOUPCAM_PIXELFORMAT_GMCY12 0x0a /* map to RGGB 12 bits */ +#define TOUPCAM_PIXELFORMAT_UYVY 0x0b + +TOUPCAM_API(HRESULT) Toupcam_put_Option(HToupcam h, unsigned iOption, int iValue); +TOUPCAM_API(HRESULT) Toupcam_get_Option(HToupcam h, unsigned iOption, int* piValue); + +/* + xOffset, yOffset, xWidth, yHeight: must be even numbers +*/ +TOUPCAM_API(HRESULT) Toupcam_put_Roi(HToupcam h, unsigned xOffset, unsigned yOffset, unsigned xWidth, unsigned yHeight); +TOUPCAM_API(HRESULT) Toupcam_get_Roi(HToupcam h, unsigned* pxOffset, unsigned* pyOffset, unsigned* pxWidth, unsigned* pyHeight); + +/* simulate replug: + return > 0, the number of device has been replug + return = 0, no device found + return E_ACCESSDENIED if without UAC Administrator privileges + for each device found, it will take about 3 seconds +*/ +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_Replug(const wchar_t* camId); +#else +TOUPCAM_API(HRESULT) Toupcam_Replug(const char* camId); +#endif + +#ifndef __TOUPCAMAFPARAM_DEFINED__ +#define __TOUPCAMAFPARAM_DEFINED__ +typedef struct { + int imax; /* maximum auto focus sensor board positon */ + int imin; /* minimum auto focus sensor board positon */ + int idef; /* conjugate calibration positon */ + int imaxabs; /* maximum absolute auto focus sensor board positon, micrometer */ + int iminabs; /* maximum absolute auto focus sensor board positon, micrometer */ + int zoneh; /* zone horizontal */ + int zonev; /* zone vertical */ +} ToupcamAfParam; +#endif + +TOUPCAM_API(HRESULT) Toupcam_get_AfParam(HToupcam h, ToupcamAfParam* pAfParam); + +#define TOUPCAM_IOCONTROLTYPE_GET_SUPPORTEDMODE 0x01 /* 0x01 => Input, 0x02 => Output, (0x01 | 0x02) => support both Input and Output */ +#define TOUPCAM_IOCONTROLTYPE_GET_GPIODIR 0x03 /* 0x00 => Input, 0x01 => Output */ +#define TOUPCAM_IOCONTROLTYPE_SET_GPIODIR 0x04 +#define TOUPCAM_IOCONTROLTYPE_GET_FORMAT 0x05 /* + 0x00 => not connected + 0x01 => Tri-state: Tri-state mode (Not driven) + 0x02 => TTL: TTL level signals + 0x03 => LVDS: LVDS level signals + 0x04 => RS422: RS422 level signals + 0x05 => Opto-coupled + */ +#define TOUPCAM_IOCONTROLTYPE_SET_FORMAT 0x06 +#define TOUPCAM_IOCONTROLTYPE_GET_OUTPUTINVERTER 0x07 /* boolean, only support output signal */ +#define TOUPCAM_IOCONTROLTYPE_SET_OUTPUTINVERTER 0x08 +#define TOUPCAM_IOCONTROLTYPE_GET_INPUTACTIVATION 0x09 /* 0x00 => Rising edge, 0x01 => Falling edge, 0x02 => Level high, 0x03 => Level low */ +#define TOUPCAM_IOCONTROLTYPE_SET_INPUTACTIVATION 0x0a +#define TOUPCAM_IOCONTROLTYPE_GET_DEBOUNCERTIME 0x0b /* debouncer time in microseconds, range: [0, 20000] */ +#define TOUPCAM_IOCONTROLTYPE_SET_DEBOUNCERTIME 0x0c +#define TOUPCAM_IOCONTROLTYPE_GET_TRIGGERSOURCE 0x0d /* + 0x00 => Opto-isolated input + 0x01 => GPIO0 + 0x02 => GPIO1 + 0x03 => Counter + 0x04 => PWM + 0x05 => Software + */ +#define TOUPCAM_IOCONTROLTYPE_SET_TRIGGERSOURCE 0x0e +#define TOUPCAM_IOCONTROLTYPE_GET_TRIGGERDELAY 0x0f /* Trigger delay time in microseconds, range: [0, 5000000] */ +#define TOUPCAM_IOCONTROLTYPE_SET_TRIGGERDELAY 0x10 +#define TOUPCAM_IOCONTROLTYPE_GET_BURSTCOUNTER 0x11 /* Burst Counter, range: [1 ~ 65535] */ +#define TOUPCAM_IOCONTROLTYPE_SET_BURSTCOUNTER 0x12 +#define TOUPCAM_IOCONTROLTYPE_GET_COUNTERSOURCE 0x13 /* 0x00 => Opto-isolated input, 0x01 => GPIO0, 0x02 => GPIO1 */ +#define TOUPCAM_IOCONTROLTYPE_SET_COUNTERSOURCE 0x14 +#define TOUPCAM_IOCONTROLTYPE_GET_COUNTERVALUE 0x15 /* Counter Value, range: [1 ~ 65535] */ +#define TOUPCAM_IOCONTROLTYPE_SET_COUNTERVALUE 0x16 +#define TOUPCAM_IOCONTROLTYPE_SET_RESETCOUNTER 0x18 +#define TOUPCAM_IOCONTROLTYPE_GET_PWM_FREQ 0x19 +#define TOUPCAM_IOCONTROLTYPE_SET_PWM_FREQ 0x1a +#define TOUPCAM_IOCONTROLTYPE_GET_PWM_DUTYRATIO 0x1b +#define TOUPCAM_IOCONTROLTYPE_SET_PWM_DUTYRATIO 0x1c +#define TOUPCAM_IOCONTROLTYPE_GET_PWMSOURCE 0x1d /* 0x00 => Opto-isolated input, 0x01 => GPIO0, 0x02 => GPIO1 */ +#define TOUPCAM_IOCONTROLTYPE_SET_PWMSOURCE 0x1e +#define TOUPCAM_IOCONTROLTYPE_GET_OUTPUTMODE 0x1f /* + 0x00 => Frame Trigger Wait + 0x01 => Exposure Active + 0x02 => Strobe + 0x03 => User output + 0x04 => Counter Output + 0x05 => Timer Output + */ +#define TOUPCAM_IOCONTROLTYPE_SET_OUTPUTMODE 0x20 +#define TOUPCAM_IOCONTROLTYPE_GET_STROBEDELAYMODE 0x21 /* boolean, 0 => pre-delay, 1 => delay; compared to exposure active signal */ +#define TOUPCAM_IOCONTROLTYPE_SET_STROBEDELAYMODE 0x22 +#define TOUPCAM_IOCONTROLTYPE_GET_STROBEDELAYTIME 0x23 /* Strobe delay or pre-delay time in microseconds, range: [0, 5000000] */ +#define TOUPCAM_IOCONTROLTYPE_SET_STROBEDELAYTIME 0x24 +#define TOUPCAM_IOCONTROLTYPE_GET_STROBEDURATION 0x25 /* Strobe duration time in microseconds, range: [0, 5000000] */ +#define TOUPCAM_IOCONTROLTYPE_SET_STROBEDURATION 0x26 +#define TOUPCAM_IOCONTROLTYPE_GET_USERVALUE 0x27 /* + bit0 => Opto-isolated output + bit1 => GPIO0 output + bit2 => GPIO1 output + */ +#define TOUPCAM_IOCONTROLTYPE_SET_USERVALUE 0x28 +#define TOUPCAM_IOCONTROLTYPE_GET_UART_ENABLE 0x29 /* enable: 1 => on; 0 => off */ +#define TOUPCAM_IOCONTROLTYPE_SET_UART_ENABLE 0x2a +#define TOUPCAM_IOCONTROLTYPE_GET_UART_BAUDRATE 0x2b /* baud rate: 0 => 9600; 1 => 19200; 2 => 38400; 3 => 57600; 4 => 115200 */ +#define TOUPCAM_IOCONTROLTYPE_SET_UART_BAUDRATE 0x2c +#define TOUPCAM_IOCONTROLTYPE_GET_UART_LINEMODE 0x2d /* line mode: 0 => TX(GPIO_0)/RX(GPIO_1); 1 => TX(GPIO_1)/RX(GPIO_0) */ +#define TOUPCAM_IOCONTROLTYPE_SET_UART_LINEMODE 0x2e +#define TOUPCAM_IOCONTROLTYPE_GET_EXPO_ACTIVE_MODE 0x2f /* exposure time signal: 0 => specified line, 1 => common exposure time */ +#define TOUPCAM_IOCONTROLTYPE_SET_EXPO_ACTIVE_MODE 0x30 +#define TOUPCAM_IOCONTROLTYPE_GET_EXPO_START_LINE 0x31 /* exposure start line, default: 0 */ +#define TOUPCAM_IOCONTROLTYPE_SET_EXPO_START_LINE 0x32 +#define TOUPCAM_IOCONTROLTYPE_GET_EXPO_END_LINE 0x33 /* exposure end line, default: 0 + end line must be no less than start line + */ +#define TOUPCAM_IOCONTROLTYPE_SET_EXPO_END_LINE 0x34 +#define TOUPCAM_IOCONTROLTYPE_GET_EXEVT_ACTIVE_MODE 0x35 /* exposure event: 0 => specified line, 1 => common exposure time */ +#define TOUPCAM_IOCONTROLTYPE_SET_EXEVT_ACTIVE_MODE 0x36 +#define TOUPCAM_IOCONTROLTYPE_GET_OUTPUTCOUNTERVALUE 0x37 /* Output Counter Value, range: [0 ~ 65535] */ +#define TOUPCAM_IOCONTROLTYPE_SET_OUTPUTCOUNTERVALUE 0x38 +#define TOUPCAM_IOCONTROLTYPE_SET_OUTPUT_PAUSE 0x3a /* Output pause: 1 => puase, 0 => unpause */ + +#define TOUPCAM_IOCONTROL_DELAYTIME_MAX (5 * 1000 * 1000) + +/* + ioLineNumber: + 0 => Opto-isolated input + 1 => Opto-isolated output + 2 => GPIO0 + 3 => GPIO1 +*/ +TOUPCAM_API(HRESULT) Toupcam_IoControl(HToupcam h, unsigned ioLineNumber, unsigned nType, int outVal, int* inVal); + +#define TOUPCAM_FLASH_SIZE 0x00 /* query total size */ +#define TOUPCAM_FLASH_EBLOCK 0x01 /* query erase block size */ +#define TOUPCAM_FLASH_RWBLOCK 0x02 /* query read/write block size */ +#define TOUPCAM_FLASH_STATUS 0x03 /* query status */ +#define TOUPCAM_FLASH_READ 0x04 /* read */ +#define TOUPCAM_FLASH_WRITE 0x05 /* write */ +#define TOUPCAM_FLASH_ERASE 0x06 /* erase */ +/* Flash: + action = TOUPCAM_FLASH_XXXX: read, write, erase, query total size, query read/write block size, query erase block size + addr = address + see democpp +*/ +TOUPCAM_API(HRESULT) Toupcam_rwc_Flash(HToupcam h, unsigned action, unsigned addr, unsigned len, void* pData); + +TOUPCAM_API(HRESULT) Toupcam_write_UART(HToupcam h, const unsigned char* pData, unsigned nDataLen); +TOUPCAM_API(HRESULT) Toupcam_read_UART(HToupcam h, unsigned char* pBuffer, unsigned nBufferLen); + +TOUPCAM_API(const ToupcamModelV2**) Toupcam_all_Model(); /* return all supported USB model array */ +TOUPCAM_API(const ToupcamModelV2*) Toupcam_query_Model(HToupcam h); +TOUPCAM_API(const ToupcamModelV2*) Toupcam_get_Model(unsigned short idVendor, unsigned short idProduct); + +/* firmware update: + camId: camera ID + filePath: ufw file full path + funProgress, ctx: progress percent callback +Please do not unplug the camera or lost power during the upgrade process, this is very very important. +Once an unplugging or power outage occurs during the upgrade process, the camera will no longer be available and can only be returned to the factory for repair. +*/ +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_Update(const wchar_t* camId, const wchar_t* filePath, PITOUPCAM_PROGRESS funProgress, void* ctxProgress); +#else +TOUPCAM_API(HRESULT) Toupcam_Update(const char* camId, const char* filePath, PITOUPCAM_PROGRESS funProgress, void* ctxProgress); +#endif + +TOUPCAM_API(HRESULT) Toupcam_put_Linear(HToupcam h, const unsigned char* v8, const unsigned short* v16); /* v8, v16 pointer must remains valid */ +TOUPCAM_API(HRESULT) Toupcam_put_Curve(HToupcam h, const unsigned char* v8, const unsigned short* v16); /* v8, v16 pointer must remains valid */ +TOUPCAM_API(HRESULT) Toupcam_put_ColorMatrix(HToupcam h, const double v[9]); /* null => revert to model default */ +TOUPCAM_API(HRESULT) Toupcam_put_InitWBGain(HToupcam h, const unsigned short v[3]); /* null => revert to model default */ + +/* + get the frame rate: framerate (fps) = Frame * 1000.0 / nTime +*/ +TOUPCAM_API(HRESULT) Toupcam_get_FrameRate(HToupcam h, unsigned* nFrame, unsigned* nTime, unsigned* nTotalFrame); + +/* astronomy: for ST4 guide, please see: ASCOM Platform Help ICameraV2. + nDirect: 0 = North, 1 = South, 2 = East, 3 = West, 4 = Stop + nDuration: in milliseconds +*/ +TOUPCAM_API(HRESULT) Toupcam_ST4PlusGuide(HToupcam h, unsigned nDirect, unsigned nDuration); + +/* S_OK: ST4 pulse guiding + S_FALSE: ST4 not pulse guiding +*/ +TOUPCAM_API(HRESULT) Toupcam_ST4PlusGuideState(HToupcam h); + +TOUPCAM_API(HRESULT) Toupcam_Gain2TempTint(const int gain[3], int* temp, int* tint); +TOUPCAM_API(void) Toupcam_TempTint2Gain(const int temp, const int tint, int gain[3]); +/* + calculate the clarity factor: + pImageData: pointer to the image data + bits: 8(Grey), 16(Grey), 24(RGB24), 32(RGB32), 48(RGB48), 64(RGB64) + nImgWidth, nImgHeight: the image width and height + xOffset, yOffset, xWidth, yHeight: the Roi used to calculate. If not specified, use 1/5 * 1/5 rectangle in the center + return < 0.0 when error +*/ +TOUPCAM_API(double) Toupcam_calc_ClarityFactor(const void* pImageData, int bits, unsigned nImgWidth, unsigned nImgHeight); +TOUPCAM_API(double) Toupcam_calc_ClarityFactorV2(const void* pImageData, int bits, unsigned nImgWidth, unsigned nImgHeight, unsigned xOffset, unsigned yOffset, unsigned xWidth, unsigned yHeight); + +/* + nBitCount: output bitmap bit count + when nBitDepth == 8: + nBitCount must be 24 or 32 + when nBitDepth > 8 + nBitCount: 24 => RGB24 + 32 => RGB32 + 48 => RGB48 + 64 => RGB64 +*/ +TOUPCAM_API(void) Toupcam_deBayerV2(unsigned nFourCC, int nW, int nH, const void* input, void* output, unsigned char nBitDepth, unsigned char nBitCount); + +/* + obsolete, please use Toupcam_deBayerV2 +*/ +TOUPCAM_DEPRECATED +TOUPCAM_API(void) Toupcam_deBayer(unsigned nFourCC, int nW, int nH, const void* input, void* output, unsigned char nBitDepth); + +typedef void (__stdcall* PTOUPCAM_DEMOSAIC_CALLBACK)(unsigned nFourCC, int nW, int nH, const void* input, void* output, unsigned char nBitDepth, void* ctxDemosaic); +TOUPCAM_API(HRESULT) Toupcam_put_Demosaic(HToupcam h, PTOUPCAM_DEMOSAIC_CALLBACK funDemosaic, void* ctxDemosaic); + +/* + obsolete, please use ToupcamModelV2 +*/ +typedef struct { +#if defined(_WIN32) + const wchar_t* name; /* model name, in Windows, we use unicode */ +#else + const char* name; /* model name */ +#endif + unsigned flag; /* TOUPCAM_FLAG_xxx */ + unsigned maxspeed; /* number of speed level, same as Toupcam_get_MaxSpeed(), the speed range = [0, maxspeed], closed interval */ + unsigned preview; /* number of preview resolution, same as Toupcam_get_ResolutionNumber() */ + unsigned still; /* number of still resolution, same as Toupcam_get_StillResolutionNumber() */ + ToupcamResolution res[16]; +} ToupcamModel; /* camera model */ + +/* + obsolete, please use ToupcamDeviceV2 +*/ +typedef struct { +#if defined(_WIN32) + wchar_t displayname[64]; /* display name */ + wchar_t id[64]; /* unique and opaque id of a connected camera, for Toupcam_Open */ +#else + char displayname[64]; /* display name */ + char id[64]; /* unique and opaque id of a connected camera, for Toupcam_Open */ +#endif + const ToupcamModel* model; +} ToupcamDevice; /* camera instance for enumerating */ + +/* + obsolete, please use Toupcam_EnumV2 +*/ +TOUPCAM_DEPRECATED +TOUPCAM_API(unsigned) Toupcam_Enum(ToupcamDevice arr[TOUPCAM_MAX]); + +typedef PTOUPCAM_DATA_CALLBACK_V3 PTOUPCAM_DATA_CALLBACK_V2; +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_StartPushModeV2(HToupcam h, PTOUPCAM_DATA_CALLBACK_V2 funData, void* ctxData); + +#if !defined(_WIN32) +#ifndef __BITMAPINFOHEADER_DEFINED__ +#define __BITMAPINFOHEADER_DEFINED__ +typedef struct { + unsigned biSize; + int biWidth; + int biHeight; + unsigned short biPlanes; + unsigned short biBitCount; + unsigned biCompression; + unsigned biSizeImage; + int biXPelsPerMeter; + int biYPelsPerMeter; + unsigned biClrUsed; + unsigned biClrImportant; +} BITMAPINFOHEADER; +#endif +#endif + +typedef void (__stdcall* PTOUPCAM_DATA_CALLBACK)(const void* pData, const BITMAPINFOHEADER* pHeader, int bSnap, void* ctxData); +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_StartPushMode(HToupcam h, PTOUPCAM_DATA_CALLBACK funData, void* ctxData); + +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_put_ExpoCallback(HToupcam h, PITOUPCAM_EXPOSURE_CALLBACK funExpo, void* ctxExpo); +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_put_ChromeCallback(HToupcam h, PITOUPCAM_CHROME_CALLBACK funChrome, void* ctxChrome); + +/* Toupcam_FfcOnePush is obsolete, recommend using Toupcam_FfcOnce. */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_FfcOnePush(HToupcam h); + +/* Toupcam_DfcOnePush is obsolete, recommend using Toupcam_DfcOnce. */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_DfcOnePush(HToupcam h); + +/* Toupcam_AwbOnePush is obsolete, recommend using Toupcam_AwbOnce. */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_AwbOnePush(HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT); + +/* Toupcam_AbbOnePush is obsolete, recommend using Toupcam_AbbOnce. */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_AbbOnePush(HToupcam h, PITOUPCAM_BLACKBALANCE_CALLBACK funBB, void* ctxBB); + +/* Initialize support for GigE cameras. If online/offline notifications are not required, the callback function can be set to NULL */ +typedef void (__stdcall* PTOUPCAM_HOTPLUG)(void* ctxHotPlug); +TOUPCAM_API(HRESULT) Toupcam_GigeEnable(PTOUPCAM_HOTPLUG funHotPlug, void* ctxHotPlug); + +/* +USB hotplug is only available on macOS and Linux, it's unnecessary on Windows & Android. To process the device plug in / pull out: + (1) On Windows, please refer to the MSDN + (a) Device Management, https://docs.microsoft.com/en-us/windows/win32/devio/device-management + (b) Detecting Media Insertion or Removal, https://docs.microsoft.com/en-us/windows/win32/devio/detecting-media-insertion-or-removal + (2) On Android, please refer to https://developer.android.com/guide/topics/connectivity/usb/host + (3) On Linux / macOS, please call this function to register the callback function. + When the device is inserted or pulled out, you will be notified by the callback funcion, and then call Toupcam_EnumV2(...) again to enum the cameras. + (4) On macOS, IONotificationPortCreate series APIs can also be used as an alternative. +Recommendation: for better rubustness, when notify of device insertion arrives, don't open handle of this device immediately, but open it after delaying a short time (e.g., 200 milliseconds). +*/ +#if !defined(_WIN32) && !defined(__ANDROID__) +TOUPCAM_API(void) Toupcam_HotPlug(PTOUPCAM_HOTPLUG funHotPlug, void* ctxHotPlug); +#endif + +/* AAF: Astro Auto Focuser */ +#define TOUPCAM_AAF_SETPOSITION 0x01 +#define TOUPCAM_AAF_GETPOSITION 0x02 +#define TOUPCAM_AAF_SETZERO 0x03 +#define TOUPCAM_AAF_GETZERO 0x04 +#define TOUPCAM_AAF_SETDIRECTION 0x05 +#define TOUPCAM_AAF_GETDIRECTION 0x06 +#define TOUPCAM_AAF_SETMAXINCREMENT 0x07 +#define TOUPCAM_AAF_GETMAXINCREMENT 0x08 +#define TOUPCAM_AAF_SETFINE 0x09 +#define TOUPCAM_AAF_GETFINE 0x0a +#define TOUPCAM_AAF_SETCOARSE 0x0b +#define TOUPCAM_AAF_GETCOARSE 0x0c +#define TOUPCAM_AAF_SETBUZZER 0x0d +#define TOUPCAM_AAF_GETBUZZER 0x0e +#define TOUPCAM_AAF_SETBACKLASH 0x0f +#define TOUPCAM_AAF_GETBACKLASH 0x10 +#define TOUPCAM_AAF_GETAMBIENTTEMP 0x12 +#define TOUPCAM_AAF_GETTEMP 0x14 +#define TOUPCAM_AAF_ISMOVING 0x16 +#define TOUPCAM_AAF_HALT 0x17 +#define TOUPCAM_AAF_SETMAXSTEP 0x1b +#define TOUPCAM_AAF_GETMAXSTEP 0x1c +#define TOUPCAM_AAF_RANGEMIN 0xfd /* Range: min value */ +#define TOUPCAM_AAF_RANGEMAX 0xfe /* Range: max value */ +#define TOUPCAM_AAF_RANGEDEF 0xff /* Range: default value */ +TOUPCAM_API(HRESULT) Toupcam_AAF(HToupcam h, int action, int outVal, int* inVal); + +#if defined(_WIN32) +/* Toupcam_put_TempTintInit is obsolete, recommend using Toupcam_AwbOnce. */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_put_TempTintInit(HToupcam h, PITOUPCAM_TEMPTINT_CALLBACK funTT, void* ctxTT); + +/* ProcessMode: obsolete & useless, noop */ +#ifndef __TOUPCAM_PROCESSMODE_DEFINED__ +#define __TOUPCAM_PROCESSMODE_DEFINED__ +#define TOUPCAM_PROCESSMODE_FULL 0x00 /* better image quality, more cpu usage. this is the default value */ +#define TOUPCAM_PROCESSMODE_FAST 0x01 /* lower image quality, less cpu usage */ +#endif +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_put_ProcessMode(HToupcam h, unsigned nProcessMode); +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_get_ProcessMode(HToupcam h, unsigned* pnProcessMode); +#endif + +/* obsolete, recommend using Toupcam_put_Roi and Toupcam_get_Roi */ +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_put_RoiMode(HToupcam h, int bRoiMode, int xOffset, int yOffset); +TOUPCAM_DEPRECATED +TOUPCAM_API(HRESULT) Toupcam_get_RoiMode(HToupcam h, int* pbRoiMode, int* pxOffset, int* pyOffset); + +/* obsolete: + ------------------------------------------------------------| + | Parameter | Range | Default | + |-----------------------------------------------------------| + | VidgetAmount | -100~100 | 0 | + | VignetMidPoint | 0~100 | 50 | + ------------------------------------------------------------- +*/ +TOUPCAM_API(HRESULT) Toupcam_put_VignetEnable(HToupcam h, int bEnable); +TOUPCAM_API(HRESULT) Toupcam_get_VignetEnable(HToupcam h, int* bEnable); +TOUPCAM_API(HRESULT) Toupcam_put_VignetAmountInt(HToupcam h, int nAmount); +TOUPCAM_API(HRESULT) Toupcam_get_VignetAmountInt(HToupcam h, int* nAmount); +TOUPCAM_API(HRESULT) Toupcam_put_VignetMidPointInt(HToupcam h, int nMidPoint); +TOUPCAM_API(HRESULT) Toupcam_get_VignetMidPointInt(HToupcam h, int* nMidPoint); + +/* obsolete flags */ +#define TOUPCAM_FLAG_BITDEPTH10 TOUPCAM_FLAG_RAW10 /* pixel format, RAW 10bits */ +#define TOUPCAM_FLAG_BITDEPTH12 TOUPCAM_FLAG_RAW12 /* pixel format, RAW 12bits */ +#define TOUPCAM_FLAG_BITDEPTH14 TOUPCAM_FLAG_RAW14 /* pixel format, RAW 14bits */ +#define TOUPCAM_FLAG_BITDEPTH16 TOUPCAM_FLAG_RAW16 /* pixel format, RAW 16bits */ + +#if defined(_WIN32) +TOUPCAM_API(HRESULT) Toupcam_set_Name(HToupcam h, const char* name); +TOUPCAM_API(HRESULT) Toupcam_query_Name(HToupcam h, char name[64]); +TOUPCAM_API(HRESULT) Toupcam_put_Name(const wchar_t* camId, const char* name); +TOUPCAM_API(HRESULT) Toupcam_get_Name(const wchar_t* camId, char name[64]); +#else +TOUPCAM_API(HRESULT) Toupcam_set_Name(HToupcam h, const char* name); +TOUPCAM_API(HRESULT) Toupcam_query_Name(HToupcam h, char name[64]); +TOUPCAM_API(HRESULT) Toupcam_put_Name(const char* camId, const char* name); +TOUPCAM_API(HRESULT) Toupcam_get_Name(const char* camId, char name[64]); +#endif +TOUPCAM_API(unsigned) Toupcam_EnumWithName(ToupcamDeviceV2 pti[TOUPCAM_MAX]); + +TOUPCAM_API(HRESULT) Toupcam_put_RoiN(HToupcam h, unsigned xOffset[], unsigned yOffset[], unsigned xWidth[], unsigned yHeight[], unsigned Num); + +TOUPCAM_API(HRESULT) Toupcam_log_File(const +#if defined(_WIN32) + wchar_t* +#else + char* +#endif + filepath +); +TOUPCAM_API(HRESULT) Toupcam_log_Level(unsigned level); /* 0 => none; 1 => error; 2 => debug; 3 => verbose */ + +#if defined(_WIN32) +#pragma pack(pop) +#endif + +#ifdef __cplusplus +} +#endif + +#endif