process.go 23 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067
  1. package main
  2. /*
  3. #cgo pkg-config: vips
  4. #cgo LDFLAGS: -s -w
  5. #include "vips.h"
  6. */
  7. import "C"
  8. import (
  9. "context"
  10. "errors"
  11. "log"
  12. "math"
  13. "os"
  14. "runtime"
  15. "unsafe"
  16. "golang.org/x/sync/errgroup"
  17. )
  18. var (
  19. vipsSupportSmartcrop bool
  20. vipsTypeSupportLoad = make(map[imageType]bool)
  21. vipsTypeSupportSave = make(map[imageType]bool)
  22. watermark *C.struct__VipsImage
  23. errSmartCropNotSupported = errors.New("Smart crop is not supported by used version of libvips")
  24. )
  25. type cConfig struct {
  26. JpegProgressive C.int
  27. PngInterlaced C.int
  28. WatermarkOpacity C.double
  29. }
  30. var cConf cConfig
  31. func initVips() {
  32. runtime.LockOSThread()
  33. defer runtime.UnlockOSThread()
  34. if err := C.vips_initialize(); err != 0 {
  35. C.vips_shutdown()
  36. log.Fatalln("unable to start vips!")
  37. }
  38. // Disable libvips cache. Since processing pipeline is fine tuned, we won't get much profit from it.
  39. // Enabled cache can cause SIGSEGV on Musl-based systems like Alpine.
  40. C.vips_cache_set_max_mem(0)
  41. C.vips_cache_set_max(0)
  42. if len(os.Getenv("IMGPROXY_VIPS_LEAK_CHECK")) > 0 {
  43. C.vips_leak_set(C.gboolean(1))
  44. }
  45. if len(os.Getenv("IMGPROXY_VIPS_CACHE_TRACE")) > 0 {
  46. C.vips_cache_set_trace(C.gboolean(1))
  47. }
  48. vipsSupportSmartcrop = C.vips_support_smartcrop() == 1
  49. if int(C.vips_type_find_load_go(C.int(imageTypeJPEG))) != 0 {
  50. vipsTypeSupportLoad[imageTypeJPEG] = true
  51. }
  52. if int(C.vips_type_find_load_go(C.int(imageTypePNG))) != 0 {
  53. vipsTypeSupportLoad[imageTypePNG] = true
  54. }
  55. if int(C.vips_type_find_load_go(C.int(imageTypeWEBP))) != 0 {
  56. vipsTypeSupportLoad[imageTypeWEBP] = true
  57. }
  58. if int(C.vips_type_find_load_go(C.int(imageTypeGIF))) != 0 {
  59. vipsTypeSupportLoad[imageTypeGIF] = true
  60. }
  61. if int(C.vips_type_find_load_go(C.int(imageTypeSVG))) != 0 {
  62. vipsTypeSupportLoad[imageTypeSVG] = true
  63. }
  64. // we load ICO with github.com/mat/besticon/ico and send decoded data to vips
  65. vipsTypeSupportLoad[imageTypeICO] = true
  66. if int(C.vips_type_find_save_go(C.int(imageTypeJPEG))) != 0 {
  67. vipsTypeSupportSave[imageTypeJPEG] = true
  68. }
  69. if int(C.vips_type_find_save_go(C.int(imageTypePNG))) != 0 {
  70. vipsTypeSupportSave[imageTypePNG] = true
  71. }
  72. if int(C.vips_type_find_save_go(C.int(imageTypeWEBP))) != 0 {
  73. vipsTypeSupportSave[imageTypeWEBP] = true
  74. }
  75. if int(C.vips_type_find_save_go(C.int(imageTypeGIF))) != 0 {
  76. vipsTypeSupportSave[imageTypeGIF] = true
  77. }
  78. if int(C.vips_type_find_save_go(C.int(imageTypeICO))) != 0 {
  79. vipsTypeSupportSave[imageTypeICO] = true
  80. }
  81. if conf.JpegProgressive {
  82. cConf.JpegProgressive = C.int(1)
  83. }
  84. if conf.PngInterlaced {
  85. cConf.PngInterlaced = C.int(1)
  86. }
  87. cConf.WatermarkOpacity = C.double(conf.WatermarkOpacity)
  88. if err := vipsPrepareWatermark(); err != nil {
  89. log.Fatal(err)
  90. }
  91. }
  92. func shutdownVips() {
  93. C.clear_image(&watermark)
  94. C.vips_shutdown()
  95. }
  96. func extractMeta(img *C.VipsImage) (int, int, int, bool) {
  97. width := int(img.Xsize)
  98. height := int(img.Ysize)
  99. angle := C.VIPS_ANGLE_D0
  100. flip := false
  101. orientation := C.vips_get_exif_orientation(img)
  102. if orientation >= 5 && orientation <= 8 {
  103. width, height = height, width
  104. }
  105. if orientation == 3 || orientation == 4 {
  106. angle = C.VIPS_ANGLE_D180
  107. }
  108. if orientation == 5 || orientation == 6 {
  109. angle = C.VIPS_ANGLE_D90
  110. }
  111. if orientation == 7 || orientation == 8 {
  112. angle = C.VIPS_ANGLE_D270
  113. }
  114. if orientation == 2 || orientation == 4 || orientation == 5 || orientation == 7 {
  115. flip = true
  116. }
  117. return width, height, angle, flip
  118. }
  119. func calcScale(width, height int, po *processingOptions, imgtype imageType) float64 {
  120. // If we're going only to crop, we need only to scale down to DPR.
  121. // Scaling up while cropping is not optimal on this stage, we'll do it later if needed.
  122. if po.Resize == resizeCrop {
  123. if po.Dpr < 1 {
  124. return po.Dpr
  125. }
  126. return 1
  127. }
  128. var scale float64
  129. srcW, srcH := float64(width), float64(height)
  130. if (po.Width == 0 || po.Width == width) && (po.Height == 0 || po.Height == height) {
  131. scale = 1
  132. } else {
  133. wr := float64(po.Width) / srcW
  134. hr := float64(po.Height) / srcH
  135. if po.Width == 0 {
  136. scale = hr
  137. } else if po.Height == 0 {
  138. scale = wr
  139. } else if po.Resize == resizeFit {
  140. scale = math.Min(wr, hr)
  141. } else {
  142. scale = math.Max(wr, hr)
  143. }
  144. }
  145. scale = scale * po.Dpr
  146. if !po.Enlarge && scale > 1 && imgtype != imageTypeSVG {
  147. return 1
  148. }
  149. if srcW*scale < 1 {
  150. scale = 1 / srcW
  151. }
  152. if srcH*scale < 1 {
  153. scale = 1 / srcH
  154. }
  155. return scale
  156. }
  157. func calcShink(scale float64, imgtype imageType) int {
  158. switch imgtype {
  159. case imageTypeWEBP:
  160. return int(1.0 / scale)
  161. case imageTypeJPEG:
  162. shrink := int(1.0 / scale)
  163. switch {
  164. case shrink >= 16:
  165. return 8
  166. case shrink >= 8:
  167. return 4
  168. case shrink >= 4:
  169. return 2
  170. }
  171. }
  172. return 1
  173. }
  174. func calcCrop(width, height, cropWidth, cropHeight int, gravity *gravityOptions) (left, top int) {
  175. if gravity.Type == gravityFocusPoint {
  176. pointX := int(float64(width) * gravity.X)
  177. pointY := int(float64(height) * gravity.Y)
  178. left = maxInt(0, minInt(pointX-cropWidth/2, width-cropWidth))
  179. top = maxInt(0, minInt(pointY-cropHeight/2, height-cropHeight))
  180. return
  181. }
  182. left = (width - cropWidth + 1) / 2
  183. top = (height - cropHeight + 1) / 2
  184. if gravity.Type == gravityNorth || gravity.Type == gravityNorthEast || gravity.Type == gravityNorthWest {
  185. top = 0
  186. }
  187. if gravity.Type == gravityEast || gravity.Type == gravityNorthEast || gravity.Type == gravitySouthEast {
  188. left = width - cropWidth
  189. }
  190. if gravity.Type == gravitySouth || gravity.Type == gravitySouthEast || gravity.Type == gravitySouthWest {
  191. top = height - cropHeight
  192. }
  193. if gravity.Type == gravityWest || gravity.Type == gravityNorthWest || gravity.Type == gravitySouthWest {
  194. left = 0
  195. }
  196. return
  197. }
  198. func resizeImage(img **C.struct__VipsImage, scale float64, hasAlpha bool) error {
  199. var err error
  200. premultiplied := false
  201. var bandFormat C.VipsBandFormat
  202. if hasAlpha {
  203. if bandFormat, err = vipsPremultiply(img); err != nil {
  204. return err
  205. }
  206. premultiplied = true
  207. }
  208. if err = vipsResize(img, scale); err != nil {
  209. return err
  210. }
  211. if premultiplied {
  212. if err = vipsUnpremultiply(img, bandFormat); err != nil {
  213. return err
  214. }
  215. }
  216. return nil
  217. }
  218. func transformImage(ctx context.Context, img **C.struct__VipsImage, data []byte, po *processingOptions, imgtype imageType) error {
  219. var err error
  220. imgWidth, imgHeight, angle, flip := extractMeta(*img)
  221. hasAlpha := vipsImageHasAlpha(*img)
  222. if scale := calcScale(imgWidth, imgHeight, po, imgtype); scale != 1 {
  223. if imgtype == imageTypeSVG && data != nil {
  224. // Load SVG with desired scale
  225. if tmp, err := vipsLoadImage(data, imgtype, 1, scale, false); err == nil {
  226. C.swap_and_clear(img, tmp)
  227. } else {
  228. return err
  229. }
  230. } else {
  231. // Do some shrink-on-load
  232. if scale < 1.0 && data != nil {
  233. if shrink := calcShink(scale, imgtype); shrink != 1 {
  234. scale = scale * float64(shrink)
  235. if tmp, err := vipsLoadImage(data, imgtype, shrink, 1.0, false); err == nil {
  236. C.swap_and_clear(img, tmp)
  237. } else {
  238. return err
  239. }
  240. }
  241. }
  242. if err = resizeImage(img, scale, hasAlpha); err != nil {
  243. return err
  244. }
  245. }
  246. // Update actual image size after resize
  247. imgWidth, imgHeight, _, _ = extractMeta(*img)
  248. }
  249. if err = vipsImportColourProfile(img); err != nil {
  250. return err
  251. }
  252. checkTimeout(ctx)
  253. if angle != C.VIPS_ANGLE_D0 || flip {
  254. if err = vipsImageCopyMemory(img); err != nil {
  255. return err
  256. }
  257. if angle != C.VIPS_ANGLE_D0 {
  258. if err = vipsRotate(img, angle); err != nil {
  259. return err
  260. }
  261. }
  262. if flip {
  263. if err = vipsFlip(img); err != nil {
  264. return err
  265. }
  266. }
  267. }
  268. checkTimeout(ctx)
  269. cropW, cropH := po.Width, po.Height
  270. if po.Dpr < 1 || (po.Dpr > 1 && po.Resize != resizeCrop) {
  271. cropW = int(float64(cropW) * po.Dpr)
  272. cropH = int(float64(cropH) * po.Dpr)
  273. }
  274. if cropW == 0 {
  275. cropW = imgWidth
  276. } else {
  277. cropW = minInt(cropW, imgWidth)
  278. }
  279. if cropH == 0 {
  280. cropH = imgHeight
  281. } else {
  282. cropH = minInt(cropH, imgHeight)
  283. }
  284. if cropW < imgWidth || cropH < imgHeight {
  285. if po.Gravity.Type == gravitySmart {
  286. if err = vipsImageCopyMemory(img); err != nil {
  287. return err
  288. }
  289. if err = vipsSmartCrop(img, cropW, cropH); err != nil {
  290. return err
  291. }
  292. // Applying additional modifications after smart crop causes SIGSEGV on Alpine
  293. // so we have to copy memory after it
  294. if err = vipsImageCopyMemory(img); err != nil {
  295. return err
  296. }
  297. } else {
  298. left, top := calcCrop(imgWidth, imgHeight, cropW, cropH, &po.Gravity)
  299. if err = vipsCrop(img, left, top, cropW, cropH); err != nil {
  300. return err
  301. }
  302. }
  303. checkTimeout(ctx)
  304. }
  305. if po.Enlarge && po.Resize == resizeCrop && po.Dpr > 1 {
  306. // We didn't enlarge the image before, because is wasn't optimal. Now it's time to do it
  307. if err = resizeImage(img, po.Dpr, hasAlpha); err != nil {
  308. return err
  309. }
  310. if err = vipsImageCopyMemory(img); err != nil {
  311. return err
  312. }
  313. }
  314. if hasAlpha && (po.Flatten || po.Format == imageTypeJPEG) {
  315. if err = vipsFlatten(img, po.Background); err != nil {
  316. return err
  317. }
  318. }
  319. if po.Blur > 0 {
  320. if err = vipsBlur(img, po.Blur); err != nil {
  321. return err
  322. }
  323. }
  324. if po.Sharpen > 0 {
  325. if err = vipsSharpen(img, po.Sharpen); err != nil {
  326. return err
  327. }
  328. }
  329. checkTimeout(ctx)
  330. if po.Watermark.Enabled {
  331. if err = vipsApplyWatermark(img, &po.Watermark); err != nil {
  332. return err
  333. }
  334. }
  335. if err = vipsFixColourspace(img); err != nil {
  336. return err
  337. }
  338. return nil
  339. }
  340. func transformGif(ctx context.Context, img **C.struct__VipsImage, po *processingOptions) error {
  341. imgWidth := int((*img).Xsize)
  342. imgHeight := int((*img).Ysize)
  343. // Double check dimensions because gif may have many frames
  344. if err := checkDimensions(imgWidth, imgHeight); err != nil {
  345. return err
  346. }
  347. frameHeight, err := vipsGetInt(*img, "page-height")
  348. if err != nil {
  349. return err
  350. }
  351. delay, err := vipsGetInt(*img, "gif-delay")
  352. if err != nil {
  353. return err
  354. }
  355. loop, err := vipsGetInt(*img, "gif-loop")
  356. if err != nil {
  357. return err
  358. }
  359. framesCount := minInt(imgHeight/frameHeight, conf.MaxGifFrames)
  360. frames := make([]*C.struct__VipsImage, framesCount)
  361. defer func() {
  362. for _, frame := range frames {
  363. C.clear_image(&frame)
  364. }
  365. }()
  366. var errg errgroup.Group
  367. for i := 0; i < framesCount; i++ {
  368. ind := i
  369. errg.Go(func() error {
  370. var frame *C.struct__VipsImage
  371. if err := vipsExtract(*img, &frame, 0, ind*frameHeight, imgWidth, frameHeight); err != nil {
  372. return err
  373. }
  374. if err := transformImage(ctx, &frame, nil, po, imageTypeGIF); err != nil {
  375. return err
  376. }
  377. frames[ind] = frame
  378. return nil
  379. })
  380. }
  381. if err := errg.Wait(); err != nil {
  382. return err
  383. }
  384. checkTimeout(ctx)
  385. if err := vipsArrayjoin(frames, img); err != nil {
  386. return err
  387. }
  388. vipsSetInt(*img, "page-height", int(frames[0].Ysize))
  389. vipsSetInt(*img, "gif-delay", delay)
  390. vipsSetInt(*img, "gif-loop", loop)
  391. return nil
  392. }
  393. func processImage(ctx context.Context) ([]byte, error) {
  394. if newRelicEnabled {
  395. newRelicCancel := startNewRelicSegment(ctx, "Processing image")
  396. defer newRelicCancel()
  397. }
  398. if prometheusEnabled {
  399. defer startPrometheusDuration(prometheusProcessingDuration)()
  400. }
  401. defer C.vips_cleanup()
  402. po := getProcessingOptions(ctx)
  403. data := getImageData(ctx).Bytes()
  404. imgtype := getImageType(ctx)
  405. if po.Gravity.Type == gravitySmart && !vipsSupportSmartcrop {
  406. return nil, errSmartCropNotSupported
  407. }
  408. if po.Format == imageTypeUnknown {
  409. if vipsTypeSupportSave[imgtype] {
  410. po.Format = imgtype
  411. } else {
  412. po.Format = imageTypeJPEG
  413. }
  414. }
  415. img, err := vipsLoadImage(data, imgtype, 1, 1.0, po.Format == imageTypeGIF)
  416. if err != nil {
  417. return nil, err
  418. }
  419. defer C.clear_image(&img)
  420. if imgtype == imageTypeGIF && po.Format == imageTypeGIF {
  421. if err := transformGif(ctx, &img, po); err != nil {
  422. return nil, err
  423. }
  424. } else {
  425. if err := transformImage(ctx, &img, data, po, imgtype); err != nil {
  426. return nil, err
  427. }
  428. }
  429. checkTimeout(ctx)
  430. if po.Format == imageTypeGIF {
  431. if err := vipsCastUchar(&img); err != nil {
  432. return nil, err
  433. }
  434. checkTimeout(ctx)
  435. }
  436. return vipsSaveImage(img, po.Format, po.Quality)
  437. }
  438. func vipsPrepareWatermark() error {
  439. data, imgtype, cancel, err := watermarkData()
  440. defer cancel()
  441. if err != nil {
  442. return err
  443. }
  444. if data == nil {
  445. return nil
  446. }
  447. watermark, err = vipsLoadImage(data, imgtype, 1, 1.0, false)
  448. if err != nil {
  449. return err
  450. }
  451. var tmp *C.struct__VipsImage
  452. if cConf.WatermarkOpacity < 1 {
  453. if vipsImageHasAlpha(watermark) {
  454. var alpha *C.struct__VipsImage
  455. defer C.clear_image(&alpha)
  456. if C.vips_extract_band_go(watermark, &tmp, (*watermark).Bands-1, 1) != 0 {
  457. return vipsError()
  458. }
  459. C.swap_and_clear(&alpha, tmp)
  460. if C.vips_extract_band_go(watermark, &tmp, 0, (*watermark).Bands-1) != 0 {
  461. return vipsError()
  462. }
  463. C.swap_and_clear(&watermark, tmp)
  464. if C.vips_linear_go(alpha, &tmp, cConf.WatermarkOpacity, 0) != 0 {
  465. return vipsError()
  466. }
  467. C.swap_and_clear(&alpha, tmp)
  468. if C.vips_bandjoin_go(watermark, alpha, &tmp) != 0 {
  469. return vipsError()
  470. }
  471. C.swap_and_clear(&watermark, tmp)
  472. } else {
  473. if C.vips_bandjoin_const_go(watermark, &tmp, cConf.WatermarkOpacity*255) != 0 {
  474. return vipsError()
  475. }
  476. C.swap_and_clear(&watermark, tmp)
  477. }
  478. }
  479. if tmp = C.vips_image_copy_memory(watermark); tmp == nil {
  480. return vipsError()
  481. }
  482. C.swap_and_clear(&watermark, tmp)
  483. return nil
  484. }
  485. func vipsLoadImage(data []byte, imgtype imageType, shrink int, svgScale float64, allPages bool) (*C.struct__VipsImage, error) {
  486. var img *C.struct__VipsImage
  487. err := C.int(0)
  488. pages := C.int(1)
  489. if allPages {
  490. pages = -1
  491. }
  492. switch imgtype {
  493. case imageTypeJPEG:
  494. err = C.vips_jpegload_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), C.int(shrink), &img)
  495. case imageTypePNG:
  496. err = C.vips_pngload_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), &img)
  497. case imageTypeWEBP:
  498. err = C.vips_webpload_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), C.int(shrink), &img)
  499. case imageTypeGIF:
  500. err = C.vips_gifload_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), pages, &img)
  501. case imageTypeSVG:
  502. err = C.vips_svgload_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), C.double(svgScale), &img)
  503. case imageTypeICO:
  504. rawData, width, height, icoErr := icoData(data)
  505. if icoErr != nil {
  506. return nil, icoErr
  507. }
  508. img = C.vips_image_new_from_memory_copy(unsafe.Pointer(&rawData[0]), C.size_t(width*height*4), C.int(width), C.int(height), 4, C.VIPS_FORMAT_UCHAR)
  509. }
  510. if err != 0 {
  511. return nil, vipsError()
  512. }
  513. return img, nil
  514. }
  515. func vipsSaveImage(img *C.struct__VipsImage, imgtype imageType, quality int) ([]byte, error) {
  516. var ptr unsafe.Pointer
  517. defer C.g_free_go(&ptr)
  518. err := C.int(0)
  519. imgsize := C.size_t(0)
  520. switch imgtype {
  521. case imageTypeJPEG:
  522. err = C.vips_jpegsave_go(img, &ptr, &imgsize, 1, C.int(quality), cConf.JpegProgressive)
  523. case imageTypePNG:
  524. if err = C.vips_pngsave_go(img, &ptr, &imgsize, cConf.PngInterlaced, 1); err != 0 {
  525. warning("Failed to save PNG; Trying not to embed icc profile")
  526. err = C.vips_pngsave_go(img, &ptr, &imgsize, cConf.PngInterlaced, 0)
  527. }
  528. case imageTypeWEBP:
  529. err = C.vips_webpsave_go(img, &ptr, &imgsize, 1, C.int(quality))
  530. case imageTypeGIF:
  531. err = C.vips_gifsave_go(img, &ptr, &imgsize)
  532. case imageTypeICO:
  533. err = C.vips_icosave_go(img, &ptr, &imgsize)
  534. }
  535. if err != 0 {
  536. return nil, vipsError()
  537. }
  538. return C.GoBytes(ptr, C.int(imgsize)), nil
  539. }
  540. func vipsArrayjoin(in []*C.struct__VipsImage, out **C.struct__VipsImage) error {
  541. var tmp *C.struct__VipsImage
  542. if C.vips_arrayjoin_go(&in[0], &tmp, C.int(len(in))) != 0 {
  543. return vipsError()
  544. }
  545. C.swap_and_clear(out, tmp)
  546. return nil
  547. }
  548. func vipsImageHasAlpha(img *C.struct__VipsImage) bool {
  549. return C.vips_image_hasalpha_go(img) > 0
  550. }
  551. func vipsGetInt(img *C.struct__VipsImage, name string) (int, error) {
  552. var i C.int
  553. if C.vips_image_get_int(img, C.CString(name), &i) != 0 {
  554. return 0, vipsError()
  555. }
  556. return int(i), nil
  557. }
  558. func vipsSetInt(img *C.struct__VipsImage, name string, value int) {
  559. C.vips_image_set_int(img, C.CString(name), C.int(value))
  560. }
  561. func vipsPremultiply(img **C.struct__VipsImage) (C.VipsBandFormat, error) {
  562. var tmp *C.struct__VipsImage
  563. format := C.vips_band_format(*img)
  564. if C.vips_premultiply_go(*img, &tmp) != 0 {
  565. return 0, vipsError()
  566. }
  567. C.swap_and_clear(img, tmp)
  568. return format, nil
  569. }
  570. func vipsUnpremultiply(img **C.struct__VipsImage, format C.VipsBandFormat) error {
  571. var tmp *C.struct__VipsImage
  572. if C.vips_unpremultiply_go(*img, &tmp) != 0 {
  573. return vipsError()
  574. }
  575. C.swap_and_clear(img, tmp)
  576. if C.vips_cast_go(*img, &tmp, format) != 0 {
  577. return vipsError()
  578. }
  579. C.swap_and_clear(img, tmp)
  580. return nil
  581. }
  582. func vipsCastUchar(img **C.struct__VipsImage) error {
  583. var tmp *C.struct__VipsImage
  584. if C.vips_image_get_format(*img) != C.VIPS_FORMAT_UCHAR {
  585. if C.vips_cast_go(*img, &tmp, C.VIPS_FORMAT_UCHAR) != 0 {
  586. return vipsError()
  587. }
  588. C.swap_and_clear(img, tmp)
  589. }
  590. return nil
  591. }
  592. func vipsResize(img **C.struct__VipsImage, scale float64) error {
  593. var tmp *C.struct__VipsImage
  594. if C.vips_resize_go(*img, &tmp, C.double(scale)) != 0 {
  595. return vipsError()
  596. }
  597. C.swap_and_clear(img, tmp)
  598. return nil
  599. }
  600. func vipsRotate(img **C.struct__VipsImage, angle int) error {
  601. var tmp *C.struct__VipsImage
  602. if C.vips_rot_go(*img, &tmp, C.VipsAngle(angle)) != 0 {
  603. return vipsError()
  604. }
  605. C.swap_and_clear(img, tmp)
  606. return nil
  607. }
  608. func vipsFlip(img **C.struct__VipsImage) error {
  609. var tmp *C.struct__VipsImage
  610. if C.vips_flip_horizontal_go(*img, &tmp) != 0 {
  611. return vipsError()
  612. }
  613. C.swap_and_clear(img, tmp)
  614. return nil
  615. }
  616. func vipsCrop(img **C.struct__VipsImage, left, top, width, height int) error {
  617. var tmp *C.struct__VipsImage
  618. if C.vips_extract_area_go(*img, &tmp, C.int(left), C.int(top), C.int(width), C.int(height)) != 0 {
  619. return vipsError()
  620. }
  621. C.swap_and_clear(img, tmp)
  622. return nil
  623. }
  624. func vipsExtract(in *C.struct__VipsImage, out **C.struct__VipsImage, left, top, width, height int) error {
  625. if C.vips_extract_area_go(in, out, C.int(left), C.int(top), C.int(width), C.int(height)) != 0 {
  626. return vipsError()
  627. }
  628. return nil
  629. }
  630. func vipsSmartCrop(img **C.struct__VipsImage, width, height int) error {
  631. var tmp *C.struct__VipsImage
  632. if C.vips_smartcrop_go(*img, &tmp, C.int(width), C.int(height)) != 0 {
  633. return vipsError()
  634. }
  635. C.swap_and_clear(img, tmp)
  636. return nil
  637. }
  638. func vipsFlatten(img **C.struct__VipsImage, bg color) error {
  639. var tmp *C.struct__VipsImage
  640. if C.vips_flatten_go(*img, &tmp, C.double(bg.R), C.double(bg.G), C.double(bg.B)) != 0 {
  641. return vipsError()
  642. }
  643. C.swap_and_clear(img, tmp)
  644. return nil
  645. }
  646. func vipsBlur(img **C.struct__VipsImage, sigma float32) error {
  647. var tmp *C.struct__VipsImage
  648. if C.vips_gaussblur_go(*img, &tmp, C.double(sigma)) != 0 {
  649. return vipsError()
  650. }
  651. C.swap_and_clear(img, tmp)
  652. return nil
  653. }
  654. func vipsSharpen(img **C.struct__VipsImage, sigma float32) error {
  655. var tmp *C.struct__VipsImage
  656. if C.vips_sharpen_go(*img, &tmp, C.double(sigma)) != 0 {
  657. return vipsError()
  658. }
  659. C.swap_and_clear(img, tmp)
  660. return nil
  661. }
  662. func vipsImportColourProfile(img **C.struct__VipsImage) error {
  663. var tmp *C.struct__VipsImage
  664. if C.vips_need_icc_import(*img) > 0 {
  665. profile, err := cmykProfilePath()
  666. if err != nil {
  667. return err
  668. }
  669. if C.vips_icc_import_go(*img, &tmp, C.CString(profile)) != 0 {
  670. return vipsError()
  671. }
  672. C.swap_and_clear(img, tmp)
  673. }
  674. return nil
  675. }
  676. func vipsFixColourspace(img **C.struct__VipsImage) error {
  677. var tmp *C.struct__VipsImage
  678. if C.vips_image_guess_interpretation(*img) != C.VIPS_INTERPRETATION_sRGB {
  679. if C.vips_colourspace_go(*img, &tmp, C.VIPS_INTERPRETATION_sRGB) != 0 {
  680. return vipsError()
  681. }
  682. C.swap_and_clear(img, tmp)
  683. }
  684. return nil
  685. }
  686. func vipsImageCopyMemory(img **C.struct__VipsImage) error {
  687. var tmp *C.struct__VipsImage
  688. if tmp = C.vips_image_copy_memory(*img); tmp == nil {
  689. return vipsError()
  690. }
  691. C.swap_and_clear(img, tmp)
  692. return nil
  693. }
  694. func vipsReplicate(img **C.struct__VipsImage, width, height C.int) error {
  695. var tmp *C.struct__VipsImage
  696. if C.vips_replicate_go(*img, &tmp, 1+width/(*img).Xsize, 1+height/(*img).Ysize) != 0 {
  697. return vipsError()
  698. }
  699. C.swap_and_clear(img, tmp)
  700. if C.vips_extract_area_go(*img, &tmp, 0, 0, width, height) != 0 {
  701. return vipsError()
  702. }
  703. C.swap_and_clear(img, tmp)
  704. return nil
  705. }
  706. func vipsEmbed(img **C.struct__VipsImage, gravity gravityType, width, height C.int, offX, offY C.int) error {
  707. wmWidth := (*img).Xsize
  708. wmHeight := (*img).Ysize
  709. left := (width-wmWidth+1)/2 + offX
  710. top := (height-wmHeight+1)/2 + offY
  711. if gravity == gravityNorth || gravity == gravityNorthEast || gravity == gravityNorthWest {
  712. top = offY
  713. }
  714. if gravity == gravityEast || gravity == gravityNorthEast || gravity == gravitySouthEast {
  715. left = width - wmWidth - offX
  716. }
  717. if gravity == gravitySouth || gravity == gravitySouthEast || gravity == gravitySouthWest {
  718. top = height - wmHeight - offY
  719. }
  720. if gravity == gravityWest || gravity == gravityNorthWest || gravity == gravitySouthWest {
  721. left = offX
  722. }
  723. if left > width {
  724. left = width - wmWidth
  725. } else if left < -wmWidth {
  726. left = 0
  727. }
  728. if top > height {
  729. top = height - wmHeight
  730. } else if top < -wmHeight {
  731. top = 0
  732. }
  733. var tmp *C.struct__VipsImage
  734. if C.vips_embed_go(*img, &tmp, left, top, width, height) != 0 {
  735. return vipsError()
  736. }
  737. C.swap_and_clear(img, tmp)
  738. return nil
  739. }
  740. func vipsResizeWatermark(width, height int) (wm *C.struct__VipsImage, err error) {
  741. wmW := float64(watermark.Xsize)
  742. wmH := float64(watermark.Ysize)
  743. wr := float64(width) / wmW
  744. hr := float64(height) / wmH
  745. scale := math.Min(wr, hr)
  746. if wmW*scale < 1 {
  747. scale = 1 / wmW
  748. }
  749. if wmH*scale < 1 {
  750. scale = 1 / wmH
  751. }
  752. if C.vips_resize_go(watermark, &wm, C.double(scale)) != 0 {
  753. err = vipsError()
  754. }
  755. return
  756. }
  757. func vipsApplyWatermark(img **C.struct__VipsImage, opts *watermarkOptions) error {
  758. if watermark == nil {
  759. return nil
  760. }
  761. var wm, wmAlpha, tmp *C.struct__VipsImage
  762. var err error
  763. defer C.clear_image(&wm)
  764. defer C.clear_image(&wmAlpha)
  765. imgW := (*img).Xsize
  766. imgH := (*img).Ysize
  767. if opts.Scale == 0 {
  768. if wm = C.vips_image_copy_memory(watermark); wm == nil {
  769. return vipsError()
  770. }
  771. } else {
  772. wmW := maxInt(int(float64(imgW)*opts.Scale), 1)
  773. wmH := maxInt(int(float64(imgH)*opts.Scale), 1)
  774. if wm, err = vipsResizeWatermark(wmW, wmH); err != nil {
  775. return err
  776. }
  777. }
  778. if opts.Replicate {
  779. if err = vipsReplicate(&wm, imgW, imgH); err != nil {
  780. return err
  781. }
  782. } else {
  783. if err = vipsEmbed(&wm, opts.Gravity, imgW, imgH, C.int(opts.OffsetX), C.int(opts.OffsetY)); err != nil {
  784. return err
  785. }
  786. }
  787. if C.vips_extract_band_go(wm, &tmp, (*wm).Bands-1, 1) != 0 {
  788. return vipsError()
  789. }
  790. C.swap_and_clear(&wmAlpha, tmp)
  791. if C.vips_extract_band_go(wm, &tmp, 0, (*wm).Bands-1) != 0 {
  792. return vipsError()
  793. }
  794. C.swap_and_clear(&wm, tmp)
  795. imgInterpolation := C.vips_image_guess_interpretation(*img)
  796. if imgInterpolation != C.vips_image_guess_interpretation(wm) {
  797. if C.vips_colourspace_go(wm, &tmp, imgInterpolation) != 0 {
  798. return vipsError()
  799. }
  800. C.swap_and_clear(&wm, tmp)
  801. }
  802. if opts.Opacity < 1 {
  803. if C.vips_linear_go(wmAlpha, &tmp, C.double(opts.Opacity), 0) != 0 {
  804. return vipsError()
  805. }
  806. C.swap_and_clear(&wmAlpha, tmp)
  807. }
  808. imgFormat := C.vips_image_get_format(*img)
  809. var imgAlpha *C.struct__VipsImage
  810. defer C.clear_image(&imgAlpha)
  811. hasAlpha := vipsImageHasAlpha(*img)
  812. if hasAlpha {
  813. if C.vips_extract_band_go(*img, &imgAlpha, (**img).Bands-1, 1) != 0 {
  814. return vipsError()
  815. }
  816. if C.vips_extract_band_go(*img, &tmp, 0, (**img).Bands-1) != 0 {
  817. return vipsError()
  818. }
  819. C.swap_and_clear(img, tmp)
  820. }
  821. if C.vips_ifthenelse_go(wmAlpha, wm, *img, &tmp) != 0 {
  822. return vipsError()
  823. }
  824. C.swap_and_clear(img, tmp)
  825. if hasAlpha {
  826. if C.vips_bandjoin_go(*img, imgAlpha, &tmp) != 0 {
  827. return vipsError()
  828. }
  829. C.swap_and_clear(img, tmp)
  830. }
  831. if imgFormat != C.vips_image_get_format(*img) {
  832. if C.vips_cast_go(*img, &tmp, imgFormat) != 0 {
  833. return vipsError()
  834. }
  835. C.swap_and_clear(img, tmp)
  836. }
  837. return nil
  838. }
  839. func vipsError() error {
  840. return errors.New(C.GoString(C.vips_error_buffer()))
  841. }