sk_surface.cpp 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443
  1. /*
  2. * Copyright 2014 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. #include "include/core/SkCanvas.h"
  8. #include "include/core/SkData.h"
  9. #include "include/core/SkImage.h"
  10. #include "include/core/SkMaskFilter.h"
  11. #include "include/core/SkMatrix.h"
  12. #include "include/core/SkPaint.h"
  13. #include "include/core/SkPath.h"
  14. #include "include/core/SkPictureRecorder.h"
  15. #include "include/core/SkSurface.h"
  16. #include "include/c/sk_canvas.h"
  17. #include "include/c/sk_data.h"
  18. #include "include/c/sk_image.h"
  19. #include "include/c/sk_paint.h"
  20. #include "include/c/sk_path.h"
  21. #include "include/c/sk_picture.h"
  22. #include "include/c/sk_surface.h"
  23. #include "src/c/sk_types_priv.h"
  24. const struct {
  25. sk_pixelgeometry_t fC;
  26. SkPixelGeometry fSK;
  27. } gPixelGeometryMap[] = {
  28. { UNKNOWN_SK_PIXELGEOMETRY, kUnknown_SkPixelGeometry },
  29. { RGB_H_SK_PIXELGEOMETRY, kRGB_H_SkPixelGeometry },
  30. { BGR_H_SK_PIXELGEOMETRY, kBGR_H_SkPixelGeometry },
  31. { RGB_V_SK_PIXELGEOMETRY, kRGB_V_SkPixelGeometry },
  32. { BGR_V_SK_PIXELGEOMETRY, kBGR_V_SkPixelGeometry },
  33. };
  34. static bool from_c_pixelgeometry(sk_pixelgeometry_t cGeom, SkPixelGeometry* skGeom) {
  35. for (size_t i = 0; i < SK_ARRAY_COUNT(gPixelGeometryMap); ++i) {
  36. if (gPixelGeometryMap[i].fC == cGeom) {
  37. if (skGeom) {
  38. *skGeom = gPixelGeometryMap[i].fSK;
  39. }
  40. return true;
  41. }
  42. }
  43. return false;
  44. }
  45. static void from_c_matrix(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
  46. matrix->setAll(cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],
  47. cmatrix->mat[3], cmatrix->mat[4], cmatrix->mat[5],
  48. cmatrix->mat[6], cmatrix->mat[7], cmatrix->mat[8]);
  49. }
  50. const struct {
  51. sk_path_direction_t fC;
  52. SkPath::Direction fSk;
  53. } gPathDirMap[] = {
  54. { CW_SK_PATH_DIRECTION, SkPath::kCW_Direction },
  55. { CCW_SK_PATH_DIRECTION, SkPath::kCCW_Direction },
  56. };
  57. static bool from_c_path_direction(sk_path_direction_t cdir, SkPath::Direction* dir) {
  58. for (size_t i = 0; i < SK_ARRAY_COUNT(gPathDirMap); ++i) {
  59. if (gPathDirMap[i].fC == cdir) {
  60. if (dir) {
  61. *dir = gPathDirMap[i].fSk;
  62. }
  63. return true;
  64. }
  65. }
  66. return false;
  67. }
  68. static SkData* AsData(const sk_data_t* cdata) {
  69. return reinterpret_cast<SkData*>(const_cast<sk_data_t*>(cdata));
  70. }
  71. static sk_data_t* ToData(SkData* data) {
  72. return reinterpret_cast<sk_data_t*>(data);
  73. }
  74. static sk_rect_t ToRect(const SkRect& rect) {
  75. return reinterpret_cast<const sk_rect_t&>(rect);
  76. }
  77. static const SkRect& AsRect(const sk_rect_t& crect) {
  78. return reinterpret_cast<const SkRect&>(crect);
  79. }
  80. static const SkPath& AsPath(const sk_path_t& cpath) {
  81. return reinterpret_cast<const SkPath&>(cpath);
  82. }
  83. static SkPath* as_path(sk_path_t* cpath) {
  84. return reinterpret_cast<SkPath*>(cpath);
  85. }
  86. static const SkImage* AsImage(const sk_image_t* cimage) {
  87. return reinterpret_cast<const SkImage*>(cimage);
  88. }
  89. static sk_image_t* ToImage(SkImage* cimage) {
  90. return reinterpret_cast<sk_image_t*>(cimage);
  91. }
  92. static sk_canvas_t* ToCanvas(SkCanvas* canvas) {
  93. return reinterpret_cast<sk_canvas_t*>(canvas);
  94. }
  95. static SkCanvas* AsCanvas(sk_canvas_t* ccanvas) {
  96. return reinterpret_cast<SkCanvas*>(ccanvas);
  97. }
  98. static SkPictureRecorder* AsPictureRecorder(sk_picture_recorder_t* crec) {
  99. return reinterpret_cast<SkPictureRecorder*>(crec);
  100. }
  101. static sk_picture_recorder_t* ToPictureRecorder(SkPictureRecorder* rec) {
  102. return reinterpret_cast<sk_picture_recorder_t*>(rec);
  103. }
  104. static const SkPicture* AsPicture(const sk_picture_t* cpic) {
  105. return reinterpret_cast<const SkPicture*>(cpic);
  106. }
  107. static SkPicture* AsPicture(sk_picture_t* cpic) {
  108. return reinterpret_cast<SkPicture*>(cpic);
  109. }
  110. static sk_picture_t* ToPicture(SkPicture* pic) {
  111. return reinterpret_cast<sk_picture_t*>(pic);
  112. }
  113. ///////////////////////////////////////////////////////////////////////////////////////////
  114. sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t* cinfo, const void* pixels,
  115. size_t rowBytes) {
  116. const SkImageInfo* info = reinterpret_cast<const SkImageInfo*>(cinfo);
  117. return (sk_image_t*)SkImage::MakeRasterCopy(SkPixmap(*info, pixels, rowBytes)).release();
  118. }
  119. sk_image_t* sk_image_new_from_encoded(const sk_data_t* cdata, const sk_irect_t* subset) {
  120. return ToImage(SkImage::MakeFromEncoded(sk_ref_sp(AsData(cdata)),
  121. reinterpret_cast<const SkIRect*>(subset)).release());
  122. }
  123. sk_data_t* sk_image_encode(const sk_image_t* cimage) {
  124. return ToData(AsImage(cimage)->encodeToData().release());
  125. }
  126. void sk_image_ref(const sk_image_t* cimage) {
  127. AsImage(cimage)->ref();
  128. }
  129. void sk_image_unref(const sk_image_t* cimage) {
  130. AsImage(cimage)->unref();
  131. }
  132. int sk_image_get_width(const sk_image_t* cimage) {
  133. return AsImage(cimage)->width();
  134. }
  135. int sk_image_get_height(const sk_image_t* cimage) {
  136. return AsImage(cimage)->height();
  137. }
  138. uint32_t sk_image_get_unique_id(const sk_image_t* cimage) {
  139. return AsImage(cimage)->uniqueID();
  140. }
  141. ///////////////////////////////////////////////////////////////////////////////////////////
  142. sk_path_t* sk_path_new() { return (sk_path_t*)new SkPath; }
  143. void sk_path_delete(sk_path_t* cpath) { delete as_path(cpath); }
  144. void sk_path_move_to(sk_path_t* cpath, float x, float y) {
  145. as_path(cpath)->moveTo(x, y);
  146. }
  147. void sk_path_line_to(sk_path_t* cpath, float x, float y) {
  148. as_path(cpath)->lineTo(x, y);
  149. }
  150. void sk_path_quad_to(sk_path_t* cpath, float x0, float y0, float x1, float y1) {
  151. as_path(cpath)->quadTo(x0, y0, x1, y1);
  152. }
  153. void sk_path_conic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float w) {
  154. as_path(cpath)->conicTo(x0, y0, x1, y1, w);
  155. }
  156. void sk_path_cubic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float x2, float y2) {
  157. as_path(cpath)->cubicTo(x0, y0, x1, y1, x2, y2);
  158. }
  159. void sk_path_close(sk_path_t* cpath) {
  160. as_path(cpath)->close();
  161. }
  162. void sk_path_add_rect(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
  163. SkPath::Direction dir;
  164. if (!from_c_path_direction(cdir, &dir)) {
  165. return;
  166. }
  167. as_path(cpath)->addRect(AsRect(*crect), dir);
  168. }
  169. void sk_path_add_oval(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
  170. SkPath::Direction dir;
  171. if (!from_c_path_direction(cdir, &dir)) {
  172. return;
  173. }
  174. as_path(cpath)->addOval(AsRect(*crect), dir);
  175. }
  176. bool sk_path_get_bounds(const sk_path_t* cpath, sk_rect_t* crect) {
  177. const SkPath& path = AsPath(*cpath);
  178. if (path.isEmpty()) {
  179. if (crect) {
  180. *crect = ToRect(SkRect::MakeEmpty());
  181. }
  182. return false;
  183. }
  184. if (crect) {
  185. *crect = ToRect(path.getBounds());
  186. }
  187. return true;
  188. }
  189. ///////////////////////////////////////////////////////////////////////////////////////////
  190. void sk_canvas_save(sk_canvas_t* ccanvas) {
  191. AsCanvas(ccanvas)->save();
  192. }
  193. void sk_canvas_save_layer(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) {
  194. AsCanvas(ccanvas)->drawRect(AsRect(*crect), AsPaint(*cpaint));
  195. }
  196. void sk_canvas_restore(sk_canvas_t* ccanvas) {
  197. AsCanvas(ccanvas)->restore();
  198. }
  199. void sk_canvas_translate(sk_canvas_t* ccanvas, float dx, float dy) {
  200. AsCanvas(ccanvas)->translate(dx, dy);
  201. }
  202. void sk_canvas_scale(sk_canvas_t* ccanvas, float sx, float sy) {
  203. AsCanvas(ccanvas)->scale(sx, sy);
  204. }
  205. void sk_canvas_rotate_degress(sk_canvas_t* ccanvas, float degrees) {
  206. AsCanvas(ccanvas)->rotate(degrees);
  207. }
  208. void sk_canvas_rotate_radians(sk_canvas_t* ccanvas, float radians) {
  209. AsCanvas(ccanvas)->rotate(SkRadiansToDegrees(radians));
  210. }
  211. void sk_canvas_skew(sk_canvas_t* ccanvas, float sx, float sy) {
  212. AsCanvas(ccanvas)->skew(sx, sy);
  213. }
  214. void sk_canvas_concat(sk_canvas_t* ccanvas, const sk_matrix_t* cmatrix) {
  215. SkASSERT(cmatrix);
  216. SkMatrix matrix;
  217. from_c_matrix(cmatrix, &matrix);
  218. AsCanvas(ccanvas)->concat(matrix);
  219. }
  220. void sk_canvas_clip_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect) {
  221. AsCanvas(ccanvas)->clipRect(AsRect(*crect));
  222. }
  223. void sk_canvas_clip_path(sk_canvas_t* ccanvas, const sk_path_t* cpath) {
  224. AsCanvas(ccanvas)->clipPath(AsPath(*cpath));
  225. }
  226. void sk_canvas_draw_paint(sk_canvas_t* ccanvas, const sk_paint_t* cpaint) {
  227. AsCanvas(ccanvas)->drawPaint(AsPaint(*cpaint));
  228. }
  229. void sk_canvas_draw_rect(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) {
  230. AsCanvas(ccanvas)->drawRect(AsRect(*crect), AsPaint(*cpaint));
  231. }
  232. void sk_canvas_draw_circle(sk_canvas_t* ccanvas, float cx, float cy, float rad,
  233. const sk_paint_t* cpaint) {
  234. AsCanvas(ccanvas)->drawCircle(cx, cy, rad, AsPaint(*cpaint));
  235. }
  236. void sk_canvas_draw_oval(sk_canvas_t* ccanvas, const sk_rect_t* crect, const sk_paint_t* cpaint) {
  237. AsCanvas(ccanvas)->drawOval(AsRect(*crect), AsPaint(*cpaint));
  238. }
  239. void sk_canvas_draw_path(sk_canvas_t* ccanvas, const sk_path_t* cpath, const sk_paint_t* cpaint) {
  240. AsCanvas(ccanvas)->drawPath(AsPath(*cpath), AsPaint(*cpaint));
  241. }
  242. void sk_canvas_draw_image(sk_canvas_t* ccanvas, const sk_image_t* cimage, float x, float y,
  243. const sk_paint_t* cpaint) {
  244. AsCanvas(ccanvas)->drawImage(AsImage(cimage), x, y, AsPaint(cpaint));
  245. }
  246. void sk_canvas_draw_image_rect(sk_canvas_t* ccanvas, const sk_image_t* cimage,
  247. const sk_rect_t* csrcR, const sk_rect_t* cdstR,
  248. const sk_paint_t* cpaint) {
  249. SkCanvas* canvas = AsCanvas(ccanvas);
  250. const SkImage* image = AsImage(cimage);
  251. const SkRect& dst = AsRect(*cdstR);
  252. const SkPaint* paint = AsPaint(cpaint);
  253. if (csrcR) {
  254. canvas->drawImageRect(image, AsRect(*csrcR), dst, paint);
  255. } else {
  256. canvas->drawImageRect(image, dst, paint);
  257. }
  258. }
  259. void sk_canvas_draw_picture(sk_canvas_t* ccanvas, const sk_picture_t* cpicture,
  260. const sk_matrix_t* cmatrix, const sk_paint_t* cpaint) {
  261. const SkMatrix* matrixPtr = NULL;
  262. SkMatrix matrix;
  263. if (cmatrix) {
  264. from_c_matrix(cmatrix, &matrix);
  265. matrixPtr = &matrix;
  266. }
  267. AsCanvas(ccanvas)->drawPicture(AsPicture(cpicture), matrixPtr, AsPaint(cpaint));
  268. }
  269. ///////////////////////////////////////////////////////////////////////////////////////////
  270. sk_surface_t* sk_surface_new_raster(const sk_imageinfo_t* cinfo,
  271. const sk_surfaceprops_t* props) {
  272. const SkImageInfo* info = reinterpret_cast<const SkImageInfo*>(cinfo);
  273. SkPixelGeometry geo = kUnknown_SkPixelGeometry;
  274. if (props && !from_c_pixelgeometry(props->pixelGeometry, &geo)) {
  275. return NULL;
  276. }
  277. SkSurfaceProps surfProps(0, geo);
  278. return (sk_surface_t*)SkSurface::MakeRaster(*info, &surfProps).release();
  279. }
  280. sk_surface_t* sk_surface_new_raster_direct(const sk_imageinfo_t* cinfo, void* pixels,
  281. size_t rowBytes,
  282. const sk_surfaceprops_t* props) {
  283. const SkImageInfo* info = reinterpret_cast<const SkImageInfo*>(cinfo);
  284. SkPixelGeometry geo = kUnknown_SkPixelGeometry;
  285. if (props && !from_c_pixelgeometry(props->pixelGeometry, &geo)) {
  286. return NULL;
  287. }
  288. SkSurfaceProps surfProps(0, geo);
  289. return (sk_surface_t*)SkSurface::MakeRasterDirect(*info, pixels, rowBytes, &surfProps).release();
  290. }
  291. void sk_surface_unref(sk_surface_t* csurf) {
  292. SkSafeUnref((SkSurface*)csurf);
  293. }
  294. sk_canvas_t* sk_surface_get_canvas(sk_surface_t* csurf) {
  295. SkSurface* surf = (SkSurface*)csurf;
  296. return (sk_canvas_t*)surf->getCanvas();
  297. }
  298. sk_image_t* sk_surface_new_image_snapshot(sk_surface_t* csurf) {
  299. SkSurface* surf = (SkSurface*)csurf;
  300. return (sk_image_t*)surf->makeImageSnapshot().release();
  301. }
  302. ///////////////////////////////////////////////////////////////////////////////////////////
  303. sk_picture_recorder_t* sk_picture_recorder_new() {
  304. return ToPictureRecorder(new SkPictureRecorder);
  305. }
  306. void sk_picture_recorder_delete(sk_picture_recorder_t* crec) {
  307. delete AsPictureRecorder(crec);
  308. }
  309. sk_canvas_t* sk_picture_recorder_begin_recording(sk_picture_recorder_t* crec,
  310. const sk_rect_t* cbounds) {
  311. return ToCanvas(AsPictureRecorder(crec)->beginRecording(AsRect(*cbounds)));
  312. }
  313. sk_picture_t* sk_picture_recorder_end_recording(sk_picture_recorder_t* crec) {
  314. return ToPicture(AsPictureRecorder(crec)->finishRecordingAsPicture().release());
  315. }
  316. void sk_picture_ref(sk_picture_t* cpic) {
  317. SkSafeRef(AsPicture(cpic));
  318. }
  319. void sk_picture_unref(sk_picture_t* cpic) {
  320. SkSafeUnref(AsPicture(cpic));
  321. }
  322. uint32_t sk_picture_get_unique_id(sk_picture_t* cpic) {
  323. return AsPicture(cpic)->uniqueID();
  324. }
  325. sk_rect_t sk_picture_get_bounds(sk_picture_t* cpic) {
  326. return ToRect(AsPicture(cpic)->cullRect());
  327. }
  328. ///////////////////////////////////////////////////////////////////////////////////////////
  329. sk_data_t* sk_data_new_with_copy(const void* src, size_t length) {
  330. return ToData(SkData::MakeWithCopy(src, length).release());
  331. }
  332. sk_data_t* sk_data_new_from_malloc(const void* memory, size_t length) {
  333. return ToData(SkData::MakeFromMalloc(memory, length).release());
  334. }
  335. sk_data_t* sk_data_new_subset(const sk_data_t* csrc, size_t offset, size_t length) {
  336. return ToData(SkData::MakeSubset(AsData(csrc), offset, length).release());
  337. }
  338. void sk_data_ref(const sk_data_t* cdata) {
  339. SkSafeRef(AsData(cdata));
  340. }
  341. void sk_data_unref(const sk_data_t* cdata) {
  342. SkSafeUnref(AsData(cdata));
  343. }
  344. size_t sk_data_get_size(const sk_data_t* cdata) {
  345. return AsData(cdata)->size();
  346. }
  347. const void* sk_data_get_data(const sk_data_t* cdata) {
  348. return AsData(cdata)->data();
  349. }
  350. ///////////////////////////////////////////////////////////////////////////////////////////