| /* -*- C++ -*- |
| * Copyright 2019-2025 LibRaw LLC (info@libraw.org) |
| * |
| |
| LibRaw is free software; you can redistribute it and/or modify |
| it under the terms of the one of two licenses as you choose: |
| |
| 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1 |
| (See file LICENSE.LGPL provided in LibRaw distribution archive for details). |
| |
| 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0 |
| (See file LICENSE.CDDL provided in LibRaw distribution archive for details). |
| |
| */ |
| |
| #include "third_party/libraw/internal/dcraw_defs.h" |
| #include "third_party/libraw/internal/libraw_cameraids.h" |
| |
| void LibRaw::GetNormalizedModel() |
| { |
| |
| int i, j; |
| char *ps; |
| int try_xml = 0; |
| |
| static const struct |
| { |
| unsigned long long id; |
| char t_model[20]; |
| } unique[] = |
| // clang-format off |
| { |
| { CanonID_EOS_M50, "EOS M50"}, // Kiss M |
| { CanonID_EOS_M6_Mark_II, "EOS M6 Mark II"}, |
| { CanonID_EOS_M200, "EOS M200"}, |
| { CanonID_EOS_D30, "EOS D30"}, |
| { CanonID_EOS_D60, "EOS D60"}, |
| { CanonID_EOS_M3, "EOS M3"}, |
| { CanonID_EOS_M10, "EOS M10"}, |
| { CanonID_EOS_M5, "EOS M5"}, |
| { CanonID_EOS_M100, "EOS M100"}, |
| { CanonID_EOS_M6, "EOS M6"}, |
| |
| { CanonID_EOS_R5_C, "EOS R5 C"}, |
| |
| { CanonID_EOS_1D, "EOS-1D"}, |
| { CanonID_EOS_1Ds, "EOS-1Ds"}, |
| { CanonID_EOS_10D, "EOS 10D"}, |
| { CanonID_EOS_1D_Mark_III, "EOS-1D Mark III"}, |
| { CanonID_EOS_300D, "EOS 300D"}, // Digital Rebel / Kiss Digital |
| { CanonID_EOS_1D_Mark_II, "EOS-1D Mark II"}, |
| { CanonID_EOS_20D, "EOS 20D"}, |
| { CanonID_EOS_450D, "EOS 450D"}, // Digital Rebel XSi / Kiss X2 |
| { CanonID_EOS_1Ds_Mark_II, "EOS-1Ds Mark II"}, |
| { CanonID_EOS_350D, "EOS 350D"}, // Digital Rebel XT / Kiss Digital N |
| { CanonID_EOS_40D, "EOS 40D"}, |
| { CanonID_EOS_5D, "EOS 5D"}, |
| { CanonID_EOS_1Ds_Mark_III, "EOS-1Ds Mark III"}, |
| { CanonID_EOS_5D_Mark_II, "EOS 5D Mark II"}, |
| { CanonID_EOS_1D_Mark_II_N, "EOS-1D Mark II N"}, |
| { CanonID_EOS_30D, "EOS 30D"}, |
| { CanonID_EOS_400D, "EOS 400D"}, // Digital Rebel XTi / Kiss Digital X |
| { CanonID_EOS_7D, "EOS 7D"}, |
| { CanonID_EOS_500D, "EOS 500D"}, // Rebel T1i / Kiss X3 |
| { CanonID_EOS_1000D, "EOS 1000D"}, // Digital Rebel XS / Kiss F |
| { CanonID_EOS_50D, "EOS 50D"}, |
| { CanonID_EOS_1D_X, "EOS-1D X"}, |
| { CanonID_EOS_550D, "EOS 550D"}, // Rebel T2i / Kiss X4 |
| { CanonID_EOS_1D_Mark_IV, "EOS-1D Mark IV"}, |
| { CanonID_EOS_5D_Mark_III, "EOS 5D Mark III"}, |
| { CanonID_EOS_600D, "EOS 600D"}, // Rebel T3i / Kiss X5 |
| { CanonID_EOS_60D, "EOS 60D"}, |
| { CanonID_EOS_1100D, "EOS 1100D"}, // Rebel T3 / Kiss X50 |
| { CanonID_EOS_7D_Mark_II, "EOS 7D Mark II"}, |
| { CanonID_EOS_650D, "EOS 650D"}, // Rebel T4i / Kiss X6i |
| { CanonID_EOS_6D, "EOS 6D"}, |
| { CanonID_EOS_1D_C, "EOS-1D C"}, |
| { CanonID_EOS_70D, "EOS 70D"}, |
| { CanonID_EOS_700D, "EOS 700D"}, // Rebel T5i / Kiss X7i |
| { CanonID_EOS_1200D, "EOS 1200D"}, // Rebel T5 / Kiss X70 / Hi |
| { CanonID_EOS_1D_X_Mark_II, "EOS-1D X Mark II"}, |
| { CanonID_EOS_M, "EOS M"}, |
| { CanonID_EOS_100D, "EOS 100D"}, // Rebel SL1 / Kiss X7 |
| { CanonID_EOS_760D, "EOS 760D"}, // Rebel T6s / 8000D |
| { CanonID_EOS_5D_Mark_IV, "EOS 5D Mark IV"}, |
| { CanonID_EOS_80D, "EOS 80D"}, |
| { CanonID_EOS_M2, "EOS M2"}, |
| { CanonID_EOS_5DS, "EOS 5DS"}, |
| { CanonID_EOS_750D, "EOS 750D"}, // Rebel T6i / Kiss X8i |
| { CanonID_EOS_5DS_R, "EOS 5DS R"}, |
| { CanonID_EOS_1300D, "EOS 1300D"}, // Rebel T6 / Kiss X80 |
| { CanonID_EOS_800D, "EOS 800D"}, // Rebel T7i / Kiss X9i |
| { CanonID_EOS_6D_Mark_II, "EOS 6D Mark II"}, |
| { CanonID_EOS_77D, "EOS 77D"}, // 9000D |
| { CanonID_EOS_200D, "EOS 200D"}, // Rebel SL2 / Kiss X9 |
| { CanonID_EOS_R5, "EOS R5"}, |
| { CanonID_EOS_3000D, "EOS 3000D"}, // Rebel T100 / 4000D |
| { CanonID_EOS_R, "EOS R"}, |
| { CanonID_EOS_1D_X_Mark_III, "EOS-1D X Mark III"}, |
| { CanonID_EOS_1500D, "EOS 1500D"}, // Rebel T7 / 2000D / Kiss X90 |
| { CanonID_EOS_RP, "EOS RP"}, |
| { CanonID_EOS_850D, "EOS 850D"}, // EOS Rebel T8i / X10i |
| { CanonID_EOS_250D, "EOS 250D"}, // Rebel SL3 / 200D II / Kiss X10 |
| { CanonID_EOS_90D, "EOS 90D"}, |
| { CanonID_EOS_R3, "EOS R3"}, |
| { CanonID_EOS_R6, "EOS R6"}, |
| { CanonID_EOS_R7, "EOS R7"}, |
| { CanonID_EOS_R10, "EOS R10"}, |
| { CanonID_EOS_M50_Mark_II, "EOS M50 Mark II"}, // M50m2, Kiss M2 |
| { CanonID_EOS_R50, "EOS R50"}, |
| { CanonID_EOS_R6m2, "EOS R6 Mark II"}, |
| { CanonID_EOS_R8, "EOS R8"}, |
| { CanonID_EOS_R1, "EOS R1"}, |
| { CanonID_EOS_R5_Mark_II, "EOS R5 Mark II"}, // EOS R5m2 |
| { CanonID_EOS_R100, "EOS R100"} |
| }, |
| #if 0 |
| olyque[] = { |
| { OlyID_E_20, "E-20"}, |
| { OlyID_E_20, "E-20,E-20N,E-20P"}, |
| { OlyID_E_1, "E-1"}, |
| { OlyID_E_300, "E-300"}, |
| { OlyID_SP_550UZ, "SP-550UZ"}, |
| { OlyID_SP_550UZ, "SP550UZ"}, |
| { OlyID_SP_510UZ, "SP-510UZ"}, |
| { OlyID_SP_510UZ, "SP510UZ"}, |
| { OlyID_SP_560UZ, "SP-560UZ"}, |
| { OlyID_SP_560UZ, "SP560UZ"}, |
| { OlyID_SP_570UZ, "SP-570UZ"}, |
| { OlyID_SP_570UZ, "SP570UZ"}, |
| { OlyID_SP_565UZ, "SP-565UZ"}, |
| { OlyID_SP_565UZ, "SP565UZ"}, |
| { OlyID_XZ_1, "XZ-1"}, |
| { OlyID_XZ_2, "XZ-2"}, |
| { OlyID_XZ_10, "XZ-10"}, |
| { OlyID_STYLUS_1, "Stylus 1"}, |
| { OlyID_STYLUS_1, "STYLUS1"}, |
| { OlyID_STYLUS_1, "STYLUS1,1s"}, |
| { OlyID_SH_2, "SH-2"}, |
| { OlyID_TG_4, "TG-4"}, |
| { OlyID_TG_5, "TG-5"}, |
| { OlyID_TG_6, "TG-6"}, |
| { OlyID_TG_7, "TG-7"}, |
| { OlyID_E_10, "E-10"}, |
| { OlyID_AIR_A01, "AIR A01"}, |
| { OlyID_AIR_A01, "AIR-A01"}, |
| { OlyID_E_330, "E-330"}, |
| { OlyID_E_500, "E-500"}, |
| { OlyID_E_400, "E-400"}, |
| { OlyID_E_510, "E-510"}, |
| { OlyID_E_3, "E-3"}, |
| { OlyID_E_410, "E-410"}, |
| { OlyID_E_420, "E-420"}, |
| { OlyID_E_30, "E-30"}, |
| { OlyID_E_520, "E-520"}, |
| { OlyID_E_P1, "E-P1"}, |
| { OlyID_E_620, "E-620"}, |
| { OlyID_E_P2, "E-P2"}, |
| { OlyID_E_PL1, "E-PL1"}, |
| { OlyID_E_450, "E-450"}, |
| { OlyID_E_600, "E-600"}, |
| { OlyID_E_P3, "E-P3"}, |
| { OlyID_E_5, "E-5"}, |
| { OlyID_E_PL2, "E-PL2"}, |
| { OlyID_E_M5, "E-M5"}, |
| { OlyID_E_PL3, "E-PL3"}, |
| { OlyID_E_PM1, "E-PM1"}, |
| { OlyID_E_PL1s, "E-PL1s"}, |
| { OlyID_E_PL5, "E-PL5"}, |
| { OlyID_E_PM2, "E-PM2"}, |
| { OlyID_E_P5, "E-P5"}, |
| { OlyID_E_PL6, "E-PL6"}, |
| { OlyID_E_PL7, "E-PL7"}, |
| { OlyID_E_M1, "E-M1"}, |
| { OlyID_E_M10, "E-M10"}, |
| { OlyID_E_M5_Mark_II, "E-M5 Mark II"}, |
| { OlyID_E_M5_Mark_II, "E-M5MarkII"}, |
| { OlyID_E_M5_Mark_II, "E-M5_M2"}, |
| { OlyID_E_M10_Mark_II, "E-M10 Mark II"}, // Clauss piX 5oo |
| { OlyID_E_M10_Mark_II, "E-M10MarkII"}, |
| { OlyID_E_M10_Mark_II, "E-M10_M2"}, |
| { OlyID_PEN_F, "PEN-F"}, |
| { OlyID_E_PL8, "E-PL8"}, |
| { OlyID_E_M1_Mark_II, "E-M1 Mark II"}, |
| { OlyID_E_M1_Mark_II, "E-M1MarkII"}, |
| { OlyID_E_M1_Mark_II, "E-M1_M2"}, |
| { OlyID_E_M10_Mark_III, "E-M10 Mark III"}, |
| { OlyID_E_M10_Mark_III, "E-M10_M3"}, |
| { OlyID_E_PL9, "E-PL9"}, |
| { OlyID_E_M1X, "E-M1X"}, |
| { OlyID_E_PL10, "E-PL10"}, |
| { OlyID_E_M10_Mark_IV, "E-M10 Mark IV"}, |
| { OlyID_E_M10_Mark_IV, "E-M10MarkIV"}, |
| { OlyID_E_M10_Mark_IV, "E-M10_M4"}, |
| { OlyID_E_M5_Mark_III, "E-M5 Mark III"}, |
| { OlyID_E_M5_Mark_III, "E-M5MarkIII"}, |
| { OlyID_E_M5_Mark_III, "E-M5_M3"}, |
| { OlyID_E_M1_Mark_III, "E-M1 Mark III"}, |
| { OlyID_E_M1_Mark_III, "E-M1MarkIII"}, |
| { OlyID_E_M1_Mark_III, "E-M1_M3"}, |
| { OlyID_E_P7 "E-P7"}, |
| { OlyID_C_3030Z, "C-3030Z"}, |
| { OlyID_C_3030Z, "C3030Z"}, |
| { OlyID_C_5050Z, "C-5050Z"}, |
| { OlyID_C_5050Z, "C5050Z"}, |
| { OlyID_C_350Z, "C-350Z"}, |
| { OlyID_C_350Z, "X200,D560Z,C350Z"}, |
| { OlyID_C_740UZ, "C-740UZ"}, |
| { OlyID_C_740UZ, "C740UZ"}, |
| { OlyID_C_5060WZ, "C-5060WZ"}, |
| { OlyID_C_5060WZ, "C5060WZ"}, |
| { OlyID_C_8080WZ, "C-8080WZ"}, |
| { OlyID_C_8080WZ, "C8080WZ"}, |
| { OlyID_C_770UZ, "C-770UZ"}, |
| { OlyID_C_770UZ, "C770UZ"}, |
| { OlyID_C_7070WZ, "C-7070WZ"}, |
| { OlyID_C_7070WZ, "C7070WZ"}, |
| { OlyID_C_7000Z, "C-7000Z"}, |
| { OlyID_C_7000Z, "C70Z,C7000Z"}, |
| { OlyID_SP_500UZ, "SP-500UZ"}, |
| { OlyID_SP_500UZ, "SP500UZ"}, |
| { OlyID_SP_310, "SP-310"}, |
| { OlyID_SP_310, "SP310"}, |
| { OlyID_SP_350, "SP-350"}, |
| { OlyID_SP_350, "SP350"}, |
| { OlyID_SP_320, "SP-320"}, |
| { OlyID_SP_320, "SP320"}, |
| }, |
| |
| penique[] = { |
| { PentaxID_Optio_S, "Optio S"}, |
| { PentaxID_Optio_S_V101, "Optio S V1.01"}, |
| { PentaxID_staristD, "*istD"}, |
| { PentaxID_staristD, "*ist D"}, |
| { PentaxID_Optio_33WR, "Optio 33WR"}, |
| { PentaxID_Optio_S4, "Optio S4"}, |
| { PentaxID_Optio_750Z, "Optio 750Z"}, |
| { PentaxID_staristDS, "*istDS"}, |
| { PentaxID_staristDS, "*ist DS"}, |
| { PentaxID_staristDL, "*istDL"}, |
| { PentaxID_staristDL, "*ist DL"}, |
| { PentaxID_staristDS2, "*istDS2"}, |
| { PentaxID_staristDS2, "*ist DS2"}, |
| { PentaxID_GX_1S, "GX-1S"}, // Samsung |
| { PentaxID_staristDL2, "*istDL2"}, |
| { PentaxID_staristDL2, "*ist DL2"}, |
| { PentaxID_GX_1L, "GX-1L"}, // Samsung |
| { PentaxID_K100D, "K100D"}, |
| { PentaxID_K110D, "K110D"}, |
| { PentaxID_K100D_Super, "K100D Super"}, |
| { PentaxID_K10D, "K10D"}, |
| { PentaxID_GX10, "GX10"}, // Samsung |
| { PentaxID_GX10, "GX-10"}, // Samsung |
| { PentaxID_K20D, "K20D"}, |
| { PentaxID_GX20, "GX20"}, // Samsung |
| { PentaxID_GX20, "GX-20"}, // Samsung |
| { PentaxID_K200D, "K200D"}, |
| { PentaxID_K2000, "K2000"}, |
| { PentaxID_K_m, "K-m"}, |
| { PentaxID_K_7, "K-7"}, |
| { PentaxID_K_x, "K-x"}, |
| { PentaxID_645D, "645D"}, |
| { PentaxID_K_r, "K-r"}, |
| { PentaxID_K_5, "K-5"}, |
| { PentaxID_Q, "Q"}, |
| { PentaxID_K_01, "K-01"}, |
| { PentaxID_K_30, "K-30"}, |
| { PentaxID_Q10, "Q10"}, |
| { PentaxID_K_5_II, "K-5 II"}, |
| { PentaxID_K_5_II_s, "K-5 II s"}, |
| { PentaxID_Q7, "Q7"}, |
| { PentaxID_MX_1, "MX-1"}, |
| { PentaxID_K_50, "K-50"}, |
| { PentaxID_K_3, "K-3"}, |
| { PentaxID_K_500, "K-500"}, |
| { PentaxID_645Z, "645Z"}, |
| { PentaxID_K_S1, "K-S1"}, |
| { PentaxID_K_S2, "K-S2"}, // Ricoh |
| { PentaxID_Q_S1, "Q-S1"}, |
| { PentaxID_K_1, "K-1"}, // Ricoh |
| { PentaxID_K_3_II, "K-3 II"}, // Ricoh |
| { PentaxID_GR_III, "GR III"}, // Ricoh |
| { PentaxID_K_70, "K-70"}, // Ricoh |
| { PentaxID_KF, "KF"}, // Ricoh |
| { PentaxID_KP, "KP"}, // Ricoh |
| { PentaxID_K_1_Mark_II, "K-1 Mark II"}, // Ricoh |
| { PentaxID_K_3_III, "K-3 Mark III"}, // Ricoh |
| { PentaxID_GR_IIIx, "GR IIIx"}, |
| { PentaxID_K_3_III_Mono, "K-3 Mark III Monochrome"}, |
| }, |
| #endif |
| sonique[] = { |
| { SonyID_DSC_R1, "DSC-R1"}, |
| { SonyID_DSLR_A100, "DSLR-A100"}, |
| { SonyID_DSLR_A900, "DSLR-A900"}, |
| { SonyID_DSLR_A700, "DSLR-A700"}, |
| { SonyID_DSLR_A200, "DSLR-A200"}, |
| { SonyID_DSLR_A350, "DSLR-A350"}, |
| { SonyID_DSLR_A300, "DSLR-A300"}, |
| { SonyID_DSLR_A900_APSC, "DSLR-A900"}, |
| { SonyID_DSLR_A380, "DSLR-A380"}, // DSLR-A390 |
| { SonyID_DSLR_A330, "DSLR-A330"}, |
| { SonyID_DSLR_A230, "DSLR-A230"}, |
| { SonyID_DSLR_A290, "DSLR-A290"}, |
| { SonyID_DSLR_A850, "DSLR-A850"}, |
| { SonyID_DSLR_A850_APSC, "DSLR-A850"}, |
| { SonyID_DSLR_A550, "DSLR-A550"}, |
| { SonyID_DSLR_A500, "DSLR-A500"}, |
| { SonyID_DSLR_A450, "DSLR-A450"}, |
| { SonyID_NEX_5, "NEX-5"}, |
| { SonyID_NEX_3, "NEX-3"}, |
| { SonyID_SLT_A33, "SLT-A33"}, |
| { SonyID_SLT_A55, "SLT-A55"}, // SLT-A55V |
| { SonyID_DSLR_A560, "DSLR-A560"}, |
| { SonyID_DSLR_A580, "DSLR-A580"}, |
| { SonyID_NEX_C3, "NEX-C3"}, |
| { SonyID_SLT_A35, "SLT-A35"}, |
| { SonyID_SLT_A65, "SLT-A65"}, // SLT-A65V |
| { SonyID_SLT_A77, "SLT-A77"}, // SLT-A77V |
| { SonyID_NEX_5N, "NEX-5N"}, |
| { SonyID_NEX_7, "NEX-7"}, // Hasselblad Lunar |
| { SonyID_NEX_VG20, "NEX-VG20"}, |
| { SonyID_SLT_A37, "SLT-A37"}, |
| { SonyID_SLT_A57, "SLT-A57"}, |
| { SonyID_NEX_F3, "NEX-F3"}, |
| { SonyID_SLT_A99, "SLT-A99"}, // SLT-A99V / Hasselblad HV |
| { SonyID_NEX_6, "NEX-6"}, |
| { SonyID_NEX_5R, "NEX-5R"}, |
| { SonyID_DSC_RX100, "DSC-RX100"}, // Hasselblad Stellar |
| { SonyID_DSC_RX1, "DSC-RX1"}, |
| { SonyID_NEX_VG900, "NEX-VG900"}, |
| { SonyID_NEX_VG30, "NEX-VG30"}, |
| { SonyID_ILCE_3000, "ILCE-3000"}, // ILCE-3500 |
| { SonyID_SLT_A58, "SLT-A58"}, |
| { SonyID_NEX_3N, "NEX-3N"}, |
| { SonyID_ILCE_7, "ILCE-7"}, |
| { SonyID_NEX_5T, "NEX-5T"}, |
| { SonyID_DSC_RX100M2, "DSC-RX100M2"}, // Hasselblad Stellar II |
| { SonyID_DSC_RX10, "DSC-RX10"}, |
| { SonyID_DSC_RX1R, "DSC-RX1R"}, |
| { SonyID_ILCE_7R, "ILCE-7R"}, // Hasselblad Lusso |
| { SonyID_ILCE_6000, "ILCE-6000"}, |
| { SonyID_ILCE_5000, "ILCE-5000"}, |
| { SonyID_DSC_RX100M3, "DSC-RX100M3"}, |
| { SonyID_ILCE_7S, "ILCE-7S"}, |
| { SonyID_ILCA_77M2, "ILCA-77M2"}, |
| { SonyID_ILCE_5100, "ILCE-5100"}, |
| { SonyID_ILCE_7M2, "ILCE-7M2"}, |
| { SonyID_DSC_RX100M4, "DSC-RX100M4"}, |
| { SonyID_DSC_RX10M2, "DSC-RX10M2"}, |
| { SonyID_DSC_RX1RM2, "DSC-RX1RM2"}, |
| { SonyID_ILCE_QX1, "ILCE-QX1"}, // Sony UMC-R10C |
| { SonyID_ILCE_7RM2, "ILCE-7RM2"}, |
| { SonyID_ILCE_7SM2, "ILCE-7SM2"}, |
| { SonyID_ILCA_68, "ILCA-68"}, |
| { SonyID_ILCA_99M2, "ILCA-99M2"}, |
| { SonyID_DSC_RX10M3, "DSC-RX10M3"}, |
| { SonyID_DSC_RX100M5, "DSC-RX100M5"}, |
| { SonyID_ILCE_6300, "ILCE-6300"}, |
| { SonyID_ILCE_9, "ILCE-9"}, |
| { SonyID_ILCE_6500, "ILCE-6500"}, |
| { SonyID_ILCE_7RM3, "ILCE-7RM3"}, |
| { SonyID_ILCE_7M3, "ILCE-7M3"}, |
| { SonyID_DSC_RX0, "DSC-RX0"}, |
| { SonyID_DSC_RX10M4, "DSC-RX10M4"}, |
| { SonyID_DSC_RX100M6, "DSC-RX100M6"}, |
| { SonyID_DSC_HX99, "DSC-HX99"}, |
| { SonyID_DSC_RX100M5A, "DSC-RX100M5A"}, |
| { SonyID_ILCE_6400, "ILCE-6400"}, |
| { SonyID_DSC_RX0M2, "DSC-RX0M2"}, |
| { SonyID_DSC_HX95, "DSC-HX95"}, |
| { SonyID_DSC_RX100M7, "DSC-RX100M7"}, |
| { SonyID_ILCE_7RM4, "ILCE-7RM4"}, |
| { SonyID_ILCE_9M2, "ILCE-9M2"}, |
| { SonyID_ILCE_6600, "ILCE-6600"}, |
| { SonyID_ILCE_6100, "ILCE-6100"}, |
| { SonyID_ZV_1, "ZV-1"}, |
| { SonyID_ILCE_7C, "ILCE-7C"}, |
| { SonyID_ZV_E10, "ZV-E10"}, |
| { SonyID_ILCE_7SM3, "ILCE-7SM3"}, |
| { SonyID_ILCE_1, "ILCE-1"}, |
| { SonyID_ILME_FX3, "ILME-FX3"}, |
| { SonyID_ILCE_7RM3A, "ILCE-7RM3A"}, |
| { SonyID_ILCE_7RM4A, "ILCE-7RM4A"}, |
| { SonyID_ILCE_7M4, "ILCE-7M4"}, |
| |
| // Sony ZV-1F doesn't save raw |
| // { SonyID_ZV_1F, "ZV-1F"}, |
| |
| { SonyID_ILCE_7RM5, "ILCE-7RM5"}, |
| { SonyID_ILME_FX30, "ILME-FX30"}, |
| { SonyID_ILCE_9M3, "ILCE-9M3"}, |
| { SonyID_ZV_E1, "ZV-E1"}, |
| { SonyID_ILCE_6700, "ILCE-6700"}, |
| { SonyID_ZV_1M2, "ZV-1M2"}, |
| { SonyID_ILCE_7CR, "ILCE-7CR"}, |
| { SonyID_ILCE_7CM2, "ILCE-7CM2"}, |
| { SonyID_ILX_LR1, "ILX-LR1"}, |
| { SonyID_ZV_E10M2, "ZV-E10M2"}, |
| { SonyID_ILME_FX2, "ILME-FX2"}, |
| }; |
| |
| static const char *orig; |
| |
| static const char fujialias[][16] = { |
| "@DBP for GX680", "DX-2000", |
| "@F500EXR", "F505EXR", |
| "@F600EXR", "F605EXR", |
| "@F770EXR", "F775EXR", |
| "@HS10", "HS10 HS11", |
| "@HS20EXR", "HS22EXR", |
| "@HS30EXR", "HS33EXR", "HS35EXR", |
| "@S5100", "S5500", |
| "@S5200", "S5600", |
| "@S6000fd", "S6500fd", |
| "@S9000", "S9500", |
| "@S9100", "S9600", |
| "@S200EXR", "S205EXR", |
| "@X-T1 IR", "X-T1IR", |
| "@GFX 100 II", "GFX100 II", |
| "@GFX 100S II", "GFX100S II", |
| "@GFX 100S", "GFX100S", |
| "@GFX 50S II", "GFX50S II" |
| }; |
| |
| static const char kodakalias[][16] = { |
| "@DCS Pro 14N", "Camerz ZDS 14", // Camerz rebadge make: "Photo Control" |
| "@DCS720X", "SCS2000", |
| "@DCS520C", "EOS D2000C", "EOS D2000", // EOS rebadge make: Canon |
| "@DCS560C", "EOS D6000C", "EOS D6000", // EOS rebadge make: Canon |
| "@DCS460M", "DCS460A", // 'A' was supposed to stand for 'achromatic', marketing changed it to 'M' |
| "@DCS460", "DCS460C", "DCS460D", |
| "@DCS465", "DCS465C", "DCS465D", |
| "@EOSDCS1", "EOSDCS1B", "EOSDCS1C", |
| "@EOSDCS3", "EOSDCS3B", "EOSDCS3C", |
| }; |
| |
| static const struct |
| { |
| const char *Kmodel; |
| ushort mount; |
| } Kodak_mounts[] = { |
| {"DCS465", LIBRAW_MOUNT_DigitalBack}, |
| {"DCS5", LIBRAW_MOUNT_Canon_EF}, |
| {"DCS Pro SLR/c", LIBRAW_MOUNT_Canon_EF}, |
| {"DCS", LIBRAW_MOUNT_Nikon_F}, |
| {"EOS", LIBRAW_MOUNT_Canon_EF}, |
| {"NC2000", LIBRAW_MOUNT_Nikon_F}, // AP "News Camera" |
| {"Pixpro S-1", LIBRAW_MOUNT_mFT}, |
| {"ProBack", LIBRAW_MOUNT_DigitalBack}, |
| {"SCS1000", LIBRAW_MOUNT_Canon_EF}, |
| }; |
| |
| static const char *KodakMonochrome[] = { |
| "DCS420M", "DCS420A", "DCS420I", |
| "DCS460M", "DCS460A", "DCS460I", |
| "DCS465M", "DCS465A", "DCS465I", |
| "DCS560M", "DCS660M", "DCS760M", "EOS D2000M", "EOS D6000M", |
| "EOSDCS1M", "EOSDCS1I", |
| "EOSDCS3M", "EOSDCS3I", |
| "EOSDCS5M", "EOSDCS5I", |
| "NC2000M", "NC2000A", "NC2000I", |
| }; |
| |
| static const char leafalias[][16] = { |
| // Leaf re-badged to Mamiya |
| "@Aptus-II 5", "DM22", |
| "@Aptus-II 6", "DM28", |
| "@Aptus-II 7", "DM33", |
| "@Aptus-II 8", "DM40", |
| "@Aptus-II 10", "DM56", |
| }; |
| |
| static const char KonicaMinolta_aliases[][24] = { |
| "@DG-5D", "DYNAX 5D", "MAXXUM 5D", "ALPHA-5 DIGITAL", "ALPHA SWEET DIGITAL", |
| "@DG-7D", "DYNAX 7D", "MAXXUM 7D", "ALPHA-7 DIGITAL", |
| }; |
| |
| static const char nikonalias[][16] = { |
| "@COOLPIX 2100", "E2100", "@COOLPIX 2500", "E2500", |
| "@COOLPIX 3200", "E3200", "@COOLPIX 3700", "E3700", |
| "@COOLPIX 4300", "E4300", "@COOLPIX 4500", "E4500", |
| "@COOLPIX 5000", "E5000", "@COOLPIX 5400", "E5400", |
| "@COOLPIX 5700", "E5700", "@COOLPIX 8400", "E8400", |
| "@COOLPIX 8700", "E8700", "@COOLPIX 8800", "E8800", |
| "@COOLPIX 700", "E700", "@COOLPIX 800", "E800", |
| "@COOLPIX 880", "E880", "@COOLPIX 900", "E900", |
| "@COOLPIX 950", "E950", "@COOLPIX 990", "E990", |
| "@COOLPIX 995", "E995", "@COOLPIX P7700", "COOLPIX Deneb", |
| "@COOLPIX P7800", "COOLPIX Kalon", |
| }; |
| |
| static const char olyalias[][32] = { // Olympus |
| "@AIR A01", "AIR-A01", |
| "@C-3030Z", "C3030Z", |
| "@C-5050Z", "C5050Z", |
| "@C-5060WZ", "C5060WZ", |
| "@C-7000Z", "C7000Z", "C70Z,C7000Z", "C70Z", |
| "@C-7070WZ", "C7070WZ", |
| "@C-8080WZ", "C8080WZ", |
| "@C-350Z", "C350Z", "X200,D560Z,C350Z", "X200", "D560Z", |
| "@C-740UZ", "C740UZ", |
| "@C-770UZ", "C770UZ", |
| "@E-20", "E-20,E-20N,E-20P", "E-20N", "E-20P", |
| "@E-M10 Mark II", "E-M10MarkII", "E-M10_M2", "piX 5oo", |
| "@E-M10 Mark III", "E-M10MarkIII", "E-M10_M3", |
| "@E-M10 Mark IV", "E-M10MarkIV", "E-M10_M4", |
| "@E-M1 Mark II", "E-M1MarkII", "E-M1_M2", |
| "@E-M1 Mark III", "E-M1MarkIII", "E-M1_M3", |
| "@E-M5 Mark II", "E-M5MarkII", "E-M5_M2", |
| "@E-M5 Mark III", "E-M5MarkIII", "E-M5_M3", |
| "@OM-1 Mark II", "OM-1MarkII", "OM-1_M2", |
| "@SH-2", "SH-3", |
| "@SP-310", "SP310", |
| "@SP-320", "SP320", |
| "@SP-350", "SP350", |
| "@SP-500UZ", "SP500UZ", |
| "@SP-510UZ", "SP510UZ", |
| "@SP-550UZ", "SP550UZ", |
| "@SP-560UZ", "SP560UZ", |
| "@SP-565UZ", "SP565UZ", |
| "@SP-570UZ", "SP570UZ", |
| "@Stylus 1", "STYLUS1", "STYLUS1s", "STYLUS1,1s", |
| }; |
| |
| static const char panalias[][16] = { // Panasonic, PanaLeica |
| // fixed lens |
| "@DMC-FX150", "DMC-FX180", |
| "@DC-FZ1000M2", "DC-FZ10002", "V-Lux 5", |
| "@DMC-FZ1000", "V-LUX (Typ 114)", |
| "@DMC-FZ2500", "DMC-FZ2000", "DMC-FZH1", |
| "@DMC-FZ100", "V-LUX 2", |
| "@DMC-FZ150", "V-LUX 3", |
| "@DMC-FZ200", "V-LUX 4", |
| "@DMC-FZ300", "DMC-FZ330", |
| "@DMC-FZ35", "DMC-FZ38", |
| "@DMC-FZ40", "DMC-FZ42", "DMC-FZ45", "DC-FZ40", "DC-FZ42", "DC-FZ45", |
| "@DMC-FZ50", "V-LUX 1", "V-LUX1", |
| "@DMC-FZ70", "DMC-FZ72", |
| "@DC-FZ80", "DC-FZ81", "DC-FZ82", "DC-FZ83", "DC-FZ85", |
| "@DMC-LC1", "DIGILUX 2", "Digilux 2", "DIGILUX2", |
| "@DMC-LF1", "C (Typ 112)", |
| "@DC-LX100M2", "D-Lux 7", |
| "@DMC-LX100", "D-LUX (Typ 109)", "D-Lux (Typ 109)", |
| "@DMC-LX1", "D-Lux2", "D-LUX2", "D-LUX 2", |
| "@DMC-LX2", "D-LUX 3", "D-LUX3", |
| "@DMC-LX3", "D-LUX 4", |
| "@DMC-LX5", "D-LUX 5", |
| "@DMC-LX7", "D-LUX 6", |
| "@DMC-LX9", "DMC-LX10", "DMC-LX15", |
| "@DMC-ZS100", "DMC-ZS110", "DMC-TZ100", "DMC-TZ101", "DMC-TZ110", "DMC-TX1", |
| "@DC-ZS200", "DC-ZS220", "DC-TZ200", "DC-TZ202", "DC-TZ220", "DC-TZ200D", "DC-TZ202D", "DC-TZ220D", "DC-ZS200D", "DC-ZS220D" "DC-TX2", "C-Lux", "CAM-DC25", |
| "@DMC-ZS40", "DMC-TZ60", "DMC-TZ61", |
| "@DMC-ZS50", "DMC-TZ70", "DMC-TZ71", |
| "@DMC-ZS60", "DMC-TZ80", "DMC-TZ81", "DMC-TZ82", "DMC-TZ85", |
| "@DC-ZS70", "DC-TZ90", "DC-TZ91", "DC-TZ92", "DC-TZ93", |
| "@DC-ZS80", "DC-TZ95", "DC-TZ96", "DC-TZ97", |
| |
| // interchangeable lens |
| "@DC-G100", "DC-G110", |
| "@DC-G99", "DC-G90", "DC-G91", "DC-G95", |
| "@DMC-G7", "DMC-G70", |
| "@DMC-G8", "DMC-G80", "DMC-G81", "DMC-G85", |
| "@DMC-GH4", "AG-GH4", "CGO4", |
| "@DC-GF10", "DC-GF90", "DC-GX880", |
| "@DC-GF9", "DC-GX850", "DC-GX800", |
| "@DMC-GM1", "DMC-GM1S", |
| "@DMC-GX85", "DMC-GX80", "DMC-GX7MK2", |
| "@DC-GX9", "DC-GX7MK3", |
| "@DMC-L1", "DIGILUX 3", "DIGILUX3", // full 4/3 mount, not m43 |
| }; |
| |
| static const char phase1alias[][16] = { |
| "@H20", "H 20", |
| "@H25", "H 25", |
| "@P20+", "P 20+", |
| "@P20", "P 20", |
| "@P21+", "P 21+", "M18", // "Mamiya M18" |
| "@P21", "P 21", |
| "@P25+", "P 25+", "M22", // "Mamiya M22" |
| "@P25", "P 25", |
| "@P30+", "P 30+", "M31", // "Mamiya M31" |
| "@P30", "P 30", |
| "@P40+", "P 40+", |
| "@P40", "P 40", |
| "@P45+", "P 45+", |
| "@P45", "P 45", |
| "@P65+", "P 65+", |
| "@P65", "P 65", |
| }; |
| |
| static const char SamsungPentax_aliases[][16] = { |
| "@*istDL2", "*ist DL2", "GX-1L", |
| "@*istDS2", "*ist DS2", "GX-1S", |
| "@*istDL", "*ist DL", |
| "@*istDS", "*ist DS", |
| "@*istD", "*ist D", |
| "@K10D", "GX10", "GX-10", |
| "@K20D", "GX20", "GX-20", |
| "@K-m", "K2000", |
| }; |
| |
| static const char samsungalias[][64] = { |
| "@EX1", "TL500", |
| "@NX U", "EK-GN100", "EK-GN110", "EK-GN120", "EK-KN120", "Galaxy NX", |
| "@NX mini", "NXF1", |
| "@WB2000", "TL350", |
| // "@WB5000", "WB5000/HZ25W", // no spaces around the slash separating names |
| // "@WB5500", "WB5500 / VLUU WB5500 / SAMSUNG HZ50W", |
| // "@WB500", "WB510 / VLUU WB500 / SAMSUNG HZ10W", |
| // "@WB550", "WB560 / VLUU WB550 / SAMSUNG HZ15W", |
| // "@WB650", "SAMSUNG WB650 / VLUU WB650 / SAMSUNG WB660" aka HZ35W |
| }; |
| |
| //clang-format on |
| if (makeIs(LIBRAW_CAMERAMAKER_VLUU)) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Samsung); |
| } |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Samsung) && |
| (ilm.CameraMount == LIBRAW_MOUNT_Pentax_K)) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Pentax); |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Unknown)) { |
| if (strcasestr(model, "Google")) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Google); |
| } |
| #ifdef USE_6BY9RPI |
| else if(strcasestr(make,"RaspberryPi")) |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_RaspberryPi); |
| #endif |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Hasselblad) && is_Sony) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Sony); |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_OmDigital)) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Olympus); |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Clauss) && (OlyID == OlyID_E_M10_Mark_II)) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Olympus); |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Canon) && |
| (!strncmp(model, "EOS D2000", 9) || // don't use unique_id here |
| !strncmp(model, "EOS D6000", 9) || // because ids for Monochrome models are unknown |
| !strncmp(model, "EOSDCS", 6))) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Kodak); |
| // if (unique_id == CanonID_EOS_D2000C) { |
| // |
| // } else if (unique_id == CanonID_EOS_D6000C) { |
| /// |
| // } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_PhotoControl) && |
| !strncasecmp(model, "Camerz ZDS 14", 13)) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Kodak); |
| |
| } else { |
| strcpy(normalized_make, make); |
| } |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Apple)) { |
| if ((imgdata.color.UniqueCameraModel[0]) && |
| (!strncmp(model, "iPad", 4) || !strncmp(model, "iPhone", 6))) |
| strcpy(model, imgdata.color.UniqueCameraModel); |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Kodak)) { |
| if ((model[6] == ' ') && |
| (!strncmp(model, "DCS4", 4) || |
| !strncmp(model, "NC2000", 6))) |
| { |
| model[6] = 0; |
| } |
| if ((model[6] != 'A') && |
| (model[6] != 'I') && |
| (model[6] != 'M') && |
| !strncmp(model, "NC2000", 6)) |
| { |
| model[6] = 0; |
| } |
| } |
| |
| else if (makeIs(LIBRAW_CAMERAMAKER_Ricoh) && |
| !strncmp(model, "GXR", 3)) { |
| strcpy(ilm.body, "Ricoh GXR"); |
| if (!imgdata.lens.Lens[0] && imgdata.color.UniqueCameraModel[0]) { |
| strcpy (imgdata.lens.Lens, imgdata.color.UniqueCameraModel); |
| remove_caseSubstr (imgdata.lens.Lens, (char *)"Ricoh"); |
| remove_caseSubstr (imgdata.lens.Lens, (char *)"Lens"); |
| removeExcessiveSpaces (imgdata.lens.Lens); |
| } |
| if (ilm.LensID == LIBRAW_LENS_NOT_SET) { |
| if (strstr(imgdata.lens.Lens, "50mm")) |
| ilm.LensID = 1; |
| else if (strstr(imgdata.lens.Lens, "S10")) |
| ilm.LensID = 2; |
| else if (strstr(imgdata.lens.Lens, "P10")) |
| ilm.LensID = 3; |
| else if (strstr(imgdata.lens.Lens, "28mm")) |
| ilm.LensID = 5; |
| else if (strstr(imgdata.lens.Lens, "A16")) |
| ilm.LensID = 6; |
| } |
| switch (ilm.LensID) { |
| case 1: // GR Lens A12 50mm F2.5 Macro |
| strcpy(model, "GXR A12 50mm"); |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_RicohModule; |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_PRIME_LENS; |
| break; |
| case 2: |
| strcpy(model, "GXR S10"); |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_1div1p7INCH; |
| ilm.CameraMount = LIBRAW_MOUNT_RicohModule; |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_ZOOM_LENS; |
| break; |
| case 3: // Ricoh Lens P10 28-300mm F3.5-5.6 VC |
| strcpy(model, "GXR P10"); |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_1div2p3INCH; |
| ilm.CameraMount = LIBRAW_MOUNT_RicohModule; |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_ZOOM_LENS; |
| break; |
| case 5: // GR Lens A12 28mm F2.5 |
| strcpy(model, "GXR A12 28mm"); |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_RicohModule; |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_PRIME_LENS; |
| break; |
| case 6: // Ricoh Lens A16 24-85mm F3.5-5.5 |
| strcpy(model, "GXR A16"); |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_RicohModule; |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_ZOOM_LENS; |
| break; |
| case 8: // Ricoh Mount A12 (Leica M lenses) |
| strcpy(model, "GXR Mount A12"); |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_Leica_M; |
| ilm.LensID = LIBRAW_LENS_NOT_SET; |
| break; |
| } |
| } |
| |
| strcpy(normalized_model, model); |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Canon)) |
| { |
| if (unique_id) |
| { |
| if ((unique_id != CanonID_EOS_D2000C) && |
| (unique_id != CanonID_EOS_D6000C)) |
| { |
| for (i = 0; i < int(sizeof unique / sizeof *unique); i++) |
| { |
| if (unique_id == unique[i].id) |
| { |
| if (!strcmp(model, "EOS Ra")) { |
| strcpy(normalized_model, model); |
| } else { |
| strcpy(model, unique[i].t_model); |
| strcpy(normalized_model, unique[i].t_model); |
| } |
| break; |
| } |
| } |
| } |
| } |
| else |
| { |
| if ((dng_version) && |
| (strlen(imgdata.color.UniqueCameraModel) > 6) && |
| strncmp(imgdata.color.UniqueCameraModel+6, "PowerShot", 9)) |
| { |
| if (!strcmp(model, "EOS Ra")) { |
| ilm.CamID = unique_id = CanonID_EOS_R; |
| strcpy(normalized_model, model); |
| // try_xml = 1; // ?? |
| } else { |
| for (i = 0; i < int(sizeof unique / sizeof *unique); i++) |
| { |
| if (!strcmp(unique[i].t_model, imgdata.color.UniqueCameraModel+6)) |
| { |
| ilm.CamID = unique_id = unique[i].id; |
| strcpy(normalized_model, unique[i].t_model); |
| try_xml = 1; |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Fujifilm)) |
| { |
| for (i = 0; i < int(sizeof fujialias / sizeof *fujialias); i++) |
| { |
| if (fujialias[i][0] == '@') |
| { |
| orig = fujialias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, fujialias[i])) |
| { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Hasselblad)) { |
| parseHassyModel(); |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Mamiya)) |
| { |
| for (i = 0; i < int(sizeof phase1alias / sizeof *phase1alias); i++) |
| { // re-badged Phase One backs |
| if (phase1alias[i][0] == '@') orig = phase1alias[i] + 1; |
| else if (!strcmp(model, phase1alias[i])) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_PhaseOne); |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| for (i = 0; i < int(sizeof leafalias / sizeof *leafalias); i++) |
| { // re-badged Leaf backs |
| if (leafalias[i][0] == '@') orig = leafalias[i] + 1; |
| else if (!strcmp(model, leafalias[i])) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Leaf); |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| |
| /* repeating, because make for some Mamiya re-badged Leaf backs is set to |
| * Leaf */ |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Leaf)) |
| { |
| for (i = 0; i < int(sizeof leafalias / sizeof *leafalias); i++) |
| { // re-badged Leaf backs |
| if (leafalias[i][0] == '@') |
| { |
| orig = leafalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, leafalias[i])) |
| { // maybe to change regular "make" to "Mamiya" too |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| if ((ps = strchr(normalized_model, '('))) |
| *ps = 0; |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Minolta) || |
| makeIs(LIBRAW_CAMERAMAKER_Konica)) |
| { |
| if (makeIs(LIBRAW_CAMERAMAKER_Konica) && !strncasecmp(model, "DiMAGE", 6)) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Minolta); |
| strcpy(make, "Minolta"); |
| } |
| else |
| { |
| for (i = 0; |
| i<int(sizeof KonicaMinolta_aliases / sizeof *KonicaMinolta_aliases); |
| i++) |
| { |
| if (KonicaMinolta_aliases[i][0] == '@') |
| { |
| orig = KonicaMinolta_aliases[i] + 1; |
| if (!strcmp(model, orig)) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Minolta); |
| strcpy(make, "Minolta"); |
| break; |
| } |
| } |
| else if (!strcasecmp(model, KonicaMinolta_aliases[i])) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Minolta); |
| strcpy(make, "Minolta"); |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Nikon)) |
| { |
| for (i = 0; i < int(sizeof nikonalias / sizeof *nikonalias); i++) |
| { |
| if (nikonalias[i][0] == '@') |
| { |
| orig = nikonalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, nikonalias[i])) |
| { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Olympus)) { |
| for (i = 0; i < int(sizeof olyalias / sizeof *olyalias); i++) { |
| if (olyalias[i][0] == '@') { |
| orig = olyalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } else if (!strcmp(model, olyalias[i])) { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| |
| if (!OlyID) { |
| if (!strcmp(normalized_model, "C-740UZ")) { |
| ilm.CamID = OlyID = unique_id = OlyID_C_740UZ; |
| |
| } else if (!strcmp(normalized_model, "C-770UZ")) { |
| ilm.CamID = OlyID = unique_id = OlyID_C_770UZ; |
| } |
| } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Panasonic) || |
| makeIs(LIBRAW_CAMERAMAKER_Leica) || |
| makeIs(LIBRAW_CAMERAMAKER_Yuneec)) |
| { |
| for (i = 0; i < int(sizeof panalias / sizeof *panalias); i++) |
| { |
| if (panalias[i][0] == '@') |
| { |
| orig = panalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, panalias[i])) |
| { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Panasonic); |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Pentax)) { |
| if (!unique_id) { |
| if (!strcmp(model, "Optio S")) { |
| ilm.CamID = unique_id = PentaxID_Optio_S; |
| } else if (!strcmp(model, "Optio S V1.01")) { |
| ilm.CamID = unique_id = PentaxID_Optio_S_V101; |
| } else if (!strcmp(model, "Optio S4")) { |
| ilm.CamID = unique_id = PentaxID_Optio_S4; |
| } else if (!strcmp(model, "Optio 750Z")) { |
| ilm.CamID = unique_id = PentaxID_Optio_750Z; |
| } else if (!strcmp(model, "Optio 33WR")) { |
| ilm.CamID = unique_id = PentaxID_Optio_33WR; |
| } |
| } |
| |
| for (i = 0; |
| i < int(sizeof SamsungPentax_aliases / sizeof *SamsungPentax_aliases); |
| i++) { |
| if (SamsungPentax_aliases[i][0] == '@') { |
| orig = SamsungPentax_aliases[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } else if (!strcmp(model, SamsungPentax_aliases[i])) { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| if (!strncmp(model, "GR", 2)) { |
| setMakeFromIndex(LIBRAW_CAMERAMAKER_Ricoh); |
| strcpy(make, "Ricoh"); |
| } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_PhaseOne)) |
| { |
| for (i = 0; i < int(sizeof phase1alias / sizeof *phase1alias); i++) |
| { |
| if (phase1alias[i][0] == '@') |
| { |
| orig = phase1alias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, phase1alias[i])) |
| { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| if (strstr(imPhaseOne.FirmwareString, "Achromatic")) |
| { |
| colors = 1; |
| filters = 0; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Samsung)) |
| { |
| j = 0; |
| if (strstr(model, "WB5500") || strstr(model, "HZ50W")) |
| { |
| strcpy(model, "WB5500"); |
| j++; |
| } |
| else if (strstr(model, "WB5000") || strstr(model, "HZ25W")) |
| { |
| strcpy(model, "WB5000"); |
| j++; |
| } |
| else if (strstr(model, "WB550") || strstr(model, "HZ15W")) |
| { |
| strcpy(model, "WB550"); |
| j++; |
| } |
| else if (strstr(model, "WB500") || strstr(model, "HZ10W")) |
| { |
| strcpy(model, "WB500"); |
| j++; |
| } |
| if (j) |
| { |
| strcpy(normalized_model, model); |
| } |
| else |
| { |
| for (i = 0; i < int(sizeof samsungalias / sizeof *samsungalias); i++) |
| { |
| if (samsungalias[i][0] == '@') |
| { |
| orig = samsungalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, samsungalias[i])) |
| { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| } |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Sony)) { |
| if (unique_id) |
| { |
| for (i = 0; i < int(sizeof sonique / sizeof *sonique); i++) |
| { |
| if (unique_id == sonique[i].id) |
| { |
| if (!strcmp(make, "Sony")) |
| strcpy(model, sonique[i].t_model); |
| strcpy(normalized_model, sonique[i].t_model); |
| break; |
| } |
| } |
| } |
| |
| /* |
| char pgroup9050 = '-'; |
| char cameratype[16] = "unknown"; |
| switch (imSony.CameraType) { |
| case LIBRAW_SONY_DSC: strcpy(cameratype, "DSC"); break; |
| case LIBRAW_SONY_DSLR: strcpy(cameratype, "DSLR"); break; |
| case LIBRAW_SONY_NEX: strcpy(cameratype, "NEX"); break; |
| case LIBRAW_SONY_SLT: strcpy(cameratype, "SLT"); break; |
| case LIBRAW_SONY_ILCE: strcpy(cameratype, "ILCE"); break; |
| case LIBRAW_SONY_ILCA: strcpy(cameratype, "ILCA"); break; |
| } |
| switch (imSony.group9050) { |
| case LIBRAW_SONY_Tag9050a: |
| pgroup9050 = 'a'; |
| break; |
| case LIBRAW_SONY_Tag9050b: |
| pgroup9050 = 'b'; |
| break; |
| case LIBRAW_SONY_Tag9050c: |
| pgroup9050 = 'c'; |
| break; |
| case LIBRAW_SONY_Tag9050d: |
| pgroup9050 = 'd'; |
| break; |
| } |
| printf("catchme\t%s\t%s\t%s\t9050%c\t%d\t%d\n", |
| model, normalized_model, cameratype, pgroup9050, imSony.len_group9050, imSony.FileFormat); |
| */ |
| |
| } else if (makeIs(LIBRAW_CAMERAMAKER_Kodak)) { |
| remove_caseSubstr (normalized_model, (char *)"EasyShare"); |
| remove_caseSubstr (normalized_model, (char *)"ZOOM"); |
| removeExcessiveSpaces (normalized_model); |
| for (i = 0; i < int(sizeof kodakalias / sizeof *kodakalias); i++) |
| { |
| if (kodakalias[i][0] == '@') |
| { |
| orig = kodakalias[i] + 1; |
| if (!strcmp(model, orig)) break; |
| } |
| else if (!strcmp(model, kodakalias[i])) |
| { |
| strcpy(normalized_model, orig); |
| break; |
| } |
| } |
| |
| if (strstr(model, "DC25")) |
| { |
| strcpy(model, "DC25"); |
| strcpy(normalized_model, model); |
| } |
| else if (!strcmp(model, "40")) |
| { |
| strcpy(model, "DC40"); |
| strcpy(normalized_model, model); |
| } |
| else if (strstr(model, "DC50")) |
| { |
| strcpy(model, "DC50"); |
| strcpy(normalized_model, model); |
| } |
| else if (strstr(model, "DC120")) |
| { |
| strcpy(model, "DC120"); |
| strcpy(normalized_model, model); |
| } |
| |
| for (i = 0; i < int(sizeof KodakMonochrome / sizeof *KodakMonochrome); i++) |
| { |
| if (!strncmp(model, KodakMonochrome[i], strlen(KodakMonochrome[i]))) |
| { |
| colors = 1; |
| filters = 0; |
| } |
| } |
| } |
| |
| if (ilm.body[0]) |
| { |
| if ((ilm.CameraMount != LIBRAW_MOUNT_Hasselblad_V) && |
| !strncmp(ilm.body, "Hasselblad ", 11) && |
| ((ilm.body[11] == 'C') || (ilm.body[11] == '2') || |
| (ilm.body[11] == '5') || (ilm.body[11] == '9'))) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_66; |
| ilm.CameraMount = LIBRAW_MOUNT_Hasselblad_V; |
| } |
| else if (!strncmp(ilm.body, "XF", 2) || !strncmp(ilm.body, "645DF", 5)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Mamiya645; |
| ilm.CameraFormat = LIBRAW_FORMAT_645; |
| } |
| else if (!strncmp(ilm.body, "Sinarcam", 2)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_LF; |
| ilm.CameraFormat = LIBRAW_FORMAT_LF; |
| strcat(ilm.body, " shutter system"); |
| } |
| } |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Kodak)) |
| { |
| if (((ilm.CameraMount == LIBRAW_MOUNT_DigitalBack) || |
| (ilm.CameraMount == LIBRAW_MOUNT_Unknown)) && |
| !strncmp(model2, "PB645", 5)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_645; |
| if (model2[5] == 'C') |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Contax645; |
| strcpy(ilm.body, "Contax 645"); |
| } |
| else if (model2[5] == 'H') |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Hasselblad_H; |
| strcpy(ilm.body, "Hasselblad H1/H2"); |
| } |
| else if (model2[5] == 'M') |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Mamiya645; |
| strcpy(ilm.body, "Mamiya 645"); |
| } |
| |
| } else if (!strncasecmp(model, "PIXPRO S-1", 10)) { |
| ilm.CameraFormat = LIBRAW_FORMAT_FT; |
| } else if (!strncasecmp(model, "PIXPRO ", 7)) { |
| ilm.CameraFormat = LIBRAW_FORMAT_1div2p3INCH; |
| } |
| } |
| |
| else if (makeIs(LIBRAW_CAMERAMAKER_Fujifilm)) |
| { |
| if (!strncmp(normalized_model, "DBP", 3)) |
| { |
| strcpy(ilm.body, "Fujifilm GX680"); |
| } |
| } |
| |
| if ((ilm.CameraFormat == LIBRAW_FORMAT_Unknown) || |
| (ilm.CameraMount == LIBRAW_MOUNT_Unknown) || |
| (ilm.CameraMount == LIBRAW_MOUNT_IL_UM)) |
| { |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Canon)) |
| { |
| if (strncmp(normalized_model, "EOS", 3)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Nikon)) |
| { |
| if (normalized_model[0] == 'D') |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Nikon_F; |
| } |
| else |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Panasonic)) |
| { |
| if (!strncmp(normalized_model, "DC-S", 4)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_FF; |
| ilm.CameraMount = LIBRAW_MOUNT_LPS_L; |
| } |
| else if (!strncmp(normalized_model, "DMC-L1", 6) || |
| !strncmp(normalized_model, "DMC-L10", 7)) |
| { |
| ilm.CameraFormat = ilm.CameraMount = LIBRAW_FORMAT_FT; |
| } |
| else if (!strncmp(normalized_model + 2, "-G", 2) || |
| !strncmp(normalized_model + 3, "-G", 2)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_FT; |
| ilm.CameraMount = LIBRAW_MOUNT_mFT; |
| } |
| else |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| ilm.FocalType = LIBRAW_FT_ZOOM_LENS; |
| if (!strncmp(normalized_model + 2, "-LX100", 6) || // DC-LX100M2 |
| !strncmp(normalized_model + 3, "-LX100", 6)) |
| { // DMC-LX100 |
| ilm.CameraFormat = ilm.LensFormat = LIBRAW_FORMAT_FT; |
| } |
| else if (!strncmp(normalized_model, "DMC-CM1", 7)) |
| { |
| ilm.FocalType = LIBRAW_FT_PRIME_LENS; |
| } |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Fujifilm)) |
| { |
| if (!strncmp(normalized_model, "GFX ", 4)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_CROP645; |
| ilm.CameraMount = LIBRAW_MOUNT_Fuji_GF; |
| } |
| else if (!strncmp(normalized_model, "X-", 2) && |
| (strncmp(normalized_model, "X-S1", 4) || |
| !strncmp(normalized_model, "X-S10", 5) || |
| !strncmp(normalized_model, "X-S20", 5))) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_Fuji_X; |
| } |
| else if (((normalized_model[0] == 'S') && // S2Pro, S3Pro, S5Pro |
| (normalized_model[2] == 'P')) || |
| !strncasecmp(normalized_model, "IS Pro", 6)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_Nikon_F; |
| } |
| else if (!strncmp(normalized_model, "DBP", 3)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_68; |
| ilm.CameraMount = LIBRAW_MOUNT_Fuji_GX; |
| } |
| else |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Samsung)) |
| { |
| if ((normalized_model[0] == 'N') && |
| (normalized_model[1] == 'X')) // DNG converters delete makernotes |
| { |
| if ((normalized_model[2] == 'F') && (normalized_model[3] == '1')) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Samsung_NX_M; |
| ilm.CameraFormat = LIBRAW_FORMAT_1INCH; |
| } |
| else |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Samsung_NX; |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| } |
| } |
| else |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Kodak)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| for (i = 0; i < int(sizeof Kodak_mounts / sizeof *Kodak_mounts); i++) |
| { |
| if (!strncmp(normalized_model, Kodak_mounts[i].Kmodel, |
| strlen(Kodak_mounts[i].Kmodel))) |
| { |
| ilm.CameraMount = Kodak_mounts[i].mount; |
| break; |
| } |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Minolta)) |
| { |
| if (!strcmp(normalized_model, "DG-5D") || |
| !strcmp(normalized_model, "DG-7D")) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| ilm.CameraMount = LIBRAW_MOUNT_Minolta_A; |
| } |
| else if (!strncasecmp(normalized_model, "DiMAGE", 6)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Casio) || |
| makeIs(LIBRAW_CAMERAMAKER_Creative)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Sigma)) |
| { |
| if (!strncmp(normalized_model, "fp", 2)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_FF; |
| ilm.CameraMount = LIBRAW_MOUNT_LPS_L; |
| } |
| else if (!strncasecmp(normalized_model, "SD", 2)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Sigma_X3F; |
| if (!strcmp(normalized_model, "SD1") || (normalized_model[4] == 'M')) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_SigmaMerrill; |
| } |
| else if (normalized_model[11] == 'H') |
| { // 'sd Quattro H' |
| ilm.CameraFormat = LIBRAW_FORMAT_SigmaAPSH; |
| } |
| else if (normalized_model[4] == 'Q') |
| { // 'sd Quattro' |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| } |
| else |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_SigmaAPSC; |
| } |
| } |
| else if (!strncasecmp(normalized_model, "DP", 2)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| if (normalized_model[4] == 'M') |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_SigmaMerrill; |
| } |
| else if (normalized_model[4] == 'Q') |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| } |
| else |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_SigmaAPSC; |
| } |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Konica)) |
| { |
| if (!strncmp(model, "KD-", 3)) |
| { // Konica KD-400Z, KD-510Z |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Mamiya)) |
| { |
| if (!strncmp(normalized_model, "ZD", 2)) |
| { |
| ilm.CameraFormat = LIBRAW_FORMAT_3648; |
| ilm.CameraMount = LIBRAW_MOUNT_Mamiya645; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Sony)) |
| { |
| if (!strncmp(normalized_model, "XCD-", 4)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_C; |
| } |
| else if (!strncmp(normalized_model, "DSC-V3", 6) || |
| !strncmp(normalized_model, "DSC-F828", 8)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| imSony.CameraType = LIBRAW_SONY_DSC; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Polaroid) && |
| !strncmp(normalized_model, "x530", 4)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Rollei) && |
| !strncmp(normalized_model, "d530flex", 8)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Pentax) && |
| !strncmp(normalized_model, "Optio", 5)) { |
| ilm.CameraMount = LIBRAW_MOUNT_FixedLens; |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Epson) && |
| !strncmp(normalized_model, "R-D1", 4)) |
| { |
| ilm.CameraMount = LIBRAW_MOUNT_Leica_M; |
| ilm.CameraFormat = LIBRAW_FORMAT_APSC; |
| } |
| } |
| |
| if ((ilm.LensMount == LIBRAW_MOUNT_Canon_RF) && |
| (ilm.LensID == 61182) && |
| (imCanon.RF_lensID != 0)) { |
| ilm.LensID = imCanon.RF_lensID; |
| } |
| |
| if (ilm.LensMount == LIBRAW_MOUNT_Unknown) |
| { |
| if (makeIs(LIBRAW_CAMERAMAKER_Samsung)) |
| { |
| if ((imgdata.lens.Lens[0] == 'N') && |
| (imgdata.lens.Lens[1] == 'X')) // same DNG problem |
| { |
| if (imgdata.lens.Lens[2] == '-') |
| { |
| ilm.LensMount = LIBRAW_MOUNT_Samsung_NX_M; |
| ilm.LensFormat = LIBRAW_FORMAT_1INCH; |
| } |
| else |
| { |
| ilm.LensMount = LIBRAW_MOUNT_Samsung_NX; |
| ilm.LensFormat = LIBRAW_FORMAT_APSC; |
| } |
| } |
| } |
| } |
| |
| if ((ilm.LensID == LIBRAW_LENS_NOT_SET) && |
| xmpdata && |
| (strlen(xmpdata) > 9)) |
| { |
| if (makeIs(LIBRAW_CAMERAMAKER_Canon) && |
| try_xml && |
| (ps = strstr(xmpdata, "LensID=\""))) |
| { |
| ilm.LensID = atoi(ps + 8); |
| if (ilm.LensID == 61182) |
| { |
| ilm.LensMount = ilm.CameraMount = LIBRAW_MOUNT_Canon_RF; |
| } |
| } |
| else if (makeIs(LIBRAW_CAMERAMAKER_Samsung)) |
| { |
| if ((ilm.LensMount == LIBRAW_MOUNT_Samsung_NX) && |
| (ps = strstr(xmpdata, "LensID=\"("))) |
| { |
| ilm.LensID = atoi(ps + 9); |
| } |
| } |
| } |
| |
| if (ilm.CameraMount == LIBRAW_MOUNT_FixedLens) |
| { |
| if (ilm.CameraFormat) |
| ilm.LensFormat = ilm.CameraFormat; |
| if (ilm.LensMount == LIBRAW_MOUNT_Unknown) |
| ilm.LensMount = LIBRAW_MOUNT_FixedLens; |
| } |
| |
| if ((ilm.CameraMount != LIBRAW_MOUNT_Unknown) && |
| (ilm.CameraMount != LIBRAW_MOUNT_FixedLens) && |
| (ilm.LensMount == LIBRAW_MOUNT_Unknown)) { |
| if (ilm.LensID == LIBRAW_LENS_NOT_SET) ilm.LensMount = LIBRAW_MOUNT_IL_UM; |
| else ilm.LensMount = ilm.CameraMount; |
| } |
| } |
| |
| void LibRaw::SetStandardIlluminants (unsigned makerIdx, const char* /*normModel*/) { |
| // int i = -1; |
| int c; |
| if (!icWBC[LIBRAW_WBI_Ill_A][0] && |
| !icWBC[LIBRAW_WBI_D65][0]) { |
| if (makerIdx == LIBRAW_CAMERAMAKER_Olympus ) { |
| for (int i = 0; i < 64 && icWBCCTC[i][0]; i++) { |
| if (icWBCCTC[i][0] == 3000) |
| FORC4 icWBC[LIBRAW_WBI_Ill_A][c] = int(icWBCCTC[i][c+1]); |
| else if (icWBCCTC[i][0] == 6600) |
| FORC4 icWBC[LIBRAW_WBI_D65][c] = int(icWBCCTC[i][c+1]); |
| } |
| } |
| } |
| |
| if (!icWBC[LIBRAW_WBI_Ill_A][0] && icWBC[LIBRAW_WBI_Tungsten][0]) |
| FORC4 icWBC[LIBRAW_WBI_Ill_A][c] = icWBC[LIBRAW_WBI_Tungsten][c]; |
| |
| if (!icWBC[LIBRAW_WBI_D65][0] && icWBC[LIBRAW_WBI_FL_N][0]) |
| FORC4 icWBC[LIBRAW_WBI_D65][c] = icWBC[LIBRAW_WBI_FL_N][c]; |
| |
| return; |
| } |
