开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
GD.xs
资源名称：netcam-1.2.tar.gz　[点击查看]
上传用户：qdrechuli
上传日期：2022-08-01
资源大小：917k
文件大小：13k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

GD.xs：源码内容
  1. #include "EXTERN.h"
  2. #include "perl.h"
  3. #include "XSUB.h"
  4. #include "libgd/gd.h"
  5. #ifdef FCGI
  6.  #include <fcgi_stdio.h>
  7. #else
  8.  #ifdef USE_SFIO
  9.   #include <config.h>
  10.  #else
  11.   #include <stdio.h>
  12.  #endif
  13.  #include <perlio.h>
  14. #endif
  15. /* Copyright 1995, 1996, Lincoln D. Stein.  See accompanying README file for
  16. usage restrictions */
  18. static int
  19. not_here(s)
  20. char *s;
  21. {
  22.     croak("%s not implemented on this architecture", s);
  23.     return -1;
  24. }
  26. static double
  27. constant(name, arg)
  28. char *name;
  29. int arg;
  30. {
  31.     errno = 0;
  32.     switch (*name) {
  33.     case 'A':
  34. break;
  35.     case 'B':
  36. break;
  37.     case 'C':
  38. break;
  39.     case 'D':
  40. break;
  41.     case 'E':
  42. break;
  43.     case 'F':
  44. break;
  45.     case 'G':
  46. break;
  47.     case 'H':
  48. break;
  49.     case 'I':
  50. break;
  51.     case 'J':
  52. break;
  53.     case 'K':
  54. break;
  55.     case 'L':
  56. break;
  57.     case 'M':
  58. break;
  59.     case 'N':
  60. break;
  61.     case 'O':
  62. break;
  63.     case 'P':
  64. break;
  65.     case 'Q':
  66. break;
  67.     case 'R':
  68. break;
  69.     case 'S':
  70. break;
  71.     case 'T':
  72. break;
  73.     case 'U':
  74. break;
  75.     case 'V':
  76. break;
  77.     case 'W':
  78. break;
  79.     case 'X':
  80. break;
  81.     case 'Y':
  82. break;
  83.     case 'Z':
  84. break;
  85.     case 'a':
  86. break;
  87.     case 'b':
  88. break;
  89.     case 'c':
  90. break;
  91.     case 'd':
  92. break;
  93.     case 'e':
  94. break;
  95.     case 'f':
  96. break;
  97.     case 'g':
  98. if (strEQ(name, "gdBrushed"))
  99. #ifdef gdBrushed
  100.     return gdBrushed;
  101. #else
  102.     goto not_there;
  103. #endif
  104. if (strEQ(name, "gdDashSize"))
  105. #ifdef gdDashSize
  106.     return gdDashSize;
  107. #else
  108.     goto not_there;
  109. #endif
  110. if (strEQ(name, "gdMaxColors"))
  111. #ifdef gdMaxColors
  112.     return gdMaxColors;
  113. #else
  114.     goto not_there;
  115. #endif
  116. if (strEQ(name, "gdStyled"))
  117. #ifdef gdStyled
  118.     return gdStyled;
  119. #else
  120.     goto not_there;
  121. #endif
  122. if (strEQ(name, "gdStyledBrushed"))
  123. #ifdef gdStyledBrushed
  124.     return gdStyledBrushed;
  125. #else
  126.     goto not_there;
  127. #endif
  128. if (strEQ(name, "gdTiled"))
  129. #ifdef gdTiled
  130.     return gdTiled;
  131. #else
  132.     goto not_there;
  133. #endif
  134. if (strEQ(name, "gdTransparent"))
  135. #ifdef gdTransparent
  136.     return gdTransparent;
  137. #else
  138.     goto not_there;
  139. #endif
  140. break;
  141.     case 'h':
  142. break;
  143.     case 'i':
  144. break;
  145.     case 'j':
  146. break;
  147.     case 'k':
  148. break;
  149.     case 'l':
  150. break;
  151.     case 'm':
  152. break;
  153.     case 'n':
  154. break;
  155.     case 'o':
  156. break;
  157.     case 'p':
  158. break;
  159.     case 'q':
  160. break;
  161.     case 'r':
  162. break;
  163.     case 's':
  164. break;
  165.     case 't':
  166. break;
  167.     case 'u':
  168. break;
  169.     case 'v':
  170. break;
  171.     case 'w':
  172. break;
  173.     case 'x':
  174. break;
  175.     case 'y':
  176. break;
  177.     case 'z':
  178. break;
  179.     }
  180.     errno = EINVAL;
  181.     return 0;
  183. not_there:
  184.     errno = ENOENT;
  185.     return 0;
  186. }
  188. typedef gdImagePtr GD__Image;
  189. typedef gdFontPtr GD__Font;
  190. typedef PerlIO * InputStream;
  191. extern  gdFontPtr gdFontLarge;
  192. extern gdFontPtr gdFontSmall;
  193. extern gdFontPtr gdFontMediumBold;
  194. extern gdFontPtr gdFontTiny;
  196. MODULE = GD PACKAGE = GD
  198. double
  199. constant(name,arg)
  200. char * name
  201. int arg
  203. MODULE = GD PACKAGE = GD::Image PREFIX=gd
  205. GD::Image
  206. gdnew(packname="GD::Image", x=64, y=64)
  207. char * packname
  208. int x
  209. int y
  210.         PROTOTYPE: $;$$
  211. CODE:
  212. {
  213. gdImagePtr theImage;
  214. theImage = gdImageCreate(x,y);
  215. RETVAL = theImage;
  216. }
  217. OUTPUT:
  218. RETVAL
  220. GD::Image
  221. gd_newFromGif(packname="GD::Image", filehandle)
  222. char * packname
  223. InputStream filehandle
  224. PROTOTYPE: $$
  225. CODE:
  226. RETVAL = gdImageCreateFromGif(filehandle);
  227. OUTPUT:
  228. RETVAL
  230. GD::Image
  231. gd_newFromXbm(packname="GD::Image", filehandle)
  232. char * packname
  233. InputStream filehandle
  234. PROTOTYPE: $$
  235. CODE:
  236. RETVAL = gdImageCreateFromXbm(filehandle);
  237. OUTPUT:
  238. RETVAL
  240. GD::Image
  241. gd_newFromGd(packname="GD::Image", filehandle)
  242. char * packname
  243. InputStream filehandle
  244. PROTOTYPE: $$
  245. CODE:
  246. RETVAL = gdImageCreateFromGd(filehandle);
  247. OUTPUT:
  248. RETVAL
  251. void
  252. gdDESTROY(image)
  253. GD::Image image
  254. PROTOTYPE: $
  255. CODE:
  256. {
  257. gdImageDestroy(image);
  258. }
  260. SV*
  261. gdgif(image)
  262.   GD::Image image
  263.   PROTOTYPE: $
  264.   CODE:
  265.   {
  266. void*         data;
  267. int           size;
  268. data = gdImageGifPtr(image,&size);
  269. RETVAL = newSVpv((char*) data,size);
  270. free(data);
  271.   }
  272.   OUTPUT:
  273.     RETVAL
  275. SV*
  276. gdgd(image)
  277.   GD::Image image
  278.   PROTOTYPE: $
  279.   CODE:
  280.   {
  281. void*         data;
  282. int           size;
  283. data = gdImageGdPtr(image,&size);
  284. RETVAL = newSVpv((char*) data,size);
  285. free(data);
  286.   }
  287.   OUTPUT:
  288.     RETVAL
  290. int
  291. gdtransparent(image, ...)
  292. GD::Image image
  293.         PROTOTYPE: $;$
  294. CODE:
  295. {
  296. int color;
  297. if (items > 1) {
  298. color=(int)SvIV(ST(1));
  299. gdImageColorTransparent(image,color);
  300. }
  301. RETVAL = gdImageGetTransparent(image);
  302. }
  303. OUTPUT:
  304. RETVAL
  306. void
  307. gdgetBounds(image)
  308. GD::Image image
  309. PROTOTYPE: $
  310. PPCODE:
  311. {
  312. int sx,sy;
  313. sx = gdImageSX(image);
  314. sy = gdImageSY(image);
  315. EXTEND(sp,2);
  316. PUSHs(sv_2mortal(newSViv(sx)));
  317. PUSHs(sv_2mortal(newSViv(sy)));
  318. }
  320. int
  321. gdrgb(image,color)
  322. GD::Image image
  323. int color
  324.         PROTOTYPE: $$
  325. PPCODE:
  326. {
  327. int r,g,b;
  328. r = gdImageRed(image,color);
  329. g = gdImageGreen(image,color);
  330. b = gdImageBlue(image,color);
  331. EXTEND(sp,3);
  332. PUSHs(sv_2mortal(newSViv(r)));
  333. PUSHs(sv_2mortal(newSViv(g)));
  334. PUSHs(sv_2mortal(newSViv(b)));
  335. }
  337. int
  338. gdboundsSafe(image,x,y)
  339. GD::Image image
  340. int x
  341. int y
  342.         PROTOTYPE: $$$
  343. CODE:
  344. {
  345. RETVAL=gdImageBoundsSafe(image,x,y);
  346. }
  347. OUTPUT:
  348. RETVAL
  350. int
  351. gdgetPixel(image,x,y)
  352. GD::Image image
  353. int x
  354. int y
  355. PROTOTYPE: $$$
  356. CODE:
  357. {
  358. RETVAL=gdImageGetPixel(image,x,y);
  359. }
  360. OUTPUT:
  361. RETVAL
  363. void
  364. gdsetPixel(image,x,y,color)
  365. GD::Image image
  366. int x
  367. int y
  368. int color
  369. PROTOTYPE: $$$
  370. CODE:
  371. {
  372. gdImageSetPixel(image,x,y,color);
  373. }
  375. void
  376. gdline(image,x1,y1,x2,y2,color)
  377. GD::Image image
  378. int x1
  379. int y1
  380. int x2
  381. int y2
  382. int color
  383.         PROTOTYPE: $$$$$$
  384. CODE:
  385. {
  386. gdImageLine(image,x1,y1,x2,y2,color);
  387. }
  389. void
  390. gddashedLine(image,x1,y1,x2,y2,color)
  391. GD::Image image
  392. int x1
  393. int y1
  394. int x2
  395. int y2
  396. int color
  397.         PROTOTYPE: $$$$$$
  398. CODE:
  399. {
  400. gdImageDashedLine(image,x1,y1,x2,y2,color);
  401. }
  403. void
  404. gdopenPolygon(image,poly,color)
  405. GD::Image image
  406. SV * poly
  407. int color
  408.         PROTOTYPE: $$$
  409. CODE:
  410. {
  411. dSP ;
  412. int length,count ;
  413. int x,y,i ;
  414. gdPointPtr polyptr;
  416. ENTER ;
  417. SAVETMPS ;
  418. PUSHMARK(sp) ;
  419. XPUSHs(poly) ;
  420. PUTBACK ;
  421. count = perl_call_method("length",G_SCALAR) ;
  422. SPAGAIN ;
  423. if (count != 1)
  424. croak("Didn't get a single result from GD::Poly::length() call.n");
  425. length = POPi ;
  426. PUTBACK ;
  427. FREETMPS ;
  428. LEAVE ;
  430. polyptr = (gdPointPtr)safemalloc(sizeof(gdPoint)*length);
  431. if (polyptr == NULL)
  432. croak("safemalloc() returned NULL in GD::Image::poly().n");
  434. for (i=0;i<length;i++) {
  435. ENTER ;
  436. SAVETMPS ;
  437. PUSHMARK(sp) ;
  438. XPUSHs(poly) ;
  439. XPUSHs(sv_2mortal(newSViv(i))) ;
  440. PUTBACK ;
  441. count = perl_call_method("getPt",G_ARRAY) ;
  442. SPAGAIN ;
  443. if (count != 2)
  444. croak("Didn't get a single result from GD::Poly::length() call.n");
  445. y = POPi ;
  446. x = POPi ;
  447. PUTBACK ;
  448. FREETMPS ;
  449. LEAVE ;
  451. polyptr[i].x = x;
  452. polyptr[i].y = y;
  453. }
  455. gdImageOpenPolygon(image,polyptr,length,color);
  456. safefree((char*) polyptr);
  457. }
  459. void
  460. gdfilledPolygon(image,poly,color)
  461. GD::Image image
  462. SV * poly
  463. int color
  464.         PROTOTYPE: $$$
  465. CODE:
  466. {
  467. dSP ;
  468. int length,count ;
  469. int x,y,i ;
  470. gdPointPtr polyptr;
  472. ENTER ;
  473. SAVETMPS ;
  474. PUSHMARK(sp) ;
  475. XPUSHs(poly) ;
  476. PUTBACK ;
  477. count = perl_call_method("length",G_SCALAR) ;
  478. SPAGAIN ;
  479. if (count != 1)
  480. croak("Didn't get a single result from GD::Poly::length() call.n");
  481. length = POPi ;
  482. PUTBACK ;
  483. FREETMPS ;
  484. LEAVE ;
  486. polyptr = (gdPointPtr)safemalloc(sizeof(gdPoint)*length);
  487. if (polyptr == NULL)
  488. croak("safemalloc() returned NULL in GD::Image::poly().n");
  490. for (i=0;i<length;i++) {
  491. ENTER ;
  492. SAVETMPS ;
  493. PUSHMARK(sp) ;
  494. XPUSHs(poly) ;
  495. XPUSHs(sv_2mortal(newSViv(i))) ;
  496. PUTBACK ;
  497. count = perl_call_method("getPt",G_ARRAY) ;
  498. SPAGAIN ;
  499. if (count != 2)
  500. croak("Didn't get a single result from GD::Poly::length() call.n");
  501. y = POPi ;
  502. x = POPi ;
  503. PUTBACK ;
  504. FREETMPS ;
  505. LEAVE ;
  507. polyptr[i].x = x;
  508. polyptr[i].y = y;
  509. }
  511. gdImageFilledPolygon(image,polyptr,length,color);
  512. safefree((char*) polyptr);
  513. }
  515. void
  516. gdrectangle(image,x1,y1,x2,y2,color)
  517. GD::Image image
  518. int x1
  519. int y1
  520. int x2
  521. int y2
  522. int color
  523.         PROTOTYPE: $$$$$$
  524. CODE:
  525. {
  526. gdImageRectangle(image,x1,y1,x2,y2,color);
  527. }
  529. void
  530. gdfilledRectangle(image,x1,y1,x2,y2,color)
  531. GD::Image image
  532. int x1
  533. int y1
  534. int x2
  535. int y2
  536. int color
  537.         PROTOTYPE: $$$$$$
  538. CODE:
  539. {
  540. gdImageFilledRectangle(image,x1,y1,x2,y2,color);
  541. }
  543. void
  544. gdarc(image,cx,cy,w,h,s,e,color)
  545. GD::Image image
  546. int cx
  547. int cy
  548. int w
  549. int h
  550. int s
  551. int e
  552. int color
  553.         PROTOTYPE: $$$$$$$$
  554. CODE:
  555. {
  556. gdImageArc(image,cx,cy,w,h,s,e,color);
  557. }
  559. void
  560. fillToBorder(image,x,y,border,color)
  561. GD::Image image
  562. int x
  563. int y
  564. int border
  565. int color
  566.         PROTOTYPE: $$$$$
  567. CODE:
  568. {
  569. gdImageFillToBorder(image,x,y,border,color);
  570. }
  572. void
  573. fill(image,x,y,color)
  574. GD::Image image
  575. int x
  576. int y
  577. int color
  578.         PROTOTYPE: $$$$
  579. CODE:
  580. {
  581. gdImageFill(image,x,y,color);
  582. }
  584. void
  585. setBrush(image,brush)
  586. GD::Image image
  587. GD::Image brush
  588.         PROTOTYPE: $$
  589. CODE:
  590. {
  591. gdImageSetBrush(image,brush);
  592. }
  594. void
  595. setTile(image,tile)
  596. GD::Image image
  597. GD::Image tile
  598.         PROTOTYPE: $$
  599. CODE:
  600. {
  601. gdImageSetTile(image,tile);
  602. }
  604. void
  605. setStyle(image, ...)
  606. GD::Image image
  607.         PROTOTYPE: $;$
  608. CODE:
  609. {
  610. int *style;
  611. int i;
  613. if (items < 2)
  614. return;
  615. style = (int*) safemalloc(sizeof(int)*(items-1));
  616. if (style == NULL)
  617. croak("malloc returned NULL at setStyle().n");
  618. for(i=1;i<items;i++) {
  619. style[i-1]=(int)SvIV(ST(i));
  620. }
  621. gdImageSetStyle(image,style,items-1);
  622. safefree((char*) style);
  623. }
  625. int
  626. colorAllocate(image,r,g,b)
  627. GD::Image image
  628. int r
  629. int g
  630. int b
  631.         PROTOTYPE: $$$$
  632. CODE:
  633. {
  634. RETVAL = gdImageColorAllocate(image,r,g,b);
  635. }
  636. OUTPUT:
  637. RETVAL
  639. int
  640. colorClosest(image,r,g,b)
  641. GD::Image image
  642. int r
  643. int g
  644. int b
  645.         PROTOTYPE: $$$$
  646. CODE:
  647. {
  648. RETVAL = gdImageColorClosest(image,r,g,b);
  649. }
  650. OUTPUT:
  651. RETVAL
  653. int
  654. colorExact(image,r,g,b)
  655. GD::Image image
  656. int r
  657. int g
  658. int b
  659. PROTOTYPE: $$$$
  660. CODE:
  661. {
  662. RETVAL = gdImageColorExact(image,r,g,b);
  663. }
  664. OUTPUT:
  665. RETVAL
  667. int
  668. colorsTotal(image)
  669. GD::Image image
  670. PROTOTYPE: $
  671. CODE:
  672. {
  673. RETVAL = gdImageColorsTotal(image);
  674. }
  675. OUTPUT:
  676. RETVAL
  679. int
  680. interlaced(image, ...)
  681. GD::Image image
  682. PROTOTYPE: $;$
  683. CODE:
  684. {
  685. if (items > 1) {
  686. if (SvOK(ST(1)))
  687. gdImageInterlace(image,1);
  688. else
  689. gdImageInterlace(image,0);
  690. }
  691. RETVAL = gdImageGetInterlaced(image);
  692. }
  693. OUTPUT:
  694. RETVAL
  696. void
  697. colorDeallocate(image,color)
  698. GD::Image image
  699. int color
  700. PROTOTYPE: $$
  701. CODE:
  702. {
  703. gdImageColorDeallocate(image,color);
  704. }
  706. void
  707. copy(destination,source,dstX,dstY,srcX,srcY,w,h)
  708. GD::Image destination
  709. GD::Image source
  710. int dstX
  711. int dstY
  712. int srcX
  713. int srcY
  714. int w
  715. int h
  716.         PROTOTYPE: $$$$$$$$
  717. CODE:
  718. {
  719. gdImageCopy(destination,source,dstX,dstY,srcX,srcY,w,h);
  720. }
  722. void
  723. copyResized(destination,source,dstX,dstY,srcX,srcY,destW,destH,srcW,srcH)
  724. GD::Image destination
  725. GD::Image source
  726. int dstX
  727. int dstY
  728. int srcX
  729. int srcY
  730. int destW
  731. int destH
  732. int srcW
  733. int srcH
  734.         PROTOTYPE: $$$$$$$$$$
  735. CODE:
  736. {
  737. gdImageCopyResized(destination,source,dstX,dstY,srcX,srcY,destW,destH,srcW,srcH);
  738. }
  740. void
  741. gdchar(image,font,x,y,c,color)
  742. GD::Image image
  743. GD::Font font
  744. int x
  745. int y
  746. char * c
  747. int color
  748.         PROTOTYPE: $$$$$$
  749. CODE:
  750. {
  751. gdImageChar(image,font,x,y,*c,color);
  752. }
  754. void
  755. gdcharUp(image,font,x,y,c,color)
  756. GD::Image image
  757. GD::Font font
  758. int x
  759. int y
  760. char * c
  761. int color
  762.         PROTOTYPE: $$$$$$
  763. CODE:
  764. {
  765. gdImageCharUp(image,font,x,y,*c,color);
  766. }
  768. void
  769. gdstring(image,font,x,y,s,color)
  770. GD::Image image
  771. GD::Font font
  772. int x
  773. int y
  774. char * s
  775. int color
  776.         PROTOTYPE: $$$$$$
  777. CODE:
  778. {
  779. gdImageString(image,font,x,y,s,color);
  780. }
  782. void
  783. gdstringUp(image,font,x,y,s,color)
  784. GD::Image image
  785. GD::Font font
  786. int x
  787. int y
  788. char * s
  789. int color
  790.         PROTOTYPE: $$$$$$
  791. CODE:
  792. {
  793. gdImageStringUp(image,font,x,y,s,color);
  794. }
  796. MODULE = GD PACKAGE = GD::Font PREFIX=gd
  798. GD::Font
  799. gdSmall(packname="GD::Font")
  800. char * packname
  801.         PROTOTYPE: $
  802. CODE:
  803. {
  804. RETVAL = gdFontSmall;
  805. }
  806. OUTPUT:
  807. RETVAL
  809. GD::Font
  810. gdLarge(packname="GD::Font")
  811. char * packname
  812. PROTOTYPE: $
  813. CODE:
  814. {
  815. RETVAL = gdFontLarge;
  816. }
  817. OUTPUT:
  818. RETVAL
  820. GD::Font
  821. gdMediumBold(packname="GD::Font")
  822. char * packname
  823. PROTOTYPE: $
  824. CODE:
  825. {
  826. RETVAL = gdFontMediumBold;
  827. }
  828. OUTPUT:
  829. RETVAL
  831. GD::Font
  832. gdTiny(packname="GD::Font")
  833. char * packname
  834. PROTOTYPE: $
  835. CODE:
  836. {
  837. RETVAL = gdFontTiny;
  838. }
  839. OUTPUT:
  840. RETVAL
  842. int
  843. gdnchars(font)
  844. GD::Font font
  845. PROTOTYPE: $
  846. CODE:
  847. {
  848. RETVAL = font->nchars;
  849. }
  850. OUTPUT:
  851. RETVAL
  853. int
  854. gdoffset(font)
  855. GD::Font font
  856. PROTOTYPE: $
  857. CODE:
  858. {
  859. RETVAL = font->offset;
  860. }
  861. OUTPUT:
  862. RETVAL
  864. int
  865. gdwidth(font)
  866. GD::Font font
  867. PROTOTYPE: $
  868. CODE:
  869. {
  870. RETVAL = font->w;
  871. }
  872. OUTPUT:
  873. RETVAL
  875. int
  876. gdheight(font)
  877. GD::Font font
  878. PROTOTYPE: $
  879. CODE:
  880. {
  881. RETVAL = font->h;
  882. }
  883. OUTPUT:
  884. RETVAL