Home | History | Annotate | Download | only in c 
      1 /*
      2  * Copyright 2018 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkImageInfo.h"
      9 #include "SkColorSpace.h"
     10 
     11 #include "sk_imageinfo.h"
     12 #include "sk_colorspace.h"
     13 
     14 const struct {
     15     sk_colortype_t  fC;
     16     SkColorType     fSK;
     17 } gColorTypeMap[] = {
     18     { UNKNOWN_SK_COLORTYPE,     kUnknown_SkColorType    },
     19     { RGBA_8888_SK_COLORTYPE,   kRGBA_8888_SkColorType  },
     20     { BGRA_8888_SK_COLORTYPE,   kBGRA_8888_SkColorType  },
     21     { ALPHA_8_SK_COLORTYPE,     kAlpha_8_SkColorType    },
     22     { GRAY_8_SK_COLORTYPE,      kGray_8_SkColorType     },
     23     { RGBA_F16_SK_COLORTYPE,    kRGBA_F16_SkColorType   },
     24     { RGBA_F32_SK_COLORTYPE,    kRGBA_F32_SkColorType   },
     25 };
     26 
     27 const struct {
     28     sk_alphatype_t  fC;
     29     SkAlphaType     fSK;
     30 } gAlphaTypeMap[] = {
     31     { OPAQUE_SK_ALPHATYPE,      kOpaque_SkAlphaType     },
     32     { PREMUL_SK_ALPHATYPE,      kPremul_SkAlphaType     },
     33     { UNPREMUL_SK_ALPHATYPE,    kUnpremul_SkAlphaType   },
     34 };
     35 
     36 static bool from_c_colortype(sk_colortype_t cCT, SkColorType* skCT) {
     37     for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypeMap); ++i) {
     38         if (gColorTypeMap[i].fC == cCT) {
     39             if (skCT) {
     40                 *skCT = gColorTypeMap[i].fSK;
     41             }
     42             return true;
     43         }
     44     }
     45     return false;
     46 }
     47 
     48 static bool to_c_colortype(SkColorType skCT, sk_colortype_t* cCT) {
     49     for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypeMap); ++i) {
     50         if (gColorTypeMap[i].fSK == skCT) {
     51             if (cCT) {
     52                 *cCT = gColorTypeMap[i].fC;
     53             }
     54             return true;
     55         }
     56     }
     57     return false;
     58 }
     59 
     60 static bool from_c_alphatype(sk_alphatype_t cAT, SkAlphaType* skAT) {
     61     for (size_t i = 0; i < SK_ARRAY_COUNT(gAlphaTypeMap); ++i) {
     62         if (gAlphaTypeMap[i].fC == cAT) {
     63             if (skAT) {
     64                 *skAT = gAlphaTypeMap[i].fSK;
     65             }
     66             return true;
     67         }
     68     }
     69     return false;
     70 }
     71 
     72 static bool to_c_alphatype(SkAlphaType skAT, sk_alphatype_t* cAT) {
     73     for (size_t i = 0; i < SK_ARRAY_COUNT(gAlphaTypeMap); ++i) {
     74         if (gAlphaTypeMap[i].fSK == skAT) {
     75             if (cAT) {
     76                 *cAT = gAlphaTypeMap[i].fC;
     77             }
     78             return true;
     79         }
     80     }
     81     return false;
     82 }
     83 
     84 const SkImageInfo* ToImageInfo(const sk_imageinfo_t* cinfo) {
     85     return reinterpret_cast<const SkImageInfo*>(cinfo);
     86 }
     87 
     88 /////////////////////////////////////////////////////////////////////////////////////////////
     89 
     90 sk_imageinfo_t* sk_imageinfo_new(int w, int h, sk_colortype_t cct, sk_alphatype_t cat,
     91                                  sk_colorspace_t* ccs) {
     92     SkColorType ct;
     93     SkAlphaType at;
     94     if (!from_c_colortype(cct, &ct) || !from_c_alphatype(cat, &at)) {
     95         return nullptr;
     96     }
     97     SkColorSpace* cs = (SkColorSpace*)ccs;
     98 
     99     SkImageInfo* info = new SkImageInfo(SkImageInfo::Make(w, h, ct, at, sk_ref_sp(cs)));
    100     return reinterpret_cast<sk_imageinfo_t*>(info);
    101 }
    102 
    103 void sk_imageinfo_delete(sk_imageinfo_t* cinfo) {
    104     delete ToImageInfo(cinfo);
    105 }
    106 
    107 int sk_imageinfo_get_width(const sk_imageinfo_t* cinfo) {
    108     return ToImageInfo(cinfo)->width();
    109 }
    110 
    111 int sk_imageinfo_get_height(const sk_imageinfo_t* cinfo) {
    112     return ToImageInfo(cinfo)->height();
    113 }
    114 
    115 sk_colortype_t sk_imageinfo_get_colortype(const sk_imageinfo_t* cinfo) {
    116     sk_colortype_t ct;
    117     return to_c_colortype(ToImageInfo(cinfo)->colorType(), &ct) ? ct : UNKNOWN_SK_COLORTYPE;
    118 }
    119 
    120 sk_alphatype_t sk_imageinfo_get_alphatype(const sk_imageinfo_t* cinfo) {
    121     sk_alphatype_t at;
    122     // odd that we return premul on failure...
    123     return to_c_alphatype(ToImageInfo(cinfo)->alphaType(), &at) ? at : PREMUL_SK_ALPHATYPE;
    124 }
    125 
    126 sk_colorspace_t* sk_imageinfo_get_colorspace(const sk_imageinfo_t* cinfo) {
    127     return reinterpret_cast<sk_colorspace_t*>(ToImageInfo(cinfo)->colorSpace());
    128 }
    129 
    130 /////////////////////////////////////////////////////////////////////////////////////////////
    131 
    132 sk_colorspace_t* sk_colorspace_new_srgb() {
    133     return reinterpret_cast<sk_colorspace_t*>(SkColorSpace::MakeSRGB().release());
    134 }
    135 
    136 void sk_colorspace_ref(sk_colorspace_t* cs) {
    137     SkSafeRef(reinterpret_cast<SkColorSpace*>(cs));
    138 }
    139 
    140 void sk_colorspace_unref(sk_colorspace_t* cs) {
    141     SkSafeUnref(reinterpret_cast<SkColorSpace*>(cs));
    142 }
    143 
    144