From 57c906a95465d0753a958dc444d14f0d44be29a8 Mon Sep 17 00:00:00 2001 From: Tuomo Tanskanen Date: Wed, 16 Dec 2009 12:26:29 +0200 Subject: [PATCH] import load-applet 0.46-1 --- Makefile.am | 13 + TODO | 5 + configure.ac | 96 +++ data/Makefile.am | 9 + data/la_picture.png | Bin 0 -> 2746 bytes data/la_process.png | Bin 0 -> 696 bytes data/la_video.png | Bin 0 -> 4829 bytes data/status_area_load_applet.desktop | 4 + data/status_menu_load_applet.desktop | 4 + debian/changelog | 184 ++++++ debian/compat | 1 + debian/control | 104 +++ debian/copyright | 3 + debian/load-applet-ximagewsrc.install | 1 + debian/load-applet.install | 4 + debian/rules | 84 +++ gst/Makefile.am | 19 + gst/gstximagesrc.c | 1157 +++++++++++++++++++++++++++++++++ gst/gstximagesrc.h | 106 +++ gst/ximageutil.c | 494 ++++++++++++++ gst/ximageutil.h | 182 ++++++ icon.png | Bin 0 -> 3382 bytes src/Makefile.am | 32 + src/item.c | 406 ++++++++++++ src/item.h | 34 + src/la_status_area_item.c | 348 ++++++++++ src/la_status_area_item.h | 33 + 27 files changed, 3323 insertions(+) create mode 100644 Makefile.am create mode 100644 TODO create mode 100644 configure.ac create mode 100644 data/Makefile.am create mode 100644 data/la_picture.png create mode 100644 data/la_process.png create mode 100644 data/la_video.png create mode 100644 data/status_area_load_applet.desktop create mode 100644 data/status_menu_load_applet.desktop create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100644 debian/copyright create mode 100644 debian/load-applet-ximagewsrc.install create mode 100644 debian/load-applet.install create mode 100755 debian/rules create mode 100644 gst/Makefile.am create mode 100644 gst/gstximagesrc.c create mode 100644 gst/gstximagesrc.h create mode 100644 gst/ximageutil.c create mode 100644 gst/ximageutil.h create mode 100644 icon.png create mode 100644 src/Makefile.am create mode 100644 src/item.c create mode 100644 src/item.h create mode 100644 src/la_status_area_item.c create mode 100644 src/la_status_area_item.h diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..8e4a161 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,13 @@ +SUBDIRS = src data gst + +EXTRA_DIST = \ + autogen.sh \ + debian/* + +deb: dist + -mkdir $(top_builddir)/debian-build + cd $(top_builddir)/debian-build && tar zxf ../$(top_builddir)/$(PACKAGE)-$(VERSION).tar.gz + cd $(top_builddir)/debian-build/$(PACKAGE)-$(VERSION) && dpkg-buildpackage -rfakeroot + -rm -rf $(top_builddir)/debian-build/$(PACKAGE)-$(VERSION) + +DISTCLEANFILES = *~ diff --git a/TODO b/TODO new file mode 100644 index 0000000..892c7d9 --- /dev/null +++ b/TODO @@ -0,0 +1,5 @@ + * Make nicer application manager icon + * Add process listing and killing again (use hildon button to launch it! not GTK buton) + * Prolly need to launch the process listing in own thread or process - else it blocks the main one and comes stacked wrong + * Add watermarking to the ximagewsrc, also fast scaling by factor of 2 + diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..8dfab45 --- /dev/null +++ b/configure.ac @@ -0,0 +1,96 @@ +AC_INIT(Makefile.am) +AM_INIT_AUTOMAKE(maemo5-load-applet, 0.5) +AM_CONFIG_HEADER(config.h) + +AC_CANONICAL_HOST + +AC_PROG_CC +AC_PROG_CPP +AC_PROG_INSTALL +AC_PROG_RANLIB +AC_PROG_LIBTOOL + +AC_HEADER_STDC + +CFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wmissing-declarations" + +AC_SUBST(CFLAGS) + +PKG_CHECK_MODULES([MAEMO5_LOADAPPLET], [ + gtk+-2.0 >= 2.4.0 + glib-2.0 >= 2.2.0 + hildon-1 >= 1.0.9 + osso-af-settings >= 0.8.1 + libhildondesktop-1 >= 2.1.0 +]) + +AC_SUBST(MAEMO5_LOADAPPLET) +AC_SUBST(MAEMO5_LOADAPPLET_CFLAGS) + +hildondesktoplibdir="${libdir}/hildon-desktop" +AC_SUBST(hildondesktoplibdir) + +hildondesktoplibdir="${libdir}/hildon-desktop" +AC_SUBST(hildondesktoplibdir) + + + +AC_CHECK_HEADER(X11/Xlib.h, HAVE_X="yes", HAVE_X="no") +if test "x$HAVE_X" = "xno" + then + AC_MSG_NOTICE([cannot find X11 development files]) + else + dnl this is much more than we want + X_LIBS="$X_LIBS $X_PRE_LIBS $X_EXTRA_LIBS" + dnl AC_PATH_XTRA only defines the path needed to find the X libs, + dnl it does not add the libs; therefore we add them here + X_LIBS="$X_LIBS -lX11" + AC_SUBST(X_CFLAGS) + AC_SUBST(X_LIBS) + + dnl check for Xfixes + PKG_CHECK_MODULES(XFIXES, xfixes, HAVE_XFIXES="yes", HAVE_XFIXES="no") + if test "x$HAVE_XFIXES" = "xyes" + then + XFIXES_CFLAGS="-DHAVE_XFIXES $XFIXES_CFLAGS" + fi + AC_SUBST(XFIXES_LIBS) + AC_SUBST(XFIXES_CFLAGS) + + dnl check for Xdamage + PKG_CHECK_MODULES(XDAMAGE, xdamage, HAVE_XDAMAGE="yes", HAVE_XDAMAGE="no") + if test "x$HAVE_XDAMAGE" = "xyes" + then + XDAMAGE_CFLAGS="-DHAVE_XDAMAGE $XDAMAGE_CFLAGS" + fi + AC_SUBST(XDAMAGE_LIBS) + AC_SUBST(XDAMAGE_CFLAGS) + fi + +dnl check for GST BASE flags +PKG_CHECK_MODULES(GSTREAMERBASE, gstreamer-base-0.10, HAVE_GSTREAMERBASE="yes", HAVE_GSTREAMERBASE="no") +AC_SUBST(GSTREAMERBASE_LIBS) +AC_SUBST(GSTREAMERBASE_CFLAGS) + +dnl check for GST flags +PKG_CHECK_MODULES(GSTREAMER, gstreamer-0.10, HAVE_GSTREAMER="yes", HAVE_GSTREAMER="no") +AC_SUBST(GSTREAMER_LIBS) +AC_SUBST(GSTREAMER_CFLAGS) + +GST_LICENSE="LGPL" +AC_DEFINE_UNQUOTED(GST_LICENSE, "$GST_LICENSE", [GStreamer license]) +AC_SUBST(GST_LICENSE) + + + +GST_PLUGIN_LDFLAGS="-module -avoid-version -export-symbols-regex '^[_]*gst_plugin_desc\$\$' -no-undefined" +AC_SUBST(GST_PLUGIN_LDFLAGS) + + +AC_CONFIG_FILES([ + Makefile + src/Makefile + data/Makefile + gst/Makefile +]) +AC_OUTPUT diff --git a/data/Makefile.am b/data/Makefile.am new file mode 100644 index 0000000..0e527ee --- /dev/null +++ b/data/Makefile.am @@ -0,0 +1,9 @@ +install-data-local: + $(INSTALL_DATA) -D $(srcdir)/status_area_load_applet.desktop $(DESTDIR)/usr/share/applications/hildon-status-menu/status_area_load_applet.desktop + $(INSTALL_DATA) -D $(srcdir)/status_menu_load_applet.desktop $(DESTDIR)/usr/share/applications/hildon-status-menu/status_menu_load_applet.desktop + $(INSTALL_DATA) -D $(srcdir)/la_picture.png $(DESTDIR)/usr/share/pixmaps/la_picture.png + $(INSTALL_DATA) -D $(srcdir)/la_video.png $(DESTDIR)/usr/share/pixmaps/la_video.png + $(INSTALL_DATA) -D $(srcdir)/la_process.png $(DESTDIR)/usr/share/pixmaps/la_process.png + + + diff --git a/data/la_picture.png b/data/la_picture.png new file mode 100644 index 0000000000000000000000000000000000000000..6678de8073a89654455eba686993bf3bbde4b717 GIT binary patch literal 2746 zcmW+&2|SeB8=eXYxr4E!Dci(gVs12CSGI^55));~zJv^66my$WWV_;L>=c)=Bn{!l zSca@~YcR4+b|oY=Lu0M*KmEV&EZ;fb@0{;F@AE#-`z6`gS{@aV7lA+^N3mAsc+jJN zRbe5}UOl*z0J;MacuO-#^#FVs41~O`EzKeOzwUn+6&YaW$W1Hf2na+}>Q_Ag$$u;d zCJz&_7cCBtA3h9Igj$Fj#(}A0L<=Y4`A`DEFN6p=AMWQx^z&7`9Y_pNw8UPtyLw+- z76K8G#+sWt1k8NR!v@10<(cBEq z>86QUgfI8zl5m2=VT7Da7^K@&w(Ts=J{$e)0rqar?hd=tQHQb_?naA&M)zWA=9yHVbi@%;Xy2i|d;KNxVY4fE zTnSRLjmPT=`}qJ8wJ~~C&4aXDcF(OTd?7OvUw+4h7yuXliQOT)L!iWY1XeuJ)kF z>h$WcXB;$><>&AYr|#_R+z|$cGdmgx6hy}s*^u4EH$<_#Jv~j#?akp#r<&Gp$x_U< zX!TQip)~^5{vDx#@TBAW(_{uow1O3!U%CqfD6oD>uZf@?} z++2*u-JOTwP0tx4H>}R8VI`m2sQNf%FCYae2qm%eo#@hm53!3S&8#`!`}Ze@{*$991>5L^eoINQ_kI!P%`f zvchD8vxi5;+W^nWO(nLd(u=XNvB#paS^=DAQ2VjV^9bzI(IDS?XN{~k=_8?XLJH({ ziP+d!5TkYDsPW+JTP+viOxWKR+1c4n?(Y6%@(F;<1LCJ65+6TRqPo0Mf+^_!8 z-U)R=Af<|I+owCa`6L2yMq_Z7pF{ilzt_!XF^o*~ew6MSi7b+b} z3^4H-D@;+zy`8l7;b07%`~y?N*vucuK_(MBWkdvBXfh211((SHOu@i(>g95&Q)1_7 ziOFj=s#NJuer`$vz^VAk5l8iFoYAa>fhT`Hr_pL%Z}{Y@=uV$ev$e5D!hnCqMqfux zYc2LKgu}u0EFSP%(7RT%^soo-d> z(5-v)&g}g9vL&6gp`jNtHMhPz49*#F@bYwkQ4vQX-QW90KmgK?kyuw6m@i;DIBHS} z6@4%V-6rmwfWx~Z-Dr2JMwN@$Iz~nVFK=+7b{2AWHYY=!ot#XBJJ#2A>+9?9?CmV2 zq@{r;s%EZBL{t=A)N(><>~)4(3(Rip3(-J7l^S|wL1&tY3@u}PTOYo}=eF=lGz$Ej zM}p4w_V$A4{K(R7|JeCZv~{&p)ZD)N%^Q)TyWiDybacLOxpj?=3G@2R526d15$to8 zP=V&=GHT};F%|nG6^5R2LV#X|o9}!kK74Ks@=Md8;&Jiu@wxf=-hqKwS3BX3&d!5P z*HW!>ve17F!OJUQN zY5#loig0Bm1qLy}m@4b4gPa0cGvR?EV|H(^Q1wdCrbF}^;DB=3FKQvMPHt{Jb*SVX zuv*QO%YRW0f>Q#*f zodRsS5AC!kd<7QCYP*+Chpapt-nG;&F3qwN?eFUY35!$hMtvLbNl+SyDiGOQEwtBK zw2v8=j9vqP)(m-ezaJoSf~H%ebx=7h%~ydj8yk@}!y~0bRj=&fgRZutygZ%j$Q;&B zfLm~IaKKi@`S)CFK}PS$2n;~ptbkJs&X0v%cjC43ZGTi&6n>Y}pI#?tkLwua=^1mqFgjjQ7^uL%E~g z16A8K?*Gncr3^4K51vU@uC1@GUW}4r_di^mXRAR{K@bQDRL* zi~wal2}l>c`gpQOSdxVLg7X|~@HgK*cAFP5X0=**%F$nzu7uai`}|i&tkIpH_bHJ1 pSKrT}k1=PTrY<;vayRGa@s2cY^T=z8x!^Ang0-+UuQv01@ITZwPKE#g literal 0 HcmV?d00001 diff --git a/data/la_process.png b/data/la_process.png new file mode 100644 index 0000000000000000000000000000000000000000..9850c659c008d0110be98ebdb6a0da573d058a98 GIT binary patch literal 696 zcmV;p0!RIcP)Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iXZ1 z69y$Z1%&tj000?uMObu0Z*6U5Zgc=ca%Ew3Wn>_CX>@2HM@dakSAh-}0006LNklvo9 zm-osEsD5jLZCtLe;ws=PbypD|kK1}7ItTU|w*|5RQoy)`y+e;w;HxuJBhdw8+El6# z_pu7U3hfoZ0=+#c2^D!2+V`IisaFgFz)>wk0e2ExNJzam3;}`!C$Wbhz-p(vVMCI- z!kBPlcdR6=_r#`C5$TnV?o8rDp|7j^mb6KPx#24YJ`L;wH)0002_L%V+f000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iXY; z6b%F*5qm@c000?uMObu0Z*6U5Zgc=ca%Ew3Wn>_CX>@2HM@dakSAh-}000s=NklybaIA!2}733BKdIbO> zggEViBwY}2rcHbI4+#m`3r3Clk#WQbP!y15tw<7>Oc0G~ZCQ?u4fXZ#>8C-lYu77> z9FEMN6c)~?KW~ov4%$uw;6f1%AQmmUX;pFYpJz^;Y9TA@bgH|zEf$DGw06&DvJ8O$ zoom*Jl?M-QDsOK7=}S9zMt;zL^`P^j05I{DiGR8J*H=#-#V8~_%X;qFjw6mB!L#;j zqKOxmzSz-vq;

FMLtiD**UpS@isXEgJn+kY0UNNIQ3K+H>{QH(r*R`R$Y5y=}LH z-~ZkHVxkd=z}mHKfg?vgzJA@hSw$BVfS&10#Geg>H9!A(#m}ct&m%q_f5@4p{hx^3H!=55^g)kU!a-$nelfiQFZ%)i_)>4wQU z=qIq|D-m?a}dfYYf>l+~(fc#}z+G^0_Q%y9S=bA-d7s@gNNSt}-! zb{$Kqs#ytD)k-9yz1P_ZZ@lr%p_gCI9u0W@WdM9WXHHz5$J2KE%$Y`9E{KoU5U^NI zAz(C~((>Jl5T|UQ5T~s_C=%cy01yEUhS~ zbeJT8*9)(`21P|n*uDF8nwm;5n;i@pGMy14=5YJ%W5~qO@XnHVkZHk}2`={oK6xW>z^Pe02XlrmmUBr$4(AiCSdpG=Kjx z3CoImNb20pyt?g7S~iKnDVK3;U?smD_FGc$5l_4>1`+`vfWQYd46*Z`FXG~TO#0B# ziw%HLedgix=#h_+0<$3%NCNCy5f(rJ;^3=-2^b6(+0^oy4-4LQ{>us>k2$=LI7Zm_Q zbjQ@;KXy9#_h<-&8$=QaI}i`T46+GS6WM$2Vra6H2hFQ^r0p}!!t9#IrT%;jvW!Vl zFewUAA&@1BHxGUUKz`#(%*xLvckRcF^lb-&14Op&LXNN4cQ#uDk9WxpDx~zfE86ZT604fLb zJK4~J zomw9>H$!Wy7CEY}9s~yhV&C5$X*}03-+2S@!Dxyf{bYO2q?RYSE+H4xz7TbRNY)fV zNP%cFONQ^@)mLkIDEd5?<$AdLpu#|h%z(sBvJ;v~jq_tM7-&XfbLJlEOlG|Cf@Qh8 z*nD&qronx>wVsoaDn3-o0~vwK*a9odJWy}Ak3slYkK49_6e`i>FMBdY0AKE*WF1Q z2*E?MX0frNg3ss7AuBzdEv2P=a`Y(PPzaNv;IdkoJ8~o`85wNavxgalg|sYN2AP?V zmZq(&BuQHXw6$ppps5LJYS>U#hAc_1+_G}z{{ju?0>Tdof~H*k;MM!WzHr8{JBE>S zT@G1fk*H@EuCB<-&3tg@2Q(Hp^4NjL z7|BTDiN}RY|5=F+I%w1LF^*BwQp2G&ht#jve|_DNkB=M%ntE$v#IayO{bTFa&H9gF z!|q_ffLqAQa+8{>F@V#lF+uluzYy@j2k`v!eK~oumXwsiWMz#e81zt6vlXAOnaPvi zWZt~ln9bUPG9~3yTqHL6?d{Og0=2bp^yrtgw^vse7S5OeoB-N;3jp)T^z=Syc6<4N zq$Jafp+mVkD@$Y97y=0i+R``{-4WtcRHw2MN=w;v_%H*LlgSz|K=b*HMy+2`k|sW} zcU2WU9*z2wC!xNcj$_AIbLbFulWF0M!orn00D;~D03hj+xs2?vg@{eajzo^H8?7V4;@YDX2GI!|@sjKZ6N z79D_I-5a!7EY6fmE*V#5vn5*x4Vp&ZzGF#Ciz7MtRD{TG*Vwsxm`{?lP~Y+6nvRRb zPGTk2Clb-3NF5zoX>ZrwId-gyva%0^+3dJ~!-jh|>Hu{1YD{p((4p$;k`nJLS2<=s z_4y~OvueuaTP*9iLg|B1b^|UD@u0>*L=P29k`~MI`M~F6P*W4A>6-g!vuU*?YhvI( z)sK!2O$3@6IdP(ajnx(0kYxLK@~Tyv^-x&n`Ot9Q98fAsT@fO2!=zzNfa`&Z2ku!v zcm1M%6Z+9_LO;?+rsGtc1PRjgO%vV*?+|y^ zRbL1vE?7|ihr+@cx4YfLuvnZ35yfs#!)$h7Fj%^ZqL`3n1F~$uYIWiFx9ZXF2tq_r z)ex#0A`%G@jYjbMTd~{Iu-TGnZ?7g0Xm37nV8!J6`rXHLt$$(n1iz{s){!h!V?VA9thCv^HJyVFt%^srjHIEp0>TVHb#8=4-w-ZA_DSYX>hd1 zw-Nxy+@iS;d^qRBM@@DU_B1>8G&>fj1+&A9(PqS8F<`J5kPR{xr-h&=sQK5r2!ws% zt`hVF@iutzHh9UKnAcSPVfo}^yN)&JvwreiqCdTHLPXM+Z1FeWyg0wPxqRi(qn|kA z;!?3%UBtzuVlvrJ69co^K`7+y5`h@&MomnRk|Y)NxF;k@l7$dg0Y%-uF2~|@o8%nRcz!4RGQ5GpINS5<8^oH()YsdejW0HZ#xGRD8gGpDlxcW?w-Y?bXLnmtz!9a__L=+K%u z8)waWA-5s%g+cW>qsh&+U;j|<)0CCnd$)AgV`JZb`+Y7(iV-S=s1ZWEdIr7F)lUeK z7rVY|>s{9^6-)P)h!U|uY!C&aK+Lb6Uo!i%*%QtbR0WLVpB?|wy#4dUpTwWU_{X%}f z-`l_c*oPM_+I7c-3DWqA3aF}r%F2_?_4T`d=l8cRUAuO=`fY=c9s8e)ladBJ(68SF z>gtO6uU{S@`c&Rj2{OpnK8M!v&qSkwrtu&Q)ef;jvW&lD=Jo& zH#aXh+b(f;8qfKdoYiH0{>oon`Do6Mb5KJn4f`8tEN*1vaou;Q`3a9skw1aZg>*(6FC|hW#`)7SqyFQ5Fca4~_*&^zA8GkIA>w?Pm63b*yayE(M0_?NXpj2P>j~ z?@V)xg&mYb{_0vh>=odwqU=wqwdtIYTj=q0W$HL%+U# z$BwS5`t1MokhZFqNVoQxuDf$b%%?GR?VWtjgA)G$!-Vw`3m?X<00000NkvXXu0mjf DeorpL literal 0 HcmV?d00001 diff --git a/data/status_area_load_applet.desktop b/data/status_area_load_applet.desktop new file mode 100644 index 0000000..877bdc8 --- /dev/null +++ b/data/status_area_load_applet.desktop @@ -0,0 +1,4 @@ +[Desktop Entry] +Name=Load Applet Maemo5 edition - status area plugin +Type=default +X-Path=status_area_load_applet.so diff --git a/data/status_menu_load_applet.desktop b/data/status_menu_load_applet.desktop new file mode 100644 index 0000000..dc8b8e7 --- /dev/null +++ b/data/status_menu_load_applet.desktop @@ -0,0 +1,4 @@ +[Desktop Entry] +Name=Load Applet Maemo5 edition - status menu plugin +Type=default +X-Path=status_menu_load_applet.so diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..436823e --- /dev/null +++ b/debian/changelog @@ -0,0 +1,184 @@ +load-applet (0.4.6-1) unstable; urgency=low + + * Fixed applet name + + -- Jakub Pavelek Sat, 31 Oct 2009 12:07:08 +0200 + +load-applet (0.4.5-2) unstable; urgency=low + + * GStreamer got updated on latest images, not in SDK. Rebuild! + + -- Jakub Pavelek Tue, 6 Oct 2009 21:16:50 +0300 + +load-applet (0.4.5-1) unstable; urgency=low + + * Comment that process info out for now + * Added copy of ximagesrc. Will modify it to have more functionality later + + -- Jakub Pavelek Wed, 30 Sep 2009 18:57:44 +0300 + +load-applet (0.4.4-3) unstable; urgency=low + + * Added missing dependency on gstreamer0.10-plugins-good-extra + + -- Jakub Pavelek Thu, 24 Sep 2009 23:24:26 +0300 + +load-applet (0.4.4-2) unstable; urgency=low + + * Added missing dependency on gst-tools + + -- Jakub Pavelek Thu, 24 Sep 2009 20:54:40 +0300 + +load-applet (0.4.4-1) unstable; urgency=low + + * Show grayed box on no CPU/Mem usage + + -- Jakub Pavelek Wed, 23 Sep 2009 21:38:52 +0300 + +load-applet (0.4.3-1) unstable; urgency=low + + * Process listing - trying out a dialog launching + * Bit better icon for video recording + + -- Jakub Pavelek Wed, 9 Sep 2009 22:37:24 +0300 + +load-applet (0.4.2-1) unstable; urgency=low + + * More efficient and consistent blinking for max cpu load + + -- Jakub Pavelek Wed, 9 Sep 2009 21:18:41 +0300 + +load-applet (0.4.1-1) unstable; urgency=low + + * Pulsating high CPU load - simple version + + -- Jakub Pavelek Tue, 8 Sep 2009 23:38:58 +0300 + +load-applet (0.4.0-2) unstable; urgency=low + + * New bigger icon to test the appearance in application manager + + -- Jakub Pavelek Tue, 8 Sep 2009 23:14:35 +0300 + +load-applet (0.4.0-1) unstable; urgency=low + + * Do not toggle the camera app when taking screenshot + * Show banner with instructions for the screenshot + + -- Jakub Pavelek Sun, 6 Sep 2009 17:53:52 +0300 + +load-applet (0.3.3-1) unstable; urgency=low + + * Do not toggle the camera app when taking screenshot + * Show banner with instructions for the screenshot + + -- Jakub Pavelek Sun, 6 Sep 2009 17:53:52 +0300 + +load-applet (0.3.2-1) unstable; urgency=low + + * Tuning the memory and CPU bars + * Stop monitoring when screen is off (should do same for fullscreen video, + maps or browser too, but too much trouble without system states) + + -- Jakub Pavelek Sun, 6 Sep 2009 16:19:51 +0300 + +load-applet (0.3.1-1) unstable; urgency=low + + * Moving monitoring from menu to area + + -- Jakub Pavelek Sun, 6 Sep 2009 10:22:23 +0300 + +load-applet (0.3.0-1) unstable; urgency=low + + * Repackaging and renaming files - split between status area and status menu items + * Adding dummy status area applet + + -- Jakub Pavelek Sat, 5 Sep 2009 12:06:07 +0300 + +maemo5-load-applet (0.2.9-1) unstable; urgency=low + + * Lets have audio for the screencast. Voice-over baby! + * Changed the encoder settings for better image quality. + + -- Jakub Pavelek Thu, 3 Sep 2009 23:29:18 +0300 + +maemo5-load-applet (0.2.8-1) unstable; urgency=low + + * Close the menu? Toggle the screenshot? Still not done ... + + -- Jakub Pavelek Mon, 3 Aug 2009 21:17:26 +0300 + +maemo5-load-applet (0.2.7-1) unstable; urgency=low + + * Listening to camera key now. + + -- Jakub Pavelek Sat, 1 Aug 2009 09:09:35 +0300 + +maemo5-load-applet (0.2.6-1) unstable; urgency=low + + * Added button for status under the icon - to open the list with apps in future + + -- Jakub Pavelek Thu, 9 Jul 2009 22:12:41 +0300 + +maemo5-load-applet (0.2.5-1) unstable; urgency=low + + * Recording works. Bad framerate, no package dependencies. + + -- Jakub Pavelek Thu, 9 Jul 2009 00:51:15 +0300 + +maemo5-load-applet (0.2.4-2) unstable; urgency=low + + * Moving to different category/section + + -- Jakub Pavelek Tue, 21 Apr 2009 14:18:07 +0300 + +maemo5-load-applet (0.2.4-1) unstable; urgency=low + + * Record UI kinda works + + -- Jakub Pavelek Thu, 9 Jul 2009 00:10:34 +0300 + +maemo5-load-applet (0.2.3-1) unstable; urgency=low + + * Added beeps to time the screenshot + * New UI - small bars, buttons for screenshot and screencast (non-functional) + * Reusing existing sound for shutter + + -- Jakub Pavelek Tue, 7 Jul 2009 23:22:13 +0300 + +maemo5-load-applet (0.2.1-1) unstable; urgency=low + + * Updated the icons for transparency, should look alright with theme change now. + + -- Jakub Pavelek Mon, 2 Mar 2009 11:39:54 +0200 + +maemo5-load-applet (0.2.0-1) unstable; urgency=low + + * Adding graphics for load indication + + -- Jakub Pavelek Sun, 1 Mar 2009 19:27:27 +0200 + +maemo5-load-applet (0.1.1-1) unstable; urgency=low + + * Small build script updates and looks of the button change. + * Removed beeping, kept shutter sound + + -- Jakub Pavelek Sat, 28 Feb 2009 18:11:10 +0200 + +maemo5-load-applet (0.1-3) unstable; urgency=low + + * Another section fix me hopes + + -- Jakub Pavelek Sat, 28 Feb 2009 04:45:31 +0200 + +maemo5-load-applet (0.1-2) unstable; urgency=low + + * Moving to proper category and giving the old icon for app manager + + -- Jakub Pavelek Sat, 28 Feb 2009 04:39:37 +0200 + +maemo5-load-applet (0.1) unstable; urgency=low + + * Initial release + + -- Jakub Pavelek Fri, 27 Feb 2009 18:08:43 +0200 diff --git a/debian/compat b/debian/compat new file mode 100644 index 0000000..b8626c4 --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +4 diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..7c8d727 --- /dev/null +++ b/debian/control @@ -0,0 +1,104 @@ +Source: load-applet +Section: user/utilities +Priority: optional +Maintainer: Jakub Pavelek +Build-Depends: debhelper (>= 4.1.0), libhildon1-dev (>=2.1.29), libosso-dev (>=2.0), osso-af-settings, libhildondesktop1-dev (>=2.1.0), libgstreamer0.10-dev +Standards-Version: 3.8.0 + +Package: load-applet-ximagewsrc +Section: devel +Architecture: any +Depends: ${shlibs:Depends} +Description: GStreamer XImage source, modified + XImage source modified to scale and include simple watermark + + +Package: load-applet +Section: user/utilities +Architecture: any +Conflicts: maemo5-load-applet +Replaces: maemo5-load-applet +Provides: maemo5-load-applet +Depends: ${shlibs:Depends}, libhildon1 (>=2.1.29), libosso1 (>=2.0), libhildondesktop1 (>=2.1.0), gstreamer-tools, load-applet-ximagewsrc +XB-Maemo-Icon-26: + iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAAXNSR0IArs4c + 6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0 + SU1FB9kJCBQIINnZDLUAAAy2SURBVGjejZrJjiRHcoY/8/DYcunausluNklw + GhhQmOM8hy56Aj2LnkQPJGguAuYiiHMYAYSKLNaSS2zubjp4LJ5ZWZSyEJWZ + sbjbbr+ZpWRW/hHlv0D+yvgSBOZjOgeggKLjOR3PzneJzvfr8vFspbgKovM5 + GddSBFTmdRE520lJNv9ngX/LTJZlIP+KyLeIICLxQWF+l5kfufgu0/v4B+M6 + CYMyftDky6mgZDwtcVk5F97pJ4R/QvgPK8hfT8SzLHX2kCZXFZ3vkpNn5Fz0 + 51/O9jq/fnJZX9+hcqLLj2KLXFEukJxuKLMKdZLk+Qaqr2jTMypkNgYdLeSC + oPQS/XJ5VQUrLOp/dXuizulIPUE1HqiiKheY0FciP5WzvJb7JQ2pnKyniUla + kcvqmwjOTEZmM6y1ZFmGGANAUMU5h3MO7xwhBDSEC8S+ZTCSSuryTXrZzOaL + CwOnLESpG7IsoyxL6rpmtVpRVRU2zwEY3EDbtByPR47HI33f472PTKgusUNe + x7bJ8WWMEKemxKhVZg2rkKx5Sqs1IlH9Mm4ggjEL8dvNlpvbG97fvefq+oqq + qkGgbVuenp54eHjgt99+Y7fb0Xdd1IYGVFNrH2OOCEYEMQaTHGISJjRqV0PA + +0AInhDid33teNEHptApRsiyjNzmlGXJZrPh7u6Oz58/8+233/L111+z2WxQ + 4LDf8z/39/z33/9OnufYLGO/39N1Hc4NeB83FhREMKNGrc2wNifPLdbmWJtF + JsTE4KBK8AHvPcPgcG5gGAac8+OaUTiTLuwUr8UYbG4py4r1esV2u+Xm+oaP + Hz/y/fff88MPP/Dp0ye22y0A+92O6+tryqLAWktVFDw+PbJ72XE4Hmi7Ducc + qooxhtzmFGVJXVVUVUVVleR5fNZkZjYpVSWEgHOOfujpuo62aWnalq7rGAZH + 8B7VMEah0R4zm1FVFVdXV9zd3nF3d8f79+/56quv+Pz5Mx8/fuTDh/es1xsA + qqpCiY4sAnVds33Y8uuvv/Lw8IC8PNO2EDRgbU5d1Wy2G95tt6zXG6q6Irf5 + KH2Zs66MPjAx0XUdh8OBl92O3W7H8TD522hCk03mNme9WnF7e8s333zDx49f + c3Nzy7t371itVgC0bTdDhK6Ln1ermvfv31PkOev1irIsYWTMh0AIgbIoebfd + cnt3y83NLZvNhqLIETGLo6rO4XzyCwA3DBwOR8qqwhhDCDr7mIaAFYmOZHNL + XdfcXF/z4cMH7u7uqOqaoIHn5yeapuGXX3/BZhYA7x1939P3PRoCq/UaMQbv + PYfDgd1uT9d3eO+pqorNZsP11TU3Nzes1yuyLCP4gPMe7ye7BjP6obUZWWZR + VcqyAqDve9q2pe87vPME1WhCxgg2y6jKktVqxXq1wtqcrm3ZHw60TYP3/jSZ + jaEuywxVXbNZb6IW12tWq6gJm9nxnphHbG7JrY05xRj8aPOoEsb4GJ3dkGUW + azNUIc9z8mJ0/CwjMwZjBA1gkRgBTJaRWTvb5TD0vOxeuL+/5/G3R9q2JSSJ + SgBjDFVVcXN7w1dffc12u8VINEebWcyU9EJgGAa6tqNrO/I8h9wuiDUJ4amA + nPd452nahrZp6fse5/0ShWSMQlN8NhIdSlXp+579bs/DwwO/3N9zOB7wbno4 + QgxrLav1mqCBul5RlhVBNcb10YZDCPR9z+F4oHgpyKxFUeq6JrNZtHkRGMOo + SIQKzjm897Rty8vuhafnJ/b7A13X4YOfEjGWGT4v+UBRfPD0rqPtGo7tgWNz + mMPiBDVsZsEobbehHzp8cEmujEcISt8PHI5HxBgU8N6zdY66rinLkjzPyUwW + 99aYA7q+o2kadrsdz8/PPD0/s9/v6buO4H3M85IwICn2NyBGkUwR65HcQ+4Q + cXNKFxHEMl7ziFXERLSa4vkpJHZtF6FDAhFEhLIsKYqCoigQEZxzMzTZ7XY8 + PT7x/PLMbr+nbRoG5wghsYJ5s+kwgrGQFVBsoLoWaieESvBeEhMSskyoV0J5 + JeQbyCqgH61BFtgdRhjQtt0MBIwxlFXJFVdzlBLg2DQ0xyNt07J/2fHy8hIz + /Ej8DBhjcTBCibngEkwGWSEUG6iNsFWhWwlFGxkAMzteZoS6ErZXsLqDYgXD + HkZrSKqIaBrOO6QTGmMoipK+6xERVqsV11dXo/nCI9B1LYfjgeYY7d75hXiR + sbSLGliwvpi4uS2hfAfrDVythHAQukEIQU7QoDFCmQvXa2G9EUojhEGRTEaA + NkUWUI3aixhnoO87hn4ghBChSF0jwD7Log+0EUJ0fY+bzWauimYTtZKUpSIg + mZCVUGyEOhc2Wwit0PsJtSbwWIQiEzalUBdQDNDvoxZn3zrD95OTDsNA27W0 + I8bpum7M9i1N09C0TQybzi+Sv1BH2LkUn8KpAWOFrIKigqoWhhXYIEkdvCyX + G6hyKAxkzWg+s/TT2L5UaxoCbhhomobnpyfu7+/x3gHw8PAbj4+P0ZGHYc49 + crHGlhiFJiS4mBORkRyyANaAhsvFkxXILBgB00czTNdEku5IUk8752iORx4e + HgB4enoCYLfb8fDwwP5wZBjcHDROiotkLSsneSAxpbRzMh6pBWnSaTlvAEny + oJxUXBNQM6gI/TDwstsxOEfx+Iiq0nYdxwS+qF4qQVMGEhMCs8SkqYQbMU9a + 0jF3KKa/CxWvvD5ipTfiobEIUlWapuV4bPDeRQcfBtwQK7sJMkwiO23yJFBC + zppR0VZHxwuKjglo7sCNnQI1QBijq55KKl0bB0qDsxX7YaBqHoGIMnGAvVzX + d0HAQoWAa8FWaNC0KyEnG8nU3tOJ+PHQpCMjJ2/oWZ/oxJ+mvGGZCU7/L9cu + v6r0mq1O+0nnDJw0MXUkWiEohHDSnZrblMok/bRFuGjUmNctk59//vnVuU+f + PvH/faV+Z841MBExmX0IixbCmUYI8ZhMLWlBLOaY7FYD2Pptymxy39knLNTj + 9wT1YE76tmnimQhSHQnWhfizY9LW9MzS+1ncrrY1jQVo3mZg9IXljuaEjcae + dwyJJaWIWZwv6c/oOfEnYh4j0cSEOW06pX6ArcE11EBjaz59N5qLq0epN9S2 + BgcNTaKlZiHfNWAbagu9Tjvo5ANJpywlb5KyT534tPOnMkapSRNpd2+EvLhm + lF5k5JIPfPnuC9gmIXZkkGZxche1YEWYcIGJZJtFYiMbcxSajjOzmX1DlxCb + lojpYKEeJVr/TsRpoh6AmnpktraLz9S2jkcaKiRx4qUuXfJ9lL6iHoLXmfCZ + eK8ED8EnjnwahxCR0RDqRQsXXnXCYDO7K9SzTzSzb6To4TQTJ/ZPIvmJeBU9 + zYNTKA2pE0sSic6GJS4S+em7TwmJi+PWQO3GT3Z8d0v0mXyoGEtXnVuLaRJL + Bw2zyUiU+ug4acIIgGZAiAlQXmlgkWw9Rpmf/3YhD3z3icbWl6/94VPUoYOa + hiDFrG17OgNL51wm4gTNIGQQbDqjGSVt4xKajZgiEUA6P7NJnHfNGyZU//61 + xLwq0VH+IwMnjfuIGTEYrJTksiKX9WhVPplECkYyCllhpcZKSYbFpOO7C73/ + NxPZ7/jHua+kpm5P8vKMPA2WnCrbsrG3oND7Y2TgpOOfUWQr1vaOKtuSuRJ0 + WPzhjdeXP3y5iHlad/napenORLadpiRzR3jw+B6ML6i4BisUsmEIbWxpJ6lW + MFhTUtl3VFyhvsD3A36ITd25x0IFtLMp/fSfP73J1E9/u3TtT1S0tLYCByL9 + LJ/YViF2eodhoDm2HHcN611NRUVhDUZXeB0WD5inmoZMLVkoUVfQ7jzHXUt7 + bBn6AQ0hjl1tF2GCq1IMehEHXb7W0k5isO3oc9EN7VTi+RBiG+95x8P9I4Kw + eldjC0FFUOxJ6ZJCBtTh+4HjruXh/pGX5x1dGzvTOm8ciW/dG7A5yviNa/HV + ulGLySzBymj7sQ/Z8fT0jIhwbFpWqwqbW8ScznzPR6UaFDd4mmPL89MLT0/P + tF2HnzH4aEKjpL/8MZrEdL5NaoQ//fELjMxUl/yECvBJTT7GUA1LQ9c5x25/ + oCjyOFpN5sMXf/ugiveBvov9+6mTHMaJZSRmIjky0iYyXwhtZ+Kns8vdiy4m + 4KkjA38B/jw1ndqxC9Y07TgXljl9vTXVnbBQ8HEQ59w0x4p3p5JsqcC24KrF + cGxF5abqq519pbWR/MqlzJz+ekD+4ccf/6zKvy/F+BS/lzFPmpxl+bnJm7Nd + NB2JKumEdxqpzp0LPZlbn5SMCicjKD2rBBX+xYL8ZcRxOmN8BVX/f0zK0x/h + 6EKAXvqlw8REiNhqwkiTM6q8/asUNGmtnLR2vgF+/F9ey/7EyCxgvgAAAABJ + RU5ErkJggg== + === +Description: Show CPU and memory usage, take screenshots, record screencasts. + This is a small Status-bar applet that monitors the CPU load and + the memory consumption. It has menu for screenshot and + screencast taking. diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 0000000..3ea8593 --- /dev/null +++ b/debian/copyright @@ -0,0 +1,3 @@ +Copyright: (c) 2005-2009 Jakub Pavelek + +Released under the terms of BSD License. diff --git a/debian/load-applet-ximagewsrc.install b/debian/load-applet-ximagewsrc.install new file mode 100644 index 0000000..76fe410 --- /dev/null +++ b/debian/load-applet-ximagewsrc.install @@ -0,0 +1 @@ +usr/lib/gstreamer-0.10/*.so diff --git a/debian/load-applet.install b/debian/load-applet.install new file mode 100644 index 0000000..289d1d9 --- /dev/null +++ b/debian/load-applet.install @@ -0,0 +1,4 @@ +usr/lib/hildon-desktop/*.so +usr/share/applications/hildon-status-menu/* +usr/share/sounds/* +usr/share/pixmaps/* diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..bfc831e --- /dev/null +++ b/debian/rules @@ -0,0 +1,84 @@ +#!/usr/bin/make -f +# -*- makefile -*- + +#export DH_VERBOSE=1 + +DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE) +DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE) + +CFLAGS = -Wall -g + +ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS))) + CFLAGS += -O0 +else + CFLAGS += -O2 +endif +ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS))) + INSTALL_PROGRAM += -s +endif + +config.status: configure + dh_testdir + CFLAGS="$(CFLAGS)" ./configure --host=$(DEB_HOST_GNU_TYPE) --build=$(DEB_BUILD_GNU_TYPE) --prefix=/usr --exec-prefix=/usr + +configure: configure-stamp + +configure-stamp: + libtoolize --automake + aclocal-1.7 || aclocal + autoconf + autoheader + automake-1.7 --add-missing --foreign || automake --add-missing> --foreign + touch configure-stamp + + +build: build-stamp + +build-stamp: config.status + dh_testdir + $(MAKE) + touch build-stamp + +clean: + dh_testdir + dh_testroot + rm -f build-stamp + [ ! -f Makefile ] || $(MAKE) distclean +ifneq "$(wildcard /usr/share/misc/config.sub)" "" + cp -f /usr/share/misc/config.sub config.sub +endif +ifneq "$(wildcard /usr/share/misc/config.guess)" "" + cp -f /usr/share/misc/config.guess config.guess +endif + rm -f configure COPYING INSTALL Makefile.in aclocal.m4 configure-stamp build-stamp config.guess config.sub depcomp install-sh ltmain.sh missing mkinstalldirs config.h.in + dh_clean + +install: build + dh_testdir + dh_testroot + dh_clean -k + dh_installdirs + $(MAKE) install DESTDIR=$(CURDIR)/debian/tmp + dh_movefiles + +binary-indep: build install + +binary-arch: build install + dh_testdir + dh_testroot + dh_installchangelogs + dh_installdocs + dh_install -v --sourcedir=debian/tmp + dh_link + dh_strip --dbg-package=load-applet + dh_compress + dh_fixperms + dh_makeshlibs -V + dh_installdeb + dh_shlibdeps + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch +.PHONY: build clean binary-indep binary-arch binary install diff --git a/gst/Makefile.am b/gst/Makefile.am new file mode 100644 index 0000000..969b14e --- /dev/null +++ b/gst/Makefile.am @@ -0,0 +1,19 @@ +plugindir = $(libdir)/gstreamer-0.10 + + +plugin_LTLIBRARIES = libgstximagewsrc.la + +libgstximagewsrc_la_SOURCES = gstximagesrc.c ximageutil.c +libgstximagewsrc_la_CFLAGS = \ + $(GST_PLUGINS_BASE_CFLAGS) \ + $(GSTREAMERBASE_CFLAGS) \ + $(GSTREAMER_CFLAGS) \ + $(X_CFLAGS) $(XFIXES_CFLAGS) $(XDAMAGE_CFLAGS) +libgstximagewsrc_la_LIBADD = \ + $(GSTREAMERBASE_LIBS) \ + $(GSTREAMER_LIBS) \ + $(X_LIBS) $(XSHM_LIBS) $(XFIXES_LIBS) $(XDAMAGE_LIBS) +libgstximagewsrc_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) +libgstximagewsrc_la_LIBTOOLFLAGS = --tag=disable-static + +noinst_HEADERS = gstximagesrc.h ximageutil.h diff --git a/gst/gstximagesrc.c b/gst/gstximagesrc.c new file mode 100644 index 0000000..6a58014 --- /dev/null +++ b/gst/gstximagesrc.c @@ -0,0 +1,1157 @@ +/* GStreamer + * + * Copyright (C) 2006 Zaheer Merali + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/** + * SECTION:element-ximagesrc + * + * This element captures your X Display and creates raw RGB video. It uses + * the XDamage extension if available to only capture areas of the screen that + * have changed since the last frame. It uses the XFixes extension if + * available to also capture your mouse pointer. By default it will fixate to + * 25 frames per second. + * + * + * Example pipelines + * |[ + * gst-launch ximagesrc ! video/x-raw-rgb,framerate=5/1 ! ffmpegcolorspace ! theoraenc ! oggmux ! filesink location=desktop.ogg + * ]| Encodes your X display to an Ogg theora video at 5 frames per second. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include "gstximagesrc.h" + +#include +#include + +#include +#include + +#include + +GST_DEBUG_CATEGORY_STATIC (gst_debug_ximage_src); +#define GST_CAT_DEFAULT gst_debug_ximage_src + +/* elementfactory information */ +static const GstElementDetails ximagesrc_details = +GST_ELEMENT_DETAILS ("Ximage video source", + "Source/Video", + "Creates a screenshot video stream", + "Lutz Mueller , " + "Jan Schmidt , " + "Zaheer Merali "); + +static GstStaticPadTemplate t = +GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-raw-rgb, " + "framerate = (fraction) [ 0, MAX ], " + "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ], " + "pixel-aspect-ratio = (fraction) [ 0, MAX ]")); + +enum +{ + PROP_0, + PROP_DISPLAY_NAME, + PROP_SCREEN_NUM, + PROP_SHOW_POINTER, + PROP_USE_DAMAGE, + PROP_STARTX, + PROP_STARTY, + PROP_ENDX, + PROP_ENDY +}; + +GST_BOILERPLATE (GstXImageSrc, gst_ximage_src, GstPushSrc, GST_TYPE_PUSH_SRC); + +static void gst_ximage_src_fixate (GstPad * pad, GstCaps * caps); +static void gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc); + +/* Called when a buffer is returned from the pipeline */ +static void +gst_ximage_src_return_buf (GstXImageSrc * ximagesrc, + GstXImageSrcBuffer * ximage) +{ + /* If our geometry changed we can't reuse that image. */ + if ((ximage->width != ximagesrc->width) || + (ximage->height != ximagesrc->height)) { + GST_DEBUG_OBJECT (ximagesrc, + "destroy image %p as its size changed %dx%d vs current %dx%d", + ximage, ximage->width, ximage->height, + ximagesrc->width, ximagesrc->height); + g_mutex_lock (ximagesrc->x_lock); + gst_ximageutil_ximage_destroy (ximagesrc->xcontext, ximage); + g_mutex_unlock (ximagesrc->x_lock); + } else { + /* In that case we can reuse the image and add it to our image pool. */ + GST_LOG_OBJECT (ximagesrc, "recycling image %p in pool", ximage); + /* need to increment the refcount again to recycle */ + gst_buffer_ref (GST_BUFFER (ximage)); + g_mutex_lock (ximagesrc->pool_lock); + ximagesrc->buffer_pool = g_slist_prepend (ximagesrc->buffer_pool, ximage); + g_mutex_unlock (ximagesrc->pool_lock); + } +} + +static gboolean +gst_ximage_src_open_display (GstXImageSrc * s, const gchar * name) +{ + g_return_val_if_fail (GST_IS_XIMAGE_SRC (s), FALSE); + + if (s->xcontext != NULL) + return TRUE; + + g_mutex_lock (s->x_lock); + s->xcontext = ximageutil_xcontext_get (GST_ELEMENT (s), name); + if (s->xcontext == NULL) { + g_mutex_unlock (s->x_lock); + GST_ELEMENT_ERROR (s, RESOURCE, OPEN_READ, + ("Could not open X display for reading"), + ("NULL returned from getting xcontext")); + return FALSE; + } + s->width = s->xcontext->width; + s->height = s->xcontext->height; + + /* Always capture root window, for now */ + s->xwindow = s->xcontext->root; + +#ifdef HAVE_XFIXES + /* check if xfixes supported */ + { + int error_base; + + if (XFixesQueryExtension (s->xcontext->disp, &s->fixes_event_base, + &error_base)) { + s->have_xfixes = TRUE; + GST_DEBUG_OBJECT (s, "X Server supports XFixes"); + } else { + + GST_DEBUG_OBJECT (s, "X Server does not support XFixes"); + } + } + +#ifdef HAVE_XDAMAGE + /* check if xdamage is supported */ + { + int error_base; + long evmask = NoEventMask; + + s->have_xdamage = FALSE; + s->damage = None; + s->damage_copy_gc = None; + s->damage_region = None; + + if (XDamageQueryExtension (s->xcontext->disp, &s->damage_event_base, + &error_base)) { + s->damage = + XDamageCreate (s->xcontext->disp, s->xwindow, XDamageReportNonEmpty); + if (s->damage != None) { + s->damage_region = XFixesCreateRegion (s->xcontext->disp, NULL, 0); + if (s->damage_region != None) { + XGCValues values; + + GST_DEBUG_OBJECT (s, "Using XDamage extension"); + values.subwindow_mode = IncludeInferiors; + s->damage_copy_gc = XCreateGC (s->xcontext->disp, + s->xwindow, GCSubwindowMode, &values); + XSelectInput (s->xcontext->disp, s->xwindow, evmask); + + s->have_xdamage = TRUE; + } else { + XDamageDestroy (s->xcontext->disp, s->damage); + s->damage = None; + } + } else + GST_DEBUG_OBJECT (s, "Could not attach to XDamage"); + } else { + GST_DEBUG_OBJECT (s, "X Server does not have XDamage extension"); + } + } +#endif +#endif + + g_mutex_unlock (s->x_lock); + + if (s->xcontext == NULL) + return FALSE; + + return TRUE; +} + +static gboolean +gst_ximage_src_start (GstBaseSrc * basesrc) +{ + GstXImageSrc *s = GST_XIMAGE_SRC (basesrc); + + s->last_frame_no = -1; +#ifdef HAVE_XDAMAGE + if (s->last_ximage) + gst_buffer_unref (GST_BUFFER_CAST (s->last_ximage)); + s->last_ximage = NULL; +#endif + return gst_ximage_src_open_display (s, s->display_name); +} + +static gboolean +gst_ximage_src_stop (GstBaseSrc * basesrc) +{ + GstXImageSrc *src = GST_XIMAGE_SRC (basesrc); + +#ifdef HAVE_XDAMAGE + if (src->last_ximage) + gst_buffer_unref (GST_BUFFER_CAST (src->last_ximage)); + src->last_ximage = NULL; +#endif + + gst_ximage_src_clear_bufpool (src); + +#ifdef HAVE_XFIXES + if (src->cursor_image) + XFree (src->cursor_image); + src->cursor_image = NULL; +#endif + + if (src->xcontext) { + g_mutex_lock (src->x_lock); + +#ifdef HAVE_XDAMAGE + if (src->damage_copy_gc != None) { + XFreeGC (src->xcontext->disp, src->damage_copy_gc); + src->damage_copy_gc = None; + } + if (src->damage_region != None) { + XFixesDestroyRegion (src->xcontext->disp, src->damage_region); + src->damage_region = None; + } + if (src->damage != None) { + XDamageDestroy (src->xcontext->disp, src->damage); + src->damage = None; + } +#endif + + ximageutil_xcontext_clear (src->xcontext); + src->xcontext = NULL; + g_mutex_unlock (src->x_lock); + } + + return TRUE; +} + +static gboolean +gst_ximage_src_unlock (GstBaseSrc * basesrc) +{ + GstXImageSrc *src = GST_XIMAGE_SRC (basesrc); + + /* Awaken the create() func if it's waiting on the clock */ + GST_OBJECT_LOCK (src); + if (src->clock_id) { + GST_DEBUG_OBJECT (src, "Waking up waiting clock"); + gst_clock_id_unschedule (src->clock_id); + } + GST_OBJECT_UNLOCK (src); + + return TRUE; +} + +static gboolean +gst_ximage_src_recalc (GstXImageSrc * src) +{ + if (!src->xcontext) + return FALSE; + + /* Maybe later we can check the display hasn't changed size */ + /* We could use XQueryPointer to get only the current window. */ + return TRUE; +} + +#ifdef HAVE_XFIXES +static void +composite_pixel (GstXContext * xcontext, guchar * dest, guchar * src) +{ + guint8 r = src[2]; + guint8 g = src[1]; + guint8 b = src[0]; + guint8 a = src[3]; + guint8 dr, dg, db; + guint32 color; + gint r_shift, r_max, r_shift_out; + gint g_shift, g_max, g_shift_out; + gint b_shift, b_max, b_shift_out; + + switch (xcontext->bpp) { + case 8: + color = *dest; + break; + case 16: + color = GUINT16_FROM_LE (*(guint16 *) (dest)); + break; + case 32: + color = GUINT32_FROM_LE (*(guint32 *) (dest)); + break; + default: + /* Should not reach here */ + g_return_if_reached (); + } + + /* possible optimisation: + * move the code that finds shift and max in the _link function */ + for (r_shift = 0; !(xcontext->visual->red_mask & (1 << r_shift)); r_shift++); + for (g_shift = 0; !(xcontext->visual->green_mask & (1 << g_shift)); + g_shift++); + for (b_shift = 0; !(xcontext->visual->blue_mask & (1 << b_shift)); b_shift++); + + for (r_shift_out = 0; !(xcontext->visual->red_mask & (1 << r_shift_out)); + r_shift_out++); + for (g_shift_out = 0; !(xcontext->visual->green_mask & (1 << g_shift_out)); + g_shift_out++); + for (b_shift_out = 0; !(xcontext->visual->blue_mask & (1 << b_shift_out)); + b_shift_out++); + + + r_max = (xcontext->visual->red_mask >> r_shift); + b_max = (xcontext->visual->blue_mask >> b_shift); + g_max = (xcontext->visual->green_mask >> g_shift); + +#define RGBXXX_R(x) (((x)>>r_shift) & (r_max)) +#define RGBXXX_G(x) (((x)>>g_shift) & (g_max)) +#define RGBXXX_B(x) (((x)>>b_shift) & (b_max)) + + dr = (RGBXXX_R (color) * 255) / r_max; + dg = (RGBXXX_G (color) * 255) / g_max; + db = (RGBXXX_B (color) * 255) / b_max; + + dr = (r * a + (0xff - a) * dr) / 0xff; + dg = (g * a + (0xff - a) * dg) / 0xff; + db = (b * a + (0xff - a) * db) / 0xff; + + color = (((dr * r_max) / 255) << r_shift_out) + + (((dg * g_max) / 255) << g_shift_out) + + (((db * b_max) / 255) << b_shift_out); + + switch (xcontext->bpp) { + case 8: + *dest = color; + break; + case 16: + *(guint16 *) (dest) = color; + break; + case 32: + *(guint32 *) (dest) = color; + break; + default: + g_warning ("bpp %d not supported\n", xcontext->bpp); + } +} +#endif + +/* Retrieve an XImageSrcBuffer, preferably from our + * pool of existing images and populate it from the window */ +static GstXImageSrcBuffer * +gst_ximage_src_ximage_get (GstXImageSrc * ximagesrc) +{ + GstXImageSrcBuffer *ximage = NULL; + + g_mutex_lock (ximagesrc->pool_lock); + while (ximagesrc->buffer_pool != NULL) { + ximage = ximagesrc->buffer_pool->data; + + if ((ximage->width != ximagesrc->width) || + (ximage->height != ximagesrc->height)) { + gst_ximage_buffer_free (ximage); + } + + ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool, + ximagesrc->buffer_pool); + } + g_mutex_unlock (ximagesrc->pool_lock); + + if (ximage == NULL) { + GstXContext *xcontext; + GstCaps *caps = NULL; + + GST_DEBUG_OBJECT (ximagesrc, "creating image (%dx%d)", + ximagesrc->width, ximagesrc->height); + + g_mutex_lock (ximagesrc->x_lock); + ximage = gst_ximageutil_ximage_new (ximagesrc->xcontext, + GST_ELEMENT (ximagesrc), ximagesrc->width, ximagesrc->height, + (BufferReturnFunc) (gst_ximage_src_return_buf)); + if (ximage == NULL) { + GST_ELEMENT_ERROR (ximagesrc, RESOURCE, WRITE, (NULL), + ("could not create a %dx%d ximage", ximage->width, ximage->height)); + g_mutex_unlock (ximagesrc->x_lock); + return NULL; + } + + xcontext = ximagesrc->xcontext; + + + caps = gst_caps_new_simple ("video/x-raw-rgb", + "bpp", G_TYPE_INT, xcontext->bpp, + "depth", G_TYPE_INT, xcontext->depth, + "endianness", G_TYPE_INT, xcontext->endianness, + "red_mask", G_TYPE_INT, xcontext->r_mask_output, + "green_mask", G_TYPE_INT, xcontext->g_mask_output, + "blue_mask", G_TYPE_INT, xcontext->b_mask_output, + "width", G_TYPE_INT, ximagesrc->width, + "height", G_TYPE_INT, ximagesrc->height, + "framerate", GST_TYPE_FRACTION, ximagesrc->fps_n, ximagesrc->fps_d, + "pixel-aspect-ratio", GST_TYPE_FRACTION, + gst_value_get_fraction_numerator (xcontext->par), + gst_value_get_fraction_denominator (xcontext->par), NULL); + + gst_buffer_set_caps (GST_BUFFER (ximage), caps); + g_mutex_unlock (ximagesrc->x_lock); + + gst_caps_unref (caps); + } + + g_return_val_if_fail (GST_IS_XIMAGE_SRC (ximagesrc), NULL); +#ifdef HAVE_XDAMAGE + if (ximagesrc->have_xdamage && ximagesrc->use_damage && + ximagesrc->last_ximage != NULL) { + XEvent ev; + + /* have_frame is TRUE when either the entire screen has been + * grabbed or when the last image has been copied */ + gboolean have_frame = FALSE; + + GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XDamage"); + + do { + XNextEvent (ximagesrc->xcontext->disp, &ev); + + if (ev.type == ximagesrc->damage_event_base + XDamageNotify) { + XserverRegion parts; + XRectangle *rects; + int nrects; + + parts = XFixesCreateRegion (ximagesrc->xcontext->disp, 0, 0); + XDamageSubtract (ximagesrc->xcontext->disp, ximagesrc->damage, None, + parts); + /* Now copy out all of the damaged rectangles. */ + rects = XFixesFetchRegion (ximagesrc->xcontext->disp, parts, &nrects); + if (rects != NULL) { + int i; + + if (!have_frame) { + GST_LOG_OBJECT (ximagesrc, + "Copying from last frame ximage->size: %d", + GST_BUFFER_SIZE (GST_BUFFER (ximage))); + memcpy (GST_BUFFER_DATA (GST_BUFFER (ximage)), + GST_BUFFER_DATA (GST_BUFFER (ximagesrc->last_ximage)), + GST_BUFFER_SIZE (GST_BUFFER (ximage))); + have_frame = TRUE; + } + for (i = 0; i < nrects; i++) { + GST_LOG_OBJECT (ximagesrc, + "Damaged sub-region @ %d,%d size %dx%d reported", + rects[i].x, rects[i].y, rects[i].width, rects[i].height); + + /* if we only want a small area, clip this damage region to + * area we want */ + if (ximagesrc->endx > ximagesrc->startx && + ximagesrc->endy > ximagesrc->starty) { + /* see if damage area intersects */ + if (rects[i].x + rects[i].width < ximagesrc->startx || + rects[i].x > ximagesrc->endx) { + /* trivial reject */ + } else if (rects[i].y + rects[i].height < ximagesrc->starty || + rects[i].y > ximagesrc->endy) { + /* trivial reject */ + } else { + /* find intersect region */ + int startx, starty, width, height; + + startx = (rects[i].x < ximagesrc->startx) ? ximagesrc->startx : + rects[i].x; + starty = (rects[i].y < ximagesrc->starty) ? ximagesrc->starty : + rects[i].y; + width = (rects[i].x + rects[i].width < ximagesrc->endx) ? + rects[i].x + rects[i].width - startx : + ximagesrc->endx - startx; + height = (rects[i].y + rects[i].height < ximagesrc->endy) ? + rects[i].y + rects[i].height - starty : ximagesrc->endy - + starty; + + GST_LOG_OBJECT (ximagesrc, + "Retrieving damaged sub-region @ %d,%d size %dx%d as intersect region", + startx, starty, width, height); + XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + startx, starty, width, height, AllPlanes, ZPixmap, + ximage->ximage, startx - ximagesrc->startx, + starty - ximagesrc->starty); + } + } else { + + GST_LOG_OBJECT (ximagesrc, + "Retrieving damaged sub-region @ %d,%d size %dx%d", + rects[i].x, rects[i].y, rects[i].width, rects[i].height); + + XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + rects[i].x, rects[i].y, + rects[i].width, rects[i].height, + AllPlanes, ZPixmap, ximage->ximage, rects[i].x, rects[i].y); + } + } + free (rects); + } + } + } while (XPending (ximagesrc->xcontext->disp)); + if (!have_frame) { + GST_LOG_OBJECT (ximagesrc, + "Copying from last frame ximage->size: %d", + GST_BUFFER_SIZE (GST_BUFFER (ximage))); + memcpy (GST_BUFFER_DATA (GST_BUFFER (ximage)), + GST_BUFFER_DATA (GST_BUFFER (ximagesrc->last_ximage)), + GST_BUFFER_SIZE (GST_BUFFER (ximage))); + have_frame = TRUE; + } +#ifdef HAVE_XFIXES + /* re-get area where last mouse pointer was but only if in our clipping + * bounds */ + if (ximagesrc->cursor_image) { + gint x, y, width, height; + + x = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot; + y = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot; + width = ximagesrc->cursor_image->width; + height = ximagesrc->cursor_image->height; + + /* bounds checking */ + if (x < 0) + x = 0; + if (y < 0) + y = 0; + if (x + width > ximagesrc->xcontext->width) + width = ximagesrc->xcontext->width - x; + if (y + height > ximagesrc->xcontext->height) + height = ximagesrc->xcontext->height - y; + g_assert (x >= 0); + g_assert (y >= 0); + GST_DEBUG_OBJECT (ximagesrc, + "Cursor was at (%d,%d) width: %d, height: %d and our range is: (%d,%d) - (%d,%d)", + x, y, width, height, ximagesrc->startx, ximagesrc->starty, + ximagesrc->endx, ximagesrc->endy); + /* only get where cursor last was, if it is in our range */ + if (ximagesrc->endx > ximagesrc->startx && + ximagesrc->endy > ximagesrc->starty) { + /* check bounds */ + if (x + width < ximagesrc->startx || x > ximagesrc->endx) { + /* trivial reject */ + } else if (y + height < ximagesrc->starty || y > ximagesrc->endy) { + /* trivial reject */ + } else { + /* find intersect region */ + int startx, starty, iwidth, iheight; + + startx = (x < ximagesrc->startx) ? ximagesrc->startx : x; + starty = (y < ximagesrc->starty) ? ximagesrc->starty : y; + iwidth = (x + width < ximagesrc->endx) ? + x + width - startx : ximagesrc->endx - startx; + iheight = (y + height < ximagesrc->endy) ? + y + height - starty : ximagesrc->endy - starty; + GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y); + XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + startx, starty, iwidth, iheight, AllPlanes, ZPixmap, + ximage->ximage, startx - ximagesrc->startx, + starty - ximagesrc->starty); + } + } else { + + GST_DEBUG_OBJECT (ximagesrc, "Removing cursor from %d,%d", x, y); + XGetSubImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + x, y, width, height, AllPlanes, ZPixmap, ximage->ximage, x, y); + } + } +#endif + + + } else { +#endif + +#ifdef HAVE_XSHM + if (ximagesrc->xcontext->use_xshm) { + GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XShm"); + XShmGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + ximage->ximage, ximagesrc->startx, ximagesrc->starty, AllPlanes); + + } else +#endif /* HAVE_XSHM */ + { + GST_DEBUG_OBJECT (ximagesrc, "Retrieving screen using XGetImage"); + ximage->ximage = XGetImage (ximagesrc->xcontext->disp, ximagesrc->xwindow, + ximagesrc->startx, ximagesrc->starty, ximagesrc->width, + ximagesrc->height, AllPlanes, ZPixmap); + } +#ifdef HAVE_XDAMAGE + } +#endif + +#ifdef HAVE_XFIXES + if (ximagesrc->show_pointer && ximagesrc->have_xfixes) { + + GST_DEBUG_OBJECT (ximagesrc, "Using XFixes to draw cursor"); + /* get cursor */ + if (ximagesrc->cursor_image) + XFree (ximagesrc->cursor_image); + ximagesrc->cursor_image = XFixesGetCursorImage (ximagesrc->xcontext->disp); + if (ximagesrc->cursor_image != NULL) { + int cx, cy, i, j, count; + int startx, starty, iwidth, iheight; + gboolean clipped = FALSE; + gboolean cursor_in_image = TRUE; + + cx = ximagesrc->cursor_image->x - ximagesrc->cursor_image->xhot; + if (cx < 0) + cx = 0; + cy = ximagesrc->cursor_image->y - ximagesrc->cursor_image->yhot; + if (cy < 0) + cy = 0; + count = ximagesrc->cursor_image->width * ximagesrc->cursor_image->height; + + /* only get where cursor last was, if it is in our range */ + if (ximagesrc->endx > ximagesrc->startx && + ximagesrc->endy > ximagesrc->starty) { + /* check bounds */ + if (cx + ximagesrc->cursor_image->width < ximagesrc->startx || + cx > ximagesrc->endx) { + /* trivial reject */ + cursor_in_image = FALSE; + } else if (cy + ximagesrc->cursor_image->height < ximagesrc->starty || + cy > ximagesrc->endy) { + /* trivial reject */ + cursor_in_image = FALSE; + } else { + /* find intersect region */ + + startx = (cx < ximagesrc->startx) ? ximagesrc->startx : cx; + starty = (cy < ximagesrc->starty) ? ximagesrc->starty : cy; + iwidth = (cx + ximagesrc->cursor_image->width < ximagesrc->endx) ? + cx + ximagesrc->cursor_image->width - startx : + ximagesrc->endx - startx; + iheight = (cy + ximagesrc->cursor_image->height < ximagesrc->endy) ? + cy + ximagesrc->cursor_image->height - starty : + ximagesrc->endy - starty; + clipped = TRUE; + } + } else { + startx = cx; + starty = cy; + iwidth = ximagesrc->cursor_image->width; + iheight = ximagesrc->cursor_image->height; + } + + if (cursor_in_image) { + GST_DEBUG_OBJECT (ximagesrc, "Cursor is in image so trying to draw it"); + for (i = 0; i < count; i++) + ximagesrc->cursor_image->pixels[i] = + GUINT_TO_LE (ximagesrc->cursor_image->pixels[i]); + /* copy those pixels across */ + for (j = starty; + j < starty + iheight && j < ximagesrc->starty + ximagesrc->height; + j++) { + for (i = startx; + i < startx + iwidth && i < ximagesrc->startx + ximagesrc->width; + i++) { + guint8 *src, *dest; + + src = + (guint8 *) & (ximagesrc->cursor_image->pixels[((j - + cy) * ximagesrc->cursor_image->width + (i - cx))]); + dest = + (guint8 *) & (ximage->ximage->data[((j - + ximagesrc->starty) * ximagesrc->width + (i - + ximagesrc->startx)) * (ximagesrc->xcontext->bpp / + 8)]); + + composite_pixel (ximagesrc->xcontext, (guint8 *) dest, + (guint8 *) src); + } + } + } + } + } +#endif +#ifdef HAVE_XDAMAGE + if (ximagesrc->have_xdamage && ximagesrc->use_damage) { + /* need to ref ximage to put in last_ximage */ + gst_buffer_ref (GST_BUFFER (ximage)); + if (ximagesrc->last_ximage) { + gst_buffer_unref (GST_BUFFER (ximagesrc->last_ximage)); + } + ximagesrc->last_ximage = ximage; + GST_LOG_OBJECT (ximagesrc, "reffing current buffer for last_ximage"); + } +#endif + return ximage; +} + +static GstFlowReturn +gst_ximage_src_create (GstPushSrc * bs, GstBuffer ** buf) +{ + GstXImageSrc *s = GST_XIMAGE_SRC (bs); + GstXImageSrcBuffer *image; + GstClockTime base_time; + GstClockTime next_capture_ts; + GstClockTime dur; + gint64 next_frame_no; + + if (!gst_ximage_src_recalc (s)) { + GST_ELEMENT_ERROR (s, RESOURCE, FAILED, + ("Changing resolution at runtime is not yet supported."), (NULL)); + return GST_FLOW_ERROR; + } + + if (s->fps_n <= 0 || s->fps_d <= 0) + return GST_FLOW_NOT_NEGOTIATED; /* FPS must be > 0 */ + + /* Now, we might need to wait for the next multiple of the fps + * before capturing */ + + GST_OBJECT_LOCK (s); + if (GST_ELEMENT_CLOCK (s) == NULL) { + GST_OBJECT_UNLOCK (s); + GST_ELEMENT_ERROR (s, RESOURCE, FAILED, + ("Cannot operate without a clock"), (NULL)); + return GST_FLOW_ERROR; + } + + base_time = GST_ELEMENT_CAST (s)->base_time; + next_capture_ts = gst_clock_get_time (GST_ELEMENT_CLOCK (s)); + next_capture_ts -= base_time; + + /* Figure out which 'frame number' position we're at, based on the cur time + * and frame rate */ + next_frame_no = gst_util_uint64_scale (next_capture_ts, + s->fps_n, GST_SECOND * s->fps_d); + if (next_frame_no == s->last_frame_no) { + GstClockID id; + GstClockReturn ret; + + /* Need to wait for the next frame */ + next_frame_no += 1; + + /* Figure out what the next frame time is */ + next_capture_ts = gst_util_uint64_scale (next_frame_no, + s->fps_d * GST_SECOND, s->fps_n); + + id = gst_clock_new_single_shot_id (GST_ELEMENT_CLOCK (s), + next_capture_ts + base_time); + s->clock_id = id; + + /* release the object lock while waiting */ + GST_OBJECT_UNLOCK (s); + + GST_DEBUG_OBJECT (s, "Waiting for next frame time %" G_GUINT64_FORMAT, + next_capture_ts); + ret = gst_clock_id_wait (id, NULL); + GST_OBJECT_LOCK (s); + + gst_clock_id_unref (id); + s->clock_id = NULL; + if (ret == GST_CLOCK_UNSCHEDULED) { + /* Got woken up by the unlock function */ + GST_OBJECT_UNLOCK (s); + return GST_FLOW_WRONG_STATE; + } + /* Duration is a complete 1/fps frame duration */ + dur = gst_util_uint64_scale_int (GST_SECOND, s->fps_d, s->fps_n); + } else { + GstClockTime next_frame_ts; + + GST_DEBUG_OBJECT (s, "No need to wait for next frame time %" + G_GUINT64_FORMAT " next frame = %" G_GINT64_FORMAT " prev = %" + G_GINT64_FORMAT, next_capture_ts, next_frame_no, s->last_frame_no); + next_frame_ts = gst_util_uint64_scale (next_frame_no + 1, + s->fps_d * GST_SECOND, s->fps_n); + /* Frame duration is from now until the next expected capture time */ + dur = next_frame_ts - next_capture_ts; + } + s->last_frame_no = next_frame_no; + GST_OBJECT_UNLOCK (s); + + image = gst_ximage_src_ximage_get (s); + if (!image) + return GST_FLOW_ERROR; + + *buf = GST_BUFFER (image); + GST_BUFFER_TIMESTAMP (*buf) = next_capture_ts; + GST_BUFFER_DURATION (*buf) = dur; + + return GST_FLOW_OK; +} + +static void +gst_ximage_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstXImageSrc *src = GST_XIMAGE_SRC (object); + + switch (prop_id) { + case PROP_DISPLAY_NAME: + + g_free (src->display_name); + src->display_name = g_strdup (g_value_get_string (value)); + break; + case PROP_SCREEN_NUM: + src->screen_num = g_value_get_uint (value); + break; + case PROP_SHOW_POINTER: + src->show_pointer = g_value_get_boolean (value); + break; + case PROP_USE_DAMAGE: + src->use_damage = g_value_get_boolean (value); + break; + case PROP_STARTX: + src->startx = g_value_get_uint (value); + break; + case PROP_STARTY: + src->starty = g_value_get_uint (value); + break; + case PROP_ENDX: + src->endx = g_value_get_uint (value); + break; + case PROP_ENDY: + src->endy = g_value_get_uint (value); + break; + default: + break; + } +} + +static void +gst_ximage_src_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstXImageSrc *src = GST_XIMAGE_SRC (object); + + switch (prop_id) { + case PROP_DISPLAY_NAME: + if (src->xcontext) + g_value_set_string (value, DisplayString (src->xcontext->disp)); + else + g_value_set_string (value, src->display_name); + + break; + case PROP_SCREEN_NUM: + g_value_set_uint (value, src->screen_num); + break; + case PROP_SHOW_POINTER: + g_value_set_boolean (value, src->show_pointer); + break; + case PROP_USE_DAMAGE: + g_value_set_boolean (value, src->use_damage); + break; + case PROP_STARTX: + g_value_set_uint (value, src->startx); + break; + case PROP_STARTY: + g_value_set_uint (value, src->starty); + break; + case PROP_ENDX: + g_value_set_uint (value, src->endx); + break; + case PROP_ENDY: + g_value_set_uint (value, src->endy); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc) +{ + g_mutex_lock (ximagesrc->pool_lock); + while (ximagesrc->buffer_pool != NULL) { + GstXImageSrcBuffer *ximage = ximagesrc->buffer_pool->data; + + gst_ximage_buffer_free (ximage); + + ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool, + ximagesrc->buffer_pool); + } + g_mutex_unlock (ximagesrc->pool_lock); +} + +static void +gst_ximage_src_base_init (gpointer g_class) +{ + GstElementClass *ec = GST_ELEMENT_CLASS (g_class); + + gst_element_class_set_details (ec, &ximagesrc_details); + gst_element_class_add_pad_template (ec, gst_static_pad_template_get (&t)); +} + +static void +gst_ximage_src_dispose (GObject * object) +{ + /* Drop references in the buffer_pool */ + gst_ximage_src_clear_bufpool (GST_XIMAGE_SRC (object)); + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +gst_ximage_src_finalize (GObject * object) +{ + GstXImageSrc *src = GST_XIMAGE_SRC (object); + + if (src->xcontext) + ximageutil_xcontext_clear (src->xcontext); + + g_mutex_free (src->pool_lock); + g_mutex_free (src->x_lock); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static GstCaps * +gst_ximage_src_get_caps (GstBaseSrc * bs) +{ + GstXImageSrc *s = GST_XIMAGE_SRC (bs); + GstXContext *xcontext; + gint x, y, width, height; + + if ((!s->xcontext) && (!gst_ximage_src_open_display (s, s->display_name))) + return + gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC + (s)->srcpad)); + + if (!gst_ximage_src_recalc (s)) + return + gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC + (s)->srcpad)); + + xcontext = s->xcontext; + + x = y = 0; + width = xcontext->width; + height = xcontext->height; + if (s->endx > s->startx && s->endy > s->starty) { + /* this means user has put in values */ + if (s->startx < xcontext->width && s->endx < xcontext->width && + s->starty < xcontext->height && s->endy < xcontext->height) { + /* values are fine */ + x = s->startx; + y = s->starty; + s->width = width = s->endx - s->startx; + s->height = height = s->endy - s->starty; + } else { + GST_WARNING + ("User put in co-ordinates overshooting the X resolution, setting to full screen"); + s->startx = 0; + s->starty = 0; + s->endx = 0; + s->endy = 0; + } + } else { + GST_WARNING ("User put in bogus co-ordinates, setting to full screen"); + s->startx = 0; + s->starty = 0; + s->endx = 0; + s->endy = 0; + } + GST_DEBUG ("width = %d, height=%d", width, height); + return gst_caps_new_simple ("video/x-raw-rgb", + "bpp", G_TYPE_INT, xcontext->bpp, + "depth", G_TYPE_INT, xcontext->depth, + "endianness", G_TYPE_INT, xcontext->endianness, + "red_mask", G_TYPE_INT, xcontext->r_mask_output, + "green_mask", G_TYPE_INT, xcontext->g_mask_output, + "blue_mask", G_TYPE_INT, xcontext->b_mask_output, + "width", G_TYPE_INT, width, + "height", G_TYPE_INT, height, + "framerate", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, + "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, + NULL); +} + +static gboolean +gst_ximage_src_set_caps (GstBaseSrc * bs, GstCaps * caps) +{ + GstXImageSrc *s = GST_XIMAGE_SRC (bs); + GstStructure *structure; + const GValue *new_fps; + + /* If not yet opened, disallow setcaps until later */ + if (!s->xcontext) + return FALSE; + + /* The only thing that can change is the framerate downstream wants */ + structure = gst_caps_get_structure (caps, 0); + new_fps = gst_structure_get_value (structure, "framerate"); + if (!new_fps) + return FALSE; + + /* Store this FPS for use when generating buffers */ + s->fps_n = gst_value_get_fraction_numerator (new_fps); + s->fps_d = gst_value_get_fraction_denominator (new_fps); + + GST_DEBUG_OBJECT (s, "peer wants %d/%d fps", s->fps_n, s->fps_d); + + return TRUE; +} + +static void +gst_ximage_src_fixate (GstPad * pad, GstCaps * caps) +{ + gint i; + GstStructure *structure; + + for (i = 0; i < gst_caps_get_size (caps); ++i) { + structure = gst_caps_get_structure (caps, i); + + gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1); + } +} + +static void +gst_ximage_src_class_init (GstXImageSrcClass * klass) +{ + GObjectClass *gc = G_OBJECT_CLASS (klass); + GstBaseSrcClass *bc = GST_BASE_SRC_CLASS (klass); + GstPushSrcClass *push_class = GST_PUSH_SRC_CLASS (klass); + + gc->set_property = gst_ximage_src_set_property; + gc->get_property = gst_ximage_src_get_property; + gc->dispose = gst_ximage_src_dispose; + gc->finalize = gst_ximage_src_finalize; + + g_object_class_install_property (gc, PROP_DISPLAY_NAME, + g_param_spec_string ("display-name", "Display", "X Display Name", NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gc, PROP_SCREEN_NUM, + g_param_spec_uint ("screen-num", "Screen number", "X Screen Number", + 0, G_MAXINT, 0, G_PARAM_READWRITE)); + g_object_class_install_property (gc, PROP_SHOW_POINTER, + g_param_spec_boolean ("show-pointer", "Show Mouse Pointer", + "Show mouse pointer (if XFixes extension enabled)", TRUE, + G_PARAM_READWRITE)); + /** + * GstXImageSrc:use-damage + * + * Use XDamage (if the XDamage extension is enabled) + * + * Since: 0.10.4 + **/ + g_object_class_install_property (gc, PROP_USE_DAMAGE, + g_param_spec_boolean ("use-damage", "Use XDamage", + "Use XDamage (if XDamage extension enabled)", TRUE, + G_PARAM_READWRITE)); + /** + * GstXImageSrc:startx + * + * X coordinate of top left corner of area to be recorded + * (0 for top left of screen) + * + * Since: 0.10.4 + **/ + g_object_class_install_property (gc, PROP_STARTX, + g_param_spec_uint ("startx", "Start X co-ordinate", + "X coordinate of top left corner of area to be recorded (0 for top left of screen)", + 0, G_MAXINT, 0, G_PARAM_READWRITE)); + /** + * GstXImageSrc:starty + * + * Y coordinate of top left corner of area to be recorded + * (0 for top left of screen) + * + * Since: 0.10.4 + **/ + g_object_class_install_property (gc, PROP_STARTY, + g_param_spec_uint ("starty", "Start Y co-ordinate", + "Y coordinate of top left corner of area to be recorded (0 for top left of screen)", + 0, G_MAXINT, 0, G_PARAM_READWRITE)); + /** + * GstXImageSrc:endx + * + * X coordinate of bottom right corner of area to be recorded + * (0 for bottom right of screen) + * + * Since: 0.10.4 + **/ + g_object_class_install_property (gc, PROP_ENDX, + g_param_spec_uint ("endx", "End X", + "X coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)", + 0, G_MAXINT, 0, G_PARAM_READWRITE)); + /** + * GstXImageSrc:endy + * + * Y coordinate of bottom right corner of area to be recorded + * (0 for bottom right of screen) + * + * Since: 0.10.4 + **/ + g_object_class_install_property (gc, PROP_ENDY, + g_param_spec_uint ("endy", "End Y", + "Y coordinate of bottom right corner of area to be recorded (0 for bottom right of screen)", + 0, G_MAXINT, 0, G_PARAM_READWRITE)); + + parent_class = g_type_class_peek_parent (klass); + + push_class->create = gst_ximage_src_create; + bc->get_caps = gst_ximage_src_get_caps; + bc->set_caps = gst_ximage_src_set_caps; + bc->start = gst_ximage_src_start; + bc->stop = gst_ximage_src_stop; + bc->unlock = gst_ximage_src_unlock; +} + +static void +gst_ximage_src_init (GstXImageSrc * ximagesrc, GstXImageSrcClass * klass) +{ + gst_base_src_set_live (GST_BASE_SRC (ximagesrc), TRUE); + gst_pad_set_fixatecaps_function (GST_BASE_SRC_PAD (ximagesrc), + gst_ximage_src_fixate); + + ximagesrc->pool_lock = g_mutex_new (); + ximagesrc->x_lock = g_mutex_new (); + ximagesrc->show_pointer = TRUE; + ximagesrc->use_damage = TRUE; + ximagesrc->startx = 0; + ximagesrc->starty = 0; + ximagesrc->endx = 0; + ximagesrc->endy = 0; +} + +static gboolean +plugin_init (GstPlugin * plugin) +{ + gboolean ret; + + GST_DEBUG_CATEGORY_INIT (gst_debug_ximage_src, "ximagewsrc", 0, + "ximagesrc element debug"); + + ret = gst_element_register (plugin, "ximagewsrc", GST_RANK_NONE, + GST_TYPE_XIMAGE_SRC); + + return ret; +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "ximagewsrc", + "X11 video input plugin using standard Xlib calls, with added watermark and scaling", + plugin_init, VERSION, GST_LICENSE, "GStreamer private plugins", "By JP"); diff --git a/gst/gstximagesrc.h b/gst/gstximagesrc.h new file mode 100644 index 0000000..f223d1e --- /dev/null +++ b/gst/gstximagesrc.h @@ -0,0 +1,106 @@ +/* screenshotsrc: Screenshot plugin for GStreamer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GST_XIMAGE_SRC_H__ +#define __GST_XIMAGE_SRC_H__ + +#include +#include +#include "ximageutil.h" + +#ifdef HAVE_XFIXES +#include +#endif +#ifdef HAVE_XDAMAGE +#include +#endif + +G_BEGIN_DECLS + +#define GST_TYPE_XIMAGE_SRC (gst_ximage_src_get_type()) +#define GST_XIMAGE_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_XIMAGE_SRC,GstXImageSrc)) +#define GST_XIMAGE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_XIMAGE_SRC,GstXImageSrc)) +#define GST_IS_XIMAGE_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_XIMAGE_SRC)) +#define GST_IS_XIMAGE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_XIMAGE_SRC)) + +typedef struct _GstXImageSrc GstXImageSrc; +typedef struct _GstXImageSrcClass GstXImageSrcClass; + +GType gst_ximage_src_get_type (void) G_GNUC_CONST; + +struct _GstXImageSrc +{ + GstPushSrc parent; + + /* Information on display */ + GstXContext *xcontext; + gint width; + gint height; + + Window xwindow; + gchar *display_name; + guint screen_num; + + /* Desired output framerate */ + gint fps_n; + gint fps_d; + + /* for framerate sync */ + GstClockID clock_id; + gint64 last_frame_no; + + /* Protect X Windows calls */ + GMutex *x_lock; + + /* Gathered pool of emitted buffers */ + GMutex *pool_lock; + GSList *buffer_pool; + + /* XFixes and XDamage support */ + gboolean have_xfixes; + gboolean have_xdamage; + gboolean show_pointer; + gboolean use_damage; + + /* co-ordinates for start and end */ + guint startx; + guint starty; + guint endx; + guint endy; + +#ifdef HAVE_XFIXES + int fixes_event_base; + XFixesCursorImage *cursor_image; +#endif +#ifdef HAVE_XDAMAGE + Damage damage; + int damage_event_base; + XserverRegion damage_region; + GC damage_copy_gc; + GstXImageSrcBuffer *last_ximage; +#endif +}; + +struct _GstXImageSrcClass +{ + GstPushSrcClass parent_class; +}; + +G_END_DECLS + +#endif /* __GST_XIMAGE_SRC_H__ */ diff --git a/gst/ximageutil.c b/gst/ximageutil.c new file mode 100644 index 0000000..e0d2c32 --- /dev/null +++ b/gst/ximageutil.c @@ -0,0 +1,494 @@ +/* GStreamer + * Copyright (C) <2005> Luca Ognibene + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ximageutil.h" + +#ifdef HAVE_XSHM +static gboolean error_caught = FALSE; + +static int +ximageutil_handle_xerror (Display * display, XErrorEvent * xevent) +{ + char error_msg[1024]; + + XGetErrorText (display, xevent->error_code, error_msg, 1024); + GST_DEBUG ("ximageutil failed to use XShm calls. error: %s", error_msg); + error_caught = TRUE; + return 0; +} + +/* This function checks that it is actually really possible to create an image + using XShm */ +gboolean +ximageutil_check_xshm_calls (GstXContext * xcontext) +{ + XImage *ximage; + XShmSegmentInfo SHMInfo; + size_t size; + int (*handler) (Display *, XErrorEvent *); + gboolean result = FALSE; + gboolean did_attach = FALSE; + + g_return_val_if_fail (xcontext != NULL, FALSE); + + /* Sync to ensure any older errors are already processed */ + XSync (xcontext->disp, FALSE); + + /* Set defaults so we don't free these later unnecessarily */ + SHMInfo.shmaddr = ((void *) -1); + SHMInfo.shmid = -1; + + /* Setting an error handler to catch failure */ + error_caught = FALSE; + handler = XSetErrorHandler (ximageutil_handle_xerror); + + /* Trying to create a 1x1 ximage */ + GST_DEBUG ("XShmCreateImage of 1x1"); + + ximage = XShmCreateImage (xcontext->disp, xcontext->visual, + xcontext->depth, ZPixmap, NULL, &SHMInfo, 1, 1); + + /* Might cause an error, sync to ensure it is noticed */ + XSync (xcontext->disp, FALSE); + if (!ximage || error_caught) { + GST_WARNING ("could not XShmCreateImage a 1x1 image"); + goto beach; + } + size = ximage->height * ximage->bytes_per_line; + + SHMInfo.shmid = shmget (IPC_PRIVATE, size, IPC_CREAT | 0777); + if (SHMInfo.shmid == -1) { + GST_WARNING ("could not get shared memory of %" G_GSIZE_FORMAT " bytes", + size); + goto beach; + } + + SHMInfo.shmaddr = shmat (SHMInfo.shmid, 0, 0); + if (SHMInfo.shmaddr == ((void *) -1)) { + GST_WARNING ("Failed to shmat: %s", g_strerror (errno)); + goto beach; + } + + /* Delete the SHM segment. It will actually go away automatically + * when we detach now */ + shmctl (SHMInfo.shmid, IPC_RMID, 0); + + ximage->data = SHMInfo.shmaddr; + SHMInfo.readOnly = FALSE; + + if (XShmAttach (xcontext->disp, &SHMInfo) == 0) { + GST_WARNING ("Failed to XShmAttach"); + goto beach; + } + + /* Sync to ensure we see any errors we caused */ + XSync (xcontext->disp, FALSE); + + if (!error_caught) { + did_attach = TRUE; + /* store whether we succeeded in result */ + result = TRUE; + } +beach: + /* Sync to ensure we swallow any errors we caused and reset error_caught */ + XSync (xcontext->disp, FALSE); + error_caught = FALSE; + XSetErrorHandler (handler); + + if (did_attach) { + XShmDetach (xcontext->disp, &SHMInfo); + XSync (xcontext->disp, FALSE); + } + if (SHMInfo.shmaddr != ((void *) -1)) + shmdt (SHMInfo.shmaddr); + if (ximage) + XDestroyImage (ximage); + return result; +} +#endif /* HAVE_XSHM */ + +/* This function gets the X Display and global info about it. Everything is + stored in our object and will be cleaned when the object is disposed. Note + here that caps for supported format are generated without any window or + image creation */ +GstXContext * +ximageutil_xcontext_get (GstElement * parent, const gchar * display_name) +{ + GstXContext *xcontext = NULL; + XPixmapFormatValues *px_formats = NULL; + gint nb_formats = 0, i; + + xcontext = g_new0 (GstXContext, 1); + + xcontext->disp = XOpenDisplay (display_name); + GST_DEBUG_OBJECT (parent, "opened display %p", xcontext->disp); + if (!xcontext->disp) { + g_free (xcontext); + return NULL; + } + xcontext->screen = DefaultScreenOfDisplay (xcontext->disp); + xcontext->screen_num = DefaultScreen (xcontext->disp); + xcontext->visual = DefaultVisual (xcontext->disp, xcontext->screen_num); + xcontext->root = DefaultRootWindow (xcontext->disp); + xcontext->white = XWhitePixel (xcontext->disp, xcontext->screen_num); + xcontext->black = XBlackPixel (xcontext->disp, xcontext->screen_num); + xcontext->depth = DefaultDepthOfScreen (xcontext->screen); + + xcontext->width = DisplayWidth (xcontext->disp, xcontext->screen_num); + xcontext->height = DisplayHeight (xcontext->disp, xcontext->screen_num); + + xcontext->widthmm = DisplayWidthMM (xcontext->disp, xcontext->screen_num); + xcontext->heightmm = DisplayHeightMM (xcontext->disp, xcontext->screen_num); + + xcontext->caps = NULL; + + GST_DEBUG_OBJECT (parent, "X reports %dx%d pixels and %d mm x %d mm", + xcontext->width, xcontext->height, xcontext->widthmm, xcontext->heightmm); + ximageutil_calculate_pixel_aspect_ratio (xcontext); + + /* We get supported pixmap formats at supported depth */ + px_formats = XListPixmapFormats (xcontext->disp, &nb_formats); + + if (!px_formats) { + XCloseDisplay (xcontext->disp); + g_free (xcontext); + return NULL; + } + + /* We get bpp value corresponding to our running depth */ + for (i = 0; i < nb_formats; i++) { + if (px_formats[i].depth == xcontext->depth) + xcontext->bpp = px_formats[i].bits_per_pixel; + } + + XFree (px_formats); + + xcontext->endianness = + (ImageByteOrder (xcontext->disp) == + LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN; + +#ifdef HAVE_XSHM + /* Search for XShm extension support */ + if (XShmQueryExtension (xcontext->disp) && + ximageutil_check_xshm_calls (xcontext)) { + xcontext->use_xshm = TRUE; + GST_DEBUG ("ximageutil is using XShm extension"); + } else { + xcontext->use_xshm = FALSE; + GST_DEBUG ("ximageutil is not using XShm extension"); + } +#endif /* HAVE_XSHM */ + + /* our caps system handles 24/32bpp RGB as big-endian. */ + if ((xcontext->bpp == 24 || xcontext->bpp == 32) && + xcontext->endianness == G_LITTLE_ENDIAN) { + xcontext->endianness = G_BIG_ENDIAN; + xcontext->r_mask_output = GUINT32_TO_BE (xcontext->visual->red_mask); + xcontext->g_mask_output = GUINT32_TO_BE (xcontext->visual->green_mask); + xcontext->b_mask_output = GUINT32_TO_BE (xcontext->visual->blue_mask); + if (xcontext->bpp == 24) { + xcontext->r_mask_output >>= 8; + xcontext->g_mask_output >>= 8; + xcontext->b_mask_output >>= 8; + } + } else { + xcontext->r_mask_output = xcontext->visual->red_mask; + xcontext->g_mask_output = xcontext->visual->green_mask; + xcontext->b_mask_output = xcontext->visual->blue_mask; + } + + return xcontext; +} + +/* This function cleans the X context. Closing the Display and unrefing the + caps for supported formats. */ +void +ximageutil_xcontext_clear (GstXContext * xcontext) +{ + g_return_if_fail (xcontext != NULL); + + if (xcontext->caps != NULL) + gst_caps_unref (xcontext->caps); + + if (xcontext->par) { + g_value_unset (xcontext->par); + g_free (xcontext->par); + } + + XCloseDisplay (xcontext->disp); + + g_free (xcontext); +} + +/* This function calculates the pixel aspect ratio based on the properties + * in the xcontext structure and stores it there. */ +void +ximageutil_calculate_pixel_aspect_ratio (GstXContext * xcontext) +{ + gint par[][2] = { + {1, 1}, /* regular screen */ + {16, 15}, /* PAL TV */ + {11, 10}, /* 525 line Rec.601 video */ + {54, 59} /* 625 line Rec.601 video */ + }; + gint i; + gint index; + gdouble ratio; + gdouble delta; + +#define DELTA(idx) (ABS (ratio - ((gdouble) par[idx][0] / par[idx][1]))) + + /* first calculate the "real" ratio based on the X values; + * which is the "physical" w/h divided by the w/h in pixels of the display */ + ratio = (gdouble) (xcontext->widthmm * xcontext->height) + / (xcontext->heightmm * xcontext->width); + + /* DirectFB's X in 720x576 reports the physical dimensions wrong, so + * override here */ + if (xcontext->width == 720 && xcontext->height == 576) { + ratio = 4.0 * 576 / (3.0 * 720); + } + GST_DEBUG ("calculated pixel aspect ratio: %f", ratio); + + /* now find the one from par[][2] with the lowest delta to the real one */ + delta = DELTA (0); + index = 0; + + for (i = 1; i < sizeof (par) / (sizeof (gint) * 2); ++i) { + gdouble this_delta = DELTA (i); + + if (this_delta < delta) { + index = i; + delta = this_delta; + } + } + + GST_DEBUG ("Decided on index %d (%d/%d)", index, + par[index][0], par[index][1]); + + if (xcontext->par) + g_free (xcontext->par); + xcontext->par = g_new0 (GValue, 1); + g_value_init (xcontext->par, GST_TYPE_FRACTION); + gst_value_set_fraction (xcontext->par, par[index][0], par[index][1]); + GST_DEBUG ("set xcontext PAR to %d/%d\n", + gst_value_get_fraction_numerator (xcontext->par), + gst_value_get_fraction_denominator (xcontext->par)); +} + +static GstBufferClass *ximagesrc_buffer_parent_class = NULL; + +static void +gst_ximagesrc_buffer_finalize (GstXImageSrcBuffer * ximage) +{ + GstElement *parent; + + g_return_if_fail (ximage != NULL); + + parent = ximage->parent; + if (parent == NULL) { + g_warning ("XImageSrcBuffer->ximagesrc == NULL"); + goto beach; + } + + if (ximage->return_func) + ximage->return_func (parent, ximage); + +beach: + + GST_MINI_OBJECT_CLASS (ximagesrc_buffer_parent_class)-> + finalize (GST_MINI_OBJECT (ximage)); + + return; +} + +void +gst_ximage_buffer_free (GstXImageSrcBuffer * ximage) +{ + /* make sure it is not recycled */ + ximage->width = -1; + ximage->height = -1; + gst_buffer_unref (GST_BUFFER (ximage)); +} + +static void +gst_ximagesrc_buffer_init (GstXImageSrcBuffer * ximage_buffer, gpointer g_class) +{ +#ifdef HAVE_XSHM + ximage_buffer->SHMInfo.shmaddr = ((void *) -1); + ximage_buffer->SHMInfo.shmid = -1; +#endif +} + +static void +gst_ximagesrc_buffer_class_init (gpointer g_class, gpointer class_data) +{ + GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class); + + ximagesrc_buffer_parent_class = g_type_class_peek_parent (g_class); + + mini_object_class->finalize = (GstMiniObjectFinalizeFunction) + gst_ximagesrc_buffer_finalize; +} + +GType +gst_ximagesrc_buffer_get_type (void) +{ + static GType _gst_ximagesrc_buffer_type; + + if (G_UNLIKELY (_gst_ximagesrc_buffer_type == 0)) { + static const GTypeInfo ximagesrc_buffer_info = { + sizeof (GstBufferClass), + NULL, + NULL, + gst_ximagesrc_buffer_class_init, + NULL, + NULL, + sizeof (GstXImageSrcBuffer), + 0, + (GInstanceInitFunc) gst_ximagesrc_buffer_init, + NULL + }; + _gst_ximagesrc_buffer_type = g_type_register_static (GST_TYPE_BUFFER, + "GstXImageSrcBuffer", &ximagesrc_buffer_info, 0); + } + return _gst_ximagesrc_buffer_type; +} + +/* This function handles GstXImageSrcBuffer creation depending on XShm availability */ +GstXImageSrcBuffer * +gst_ximageutil_ximage_new (GstXContext * xcontext, + GstElement * parent, int width, int height, BufferReturnFunc return_func) +{ + GstXImageSrcBuffer *ximage = NULL; + gboolean succeeded = FALSE; + + ximage = + (GstXImageSrcBuffer *) gst_mini_object_new (GST_TYPE_XIMAGESRC_BUFFER); + + ximage->width = width; + ximage->height = height; + +#ifdef HAVE_XSHM + if (xcontext->use_xshm) { + ximage->ximage = XShmCreateImage (xcontext->disp, + xcontext->visual, xcontext->depth, + ZPixmap, NULL, &ximage->SHMInfo, ximage->width, ximage->height); + if (!ximage->ximage) { + goto beach; + } + + /* we have to use the returned bytes_per_line for our shm size */ + ximage->size = ximage->ximage->bytes_per_line * ximage->ximage->height; + ximage->SHMInfo.shmid = shmget (IPC_PRIVATE, ximage->size, + IPC_CREAT | 0777); + if (ximage->SHMInfo.shmid == -1) + goto beach; + + ximage->SHMInfo.shmaddr = shmat (ximage->SHMInfo.shmid, 0, 0); + if (ximage->SHMInfo.shmaddr == ((void *) -1)) + goto beach; + + /* Delete the SHM segment. It will actually go away automatically + * when we detach now */ + shmctl (ximage->SHMInfo.shmid, IPC_RMID, 0); + + ximage->ximage->data = ximage->SHMInfo.shmaddr; + ximage->SHMInfo.readOnly = FALSE; + + if (XShmAttach (xcontext->disp, &ximage->SHMInfo) == 0) + goto beach; + + XSync (xcontext->disp, FALSE); + } else +#endif /* HAVE_XSHM */ + { + ximage->ximage = XCreateImage (xcontext->disp, + xcontext->visual, + xcontext->depth, + ZPixmap, 0, NULL, ximage->width, ximage->height, xcontext->bpp, 0); + if (!ximage->ximage) + goto beach; + + /* we have to use the returned bytes_per_line for our image size */ + ximage->size = ximage->ximage->bytes_per_line * ximage->ximage->height; + ximage->ximage->data = g_malloc (ximage->size); + + XSync (xcontext->disp, FALSE); + } + succeeded = TRUE; + + GST_BUFFER_DATA (ximage) = (guchar *) ximage->ximage->data; + GST_BUFFER_SIZE (ximage) = ximage->size; + + /* Keep a ref to our src */ + ximage->parent = gst_object_ref (parent); + ximage->return_func = return_func; +beach: + if (!succeeded) { + gst_ximage_buffer_free (ximage); + ximage = NULL; + } + + return ximage; +} + +/* This function destroys a GstXImageBuffer handling XShm availability */ +void +gst_ximageutil_ximage_destroy (GstXContext * xcontext, + GstXImageSrcBuffer * ximage) +{ + /* We might have some buffers destroyed after changing state to NULL */ + if (!xcontext) + goto beach; + + g_return_if_fail (ximage != NULL); + +#ifdef HAVE_XSHM + if (xcontext->use_xshm) { + if (ximage->SHMInfo.shmaddr != ((void *) -1)) { + XShmDetach (xcontext->disp, &ximage->SHMInfo); + XSync (xcontext->disp, 0); + shmdt (ximage->SHMInfo.shmaddr); + } + if (ximage->ximage) + XDestroyImage (ximage->ximage); + + } else +#endif /* HAVE_XSHM */ + { + if (ximage->ximage) { + XDestroyImage (ximage->ximage); + } + } + + XSync (xcontext->disp, FALSE); +beach: + if (ximage->parent) { + /* Release the ref to our parent */ + gst_object_unref (ximage->parent); + ximage->parent = NULL; + } + + return; +} diff --git a/gst/ximageutil.h b/gst/ximageutil.h new file mode 100644 index 0000000..517fc8e --- /dev/null +++ b/gst/ximageutil.h @@ -0,0 +1,182 @@ +/* GStreamer + * Copyright (C) <2005> Luca Ognibene + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GST_XIMAGEUTIL_H__ +#define __GST_XIMAGEUTIL_H__ + +#include + +#ifdef HAVE_XSHM +#include +#include +#include +#endif /* HAVE_XSHM */ + +#include +#include + +#ifdef HAVE_XSHM +#include +#endif /* HAVE_XSHM */ + +#include +#include + +G_BEGIN_DECLS + +typedef struct _GstXContext GstXContext; +typedef struct _GstXWindow GstXWindow; +typedef struct _GstXImage GstXImage; +typedef struct _GstXImageSrcBuffer GstXImageSrcBuffer; + +/* Global X Context stuff */ +/** + * GstXContext: + * @disp: the X11 Display of this context + * @screen: the default Screen of Display @disp + * @screen_num: the Screen number of @screen + * @visual: the default Visual of Screen @screen + * @root: the root Window of Display @disp + * @white: the value of a white pixel on Screen @screen + * @black: the value of a black pixel on Screen @screen + * @depth: the color depth of Display @disp + * @bpp: the number of bits per pixel on Display @disp + * @endianness: the endianness of image bytes on Display @disp + * @width: the width in pixels of Display @disp + * @height: the height in pixels of Display @disp + * @widthmm: the width in millimeters of Display @disp + * @heightmm: the height in millimeters of Display @disp + * @par: the pixel aspect ratio calculated from @width, @widthmm and @height, + * @heightmm ratio + * @use_xshm: used to known wether of not XShm extension is usable or not even + * if the Extension is present + * @caps: the #GstCaps that Display @disp can accept + * + * Structure used to store various informations collected/calculated for a + * Display. + */ +struct _GstXContext { + Display *disp; + + Screen *screen; + gint screen_num; + + Visual *visual; + + Window root; + + gulong white, black; + + gint depth; + gint bpp; + gint endianness; + + gint width, height; + gint widthmm, heightmm; + + /* these are the output masks + * for buffers from ximagesrc + * and are in big endian */ + guint32 r_mask_output, g_mask_output, b_mask_output; + + GValue *par; /* calculated pixel aspect ratio */ + + gboolean use_xshm; + + GstCaps *caps; +}; + +/** + * GstXWindow: + * @win: the Window ID of this X11 window + * @width: the width in pixels of Window @win + * @height: the height in pixels of Window @win + * @internal: used to remember if Window @win was created internally or passed + * through the #GstXOverlay interface + * @gc: the Graphical Context of Window @win + * + * Structure used to store informations about a Window. + */ +struct _GstXWindow { + Window win; + gint width, height; + gboolean internal; + GC gc; +}; + +gboolean ximageutil_check_xshm_calls (GstXContext * xcontext); + +GstXContext *ximageutil_xcontext_get (GstElement *parent, + const gchar *display_name); +void ximageutil_xcontext_clear (GstXContext *xcontext); +void ximageutil_calculate_pixel_aspect_ratio (GstXContext * xcontext); + +/* custom ximagesrc buffer, copied from ximagesink */ + +/* BufferReturnFunc is called when a buffer is finalised */ +typedef void (*BufferReturnFunc) (GstElement *parent, GstXImageSrcBuffer *buf); + +/** + * GstXImageSrcBuffer: + * @parent: a reference to the element we belong to + * @ximage: the XImage of this buffer + * @width: the width in pixels of XImage @ximage + * @height: the height in pixels of XImage @ximage + * @size: the size in bytes of XImage @ximage + * + * Subclass of #GstBuffer containing additional information about an XImage. + */ +struct _GstXImageSrcBuffer { + GstBuffer buffer; + + /* Reference to the ximagesrc we belong to */ + GstElement *parent; + + XImage *ximage; + +#ifdef HAVE_XSHM + XShmSegmentInfo SHMInfo; +#endif /* HAVE_XSHM */ + + gint width, height; + size_t size; + + BufferReturnFunc return_func; +}; + + +GstXImageSrcBuffer *gst_ximageutil_ximage_new (GstXContext *xcontext, + GstElement *parent, int width, int height, BufferReturnFunc return_func); + +void gst_ximageutil_ximage_destroy (GstXContext *xcontext, + GstXImageSrcBuffer * ximage); + +/* Call to manually release a buffer */ +void gst_ximage_buffer_free (GstXImageSrcBuffer *ximage); + +#define GST_TYPE_XIMAGESRC_BUFFER (gst_ximagesrc_buffer_get_type()) +#define GST_IS_XIMAGESRC_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_XIMAGESRC_BUFFER)) +#define GST_IS_XIMAGESRC_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_XIMAGESRC_BUFFER)) +#define GST_XIMAGESRC_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_XIMAGESRC_BUFFER, GstXImageSrcBuffer)) +#define GST_XIMAGESRC_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_XIMAGESRC_BUFFER, GstXImageSrcBufferClass)) +#define GST_XIMAGESRC_BUFFER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_XIMAGESRC_BUFFER, GstXImageSrcBufferClass)) + +G_END_DECLS + +#endif /* __GST_XIMAGEUTIL_H__ */ diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..550cb282f036113fb5249c4d9bc56798c832b147 GIT binary patch literal 3382 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "item.h" + +#define LOAD_APPLET_STATUS_MENU_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE (obj, LOAD_APPLET_TYPE_STATUS_MENU_ITEM, LoadAppletStatusMenuItemPrivate)) + +struct _LoadAppletStatusMenuItemPrivate { + gulong screenshot_h; + gulong video_h; + pid_t rec_pid; + gboolean recording; + + DBusError error; + GMainLoop *loop; + DBusConnection *conn; + guint timeout; + +}; + +HD_DEFINE_PLUGIN_MODULE (LoadAppletStatusMenuItem, load_applet_status_menu_item, HD_TYPE_STATUS_MENU_ITEM) + + + +#define SHUTTER_SOUND "/usr/share/sounds/camera_snd_title_1.wav" +#define BEEP_SOUND "/usr/share/sounds/ui-default_beep.wav" +#define MAX_SSHOT_NAME_LEN 64 +static gchar *sshotfilename = NULL; +static char sshotname[MAX_SSHOT_NAME_LEN]; +static guint screenshot_delay = 20; +static guint beeps = 0; +static gint sshotn = 0; +static gint scastn = 0; +static gboolean taking = FALSE; + +#define MATCH_CAMERA_KEY "type='signal'," \ + "interface='org.freedesktop.Hal.Device'," + + +static void +load_applet_status_menu_item_class_finalize(LoadAppletStatusMenuItemClass * klass) +{ +} + +static void +load_applet_status_menu_item_dispose(GObject * object) +{ + G_OBJECT_CLASS(load_applet_status_menu_item_parent_class)->dispose(object); +} + +static void +load_applet_status_menu_item_class_init(LoadAppletStatusMenuItemClass * klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + + object_class->dispose = load_applet_status_menu_item_dispose; + + g_type_class_add_private(klass, sizeof(LoadAppletStatusMenuItemPrivate)); +} + +/* + * Get the filename for next screen-shot. Start with nr. + * + */ +static int +get_next_sshot(gint nr, const gchar *suffix) +{ + FILE *f; + gint n; + + n = nr; + f = NULL; + do { + g_snprintf (sshotname, MAX_SSHOT_NAME_LEN-1, "%s/MyDocs/.images/%s%02d.%s", getenv("HOME"), sshotfilename, n, suffix); + f = g_fopen(sshotname, "r"); + if (f) { + fclose(f); + n++; + } + } + while(f != NULL); + + return n; +} + + +/* + * Get the filename for next screen-cast. Start with nr. + * + */ +static int +get_next_scast(gint nr, const gchar *suffix) +{ + FILE *f; + gint n; + + n = nr; + f = NULL; + do { + g_snprintf (sshotname, MAX_SSHOT_NAME_LEN-1, "%s/MyDocs/.videos/%s%02d.%s", getenv("HOME"), "screencast", n, suffix); + f = g_fopen(sshotname, "r"); + if (f) { + fclose(f); + n++; + } + } + while(f != NULL); + + return n; +} + + + +/* + * Close the menu, make sure it is closed and redrawn + */ +static void +do_little_dance (void) +{ + while (gtk_events_pending()) + { + gtk_main_iteration(); + } + + usleep(1000); + sched_yield(); +} + + +/* + * Take screeshot using the root window drawable + */ +static gboolean +take_screenshot(void) +{ + int width, height; + GdkDrawable *root_window; + GdkPixbuf *pixbuf; + gboolean ret; + GError *error = NULL; + + do_little_dance(); + sshotn = get_next_sshot(sshotn, "png"); + + + root_window = gdk_get_default_root_window(); + gdk_drawable_get_size(root_window, &width, &height); + pixbuf = gdk_pixbuf_get_from_drawable(NULL, + root_window, + gdk_drawable_get_colormap (root_window), + 0, 0, + 0, 0, + width, height); + + + ret = gdk_pixbuf_save(pixbuf, sshotname, "png", &error, NULL); + g_object_unref(pixbuf); + + //DEBUG + //printf("\tSaving %s\n", sshotname); + + return FALSE; +} + + +/* + * Either beep or play shutter sound and make the screenshot + */ +static gboolean +beep_or_shoot(gpointer data) +{ + beeps++; + if (beeps >= screenshot_delay) { + hildon_play_system_sound(SHUTTER_SOUND); + take_screenshot(); + return FALSE; + } else { + hildon_play_system_sound(BEEP_SOUND); + return TRUE; + } +} + + +static DBusHandlerResult +handle_dbus_events(DBusConnection *connection, DBusMessage *msg, void *user_data) +{ + if (taking == FALSE) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + gint message_type = -1; + const gchar *interface = dbus_message_get_interface(msg); + const gchar *method = dbus_message_get_member(msg); + LoadAppletStatusMenuItem *item = (LoadAppletStatusMenuItem*)user_data; + item->priv = LOAD_APPLET_STATUS_MENU_ITEM_GET_PRIVATE (item); + + if (!(message_type = dbus_message_get_type(msg)) || !interface || !method) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + switch (message_type) { + case DBUS_MESSAGE_TYPE_SIGNAL: + if ((g_strcmp0(interface, "org.freedesktop.Hal.Device") == 0) && + (g_strcmp0(method, "PropertyModified") == 0)) { + //Camera key pressed. Take screenshot, cancel the waiting loop, remove D-Bus listener + gtk_timeout_remove(item->priv->timeout); + taking = FALSE; + hildon_play_system_sound(SHUTTER_SOUND); + take_screenshot(); + dbus_bus_remove_match(item->priv->conn, MATCH_CAMERA_KEY, &item->priv->error); + dbus_connection_unref(item->priv->conn); + item->priv->conn = 0; + g_main_loop_unref(item->priv->loop); + item->priv->loop = NULL; + } + break; + default: + break; + } + return DBUS_HANDLER_RESULT_HANDLED; +} + + +#ifdef SHOW_PROCESS_INFO +/* + * Show the details dialog (FAKE) + * + */ +static void +activate_status_item(GtkMenuItem *item, gpointer data) +{ + GtkWidget *dialog; + GtkWidget *selector; + GtkWidget *content_area; + gint i; + + dialog = gtk_dialog_new(); + + selector = hildon_touch_selector_new_text (); + hildon_touch_selector_set_column_selection_mode (HILDON_TOUCH_SELECTOR (selector),HILDON_TOUCH_SELECTOR_SELECTION_MODE_SINGLE); + + for (i = 1; i <= 10 ; i++) { + gchar *label = g_strdup_printf ("Item %d", i); + hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector), label); + g_free (label); + } + + hildon_touch_selector_unselect_all(HILDON_TOUCH_SELECTOR (selector), 0); + + content_area = GTK_DIALOG(dialog)->vbox; + gtk_container_add(GTK_CONTAINER(content_area), selector); + gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 480); + + gtk_window_set_title(GTK_WINDOW(dialog), "Select process to kill - FAKE FEATURE"); + gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); + gtk_dialog_add_button(GTK_DIALOG(dialog), "Kill it", 1); + + gtk_widget_show_all(GTK_WIDGET(dialog)); + //gtk_dialog_run(GTK_DIALOG(dialog)); <- blocks and won't close status menu +} +#endif + + + +/* + * Answer the callback by setting delayed screenshot + */ +static void +activate_delayed_screenshot_item(GtkMenuItem *item, gpointer data) +{ + if (taking) + return; + + LoadAppletStatusMenuItem *menu_item = (LoadAppletStatusMenuItem*)data; + menu_item->priv = LOAD_APPLET_STATUS_MENU_ITEM_GET_PRIVATE (menu_item); + + hildon_banner_show_information(NULL, NULL, "You have 20s to press the camera capture key to take screenshot."); + beeps = 0; + taking = TRUE; + menu_item->priv->timeout = gtk_timeout_add(1000, beep_or_shoot, NULL); + + menu_item->priv->loop = g_main_loop_new(NULL, FALSE); + dbus_error_init(&menu_item->priv->error); + if ((menu_item->priv->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &menu_item->priv->error)) == NULL) { + DLOG_CRIT("LA:Failed to open connection to system bus"); + dbus_error_free(&menu_item->priv->error); + return; + } + if (!dbus_connection_add_filter(menu_item->priv->conn, handle_dbus_events, (void *)data, 0)) { + ULOG_CRIT("LA:Failed to add dbus filter"); + dbus_error_free(&menu_item->priv->error); + return; + } + dbus_bus_add_match(menu_item->priv->conn, MATCH_CAMERA_KEY, &menu_item->priv->error); + if (dbus_error_is_set(&menu_item->priv->error)) { + ULOG_WARN("LA:Unable to add match for my key"); + dbus_error_free(&menu_item->priv->error); + } + dbus_connection_setup_with_g_main(menu_item->priv->conn, NULL); +} + + +/* + * Answer the callback on video button + * If idle, start recording + * If already recording, stop + */ +static void +activate_video_item(GtkMenuItem *item, gpointer data) +{ + LoadAppletStatusMenuItem *la_item = (LoadAppletStatusMenuItem*)data; + pid_t rec_pid; + gchar *savefile; + + if (la_item->priv->recording == FALSE) { + // We are not recording. Start recording by exec + scastn = get_next_scast(scastn, "avi"); + savefile = g_strdup_printf("location=%s", sshotname); + rec_pid = fork(); + if (rec_pid == 0) { + execl("/usr/bin/gst-launch", "/usr/bin/gst-launch", "ximagewsrc", "!", "video/x-raw-rgb,framerate=5/1", "!", "ffmpegcolorspace", "!", "jpegenc", "quality=30", "!", "queue", "!", "mux.", "autoaudiosrc", "!", "audioconvert", "!", "audioresample", "!", "queue", "!", "mux.", "avimux", "name=mux", "!", "filesink", savefile, NULL); + exit(0); + } else { + la_item->priv->recording = TRUE; + la_item->priv->rec_pid = rec_pid; + } + } else { + // We are already recording + kill(la_item->priv->rec_pid, SIGTERM); + la_item->priv->recording = FALSE; + } +} + + + + +static void +load_applet_status_menu_item_init (LoadAppletStatusMenuItem * menu_item) +{ + #define ICON_DIR "/usr/share/pixmaps/" + #define ICON_VIDEO ICON_DIR"la_video.png" + #define ICON_PICTURE ICON_DIR"la_picture.png" + #define ICON_PROCESS ICON_DIR"la_process.png" + + GtkWidget *hbox, *icon, *b; + + menu_item->priv = LOAD_APPLET_STATUS_MENU_ITEM_GET_PRIVATE (menu_item); + + hbox = gtk_hbox_new(FALSE, 0); + + sshotfilename = g_strdup("screenshot"); + +#ifdef SHOW_PROCESS_INFO + // Button status + b = hildon_button_new(HILDON_SIZE_FINGER_HEIGHT, HILDON_BUTTON_ARRANGEMENT_VERTICAL); + hildon_button_set_style(HILDON_BUTTON(b), HILDON_BUTTON_STYLE_PICKER); + gtk_widget_show(b); + icon = gtk_image_new_from_file(ICON_PROCESS); + gtk_widget_show(icon); + gtk_button_set_image(GTK_BUTTON(b), GTK_WIDGET(icon)); + gtk_box_pack_start(GTK_BOX(hbox), b, TRUE, TRUE, 1); + g_signal_connect(b, "clicked", G_CALLBACK(activate_status_item), menu_item); +#endif + // Button Video + b = gtk_toggle_button_new(); + gtk_widget_show(b); + icon = gtk_image_new_from_file(ICON_VIDEO); + gtk_widget_show(icon); + gtk_button_set_image(GTK_BUTTON(b), GTK_WIDGET(icon)); + gtk_box_pack_start(GTK_BOX(hbox), b, TRUE, TRUE, 1); + menu_item->priv->screenshot_h = g_signal_connect(b, "clicked", G_CALLBACK(activate_video_item), menu_item); + // Button Picture + b = hildon_button_new(HILDON_SIZE_FINGER_HEIGHT, HILDON_BUTTON_ARRANGEMENT_VERTICAL); + gtk_widget_show(b); + icon = gtk_image_new_from_file(ICON_PICTURE); + gtk_widget_show(icon); + gtk_button_set_image(GTK_BUTTON(b), GTK_WIDGET(icon)); + gtk_box_pack_start(GTK_BOX(hbox), b, TRUE, TRUE, 1); + menu_item->priv->screenshot_h = g_signal_connect(b, "clicked", G_CALLBACK(activate_delayed_screenshot_item), menu_item); + + // Pack widgets to menu + gtk_widget_show(hbox); + gtk_container_add(GTK_CONTAINER(menu_item), hbox); + gtk_widget_show(GTK_WIDGET(menu_item)); + + // More init + menu_item->priv->recording = FALSE; +} + + + diff --git a/src/item.h b/src/item.h new file mode 100644 index 0000000..2defba7 --- /dev/null +++ b/src/item.h @@ -0,0 +1,34 @@ +#ifndef __LOAD_APPLET_STATUS_MENU_ITEM_H__ +#define __LOAD_APPLET_STATUS_MENU_ITEM_H__ + +#include + +G_BEGIN_DECLS +#define LOAD_APPLET_TYPE_STATUS_MENU_ITEM (load_applet_status_menu_item_get_type ()) +#define LOAD_APPLET_STATUS_MENU_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LOAD_APPLET_TYPE_STATUS_MENU_ITEM, LoadAppletStatusMenuItem)) +#define LOAD_APPLET_STATUS_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), LOAD_APPLET_TYPE_STATUS_MENU_ITEM, LoadAppletStatusMenuItemClass)) +#define LOAD_APPLET_IS_STATUS_MENU_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LOAD_APPLET_TYPE_STATUS_MENU_ITEM)) +#define LOAD_APPLET_IS_STATUS_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), LOAD_APPLET_TYPE_STATUS_MENU_ITEM)) +#define LOAD_APPLET_STATUS_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), LOAD_APPLET_TYPE_STATUS_MENU_ITEM, LoadAppletStatusMenuItemClass)) +typedef struct _LoadAppletStatusMenuItem LoadAppletStatusMenuItem; + +typedef struct _LoadAppletStatusMenuItemClass + LoadAppletStatusMenuItemClass; + +typedef struct _LoadAppletStatusMenuItemPrivate + LoadAppletStatusMenuItemPrivate; + +struct _LoadAppletStatusMenuItem { + HDStatusMenuItem parent; + + LoadAppletStatusMenuItemPrivate *priv; +}; + +struct _LoadAppletStatusMenuItemClass { + HDStatusMenuItemClass parent; +}; + +GType load_applet_status_menu_item_get_type (void); + +G_END_DECLS +#endif diff --git a/src/la_status_area_item.c b/src/la_status_area_item.c new file mode 100644 index 0000000..e1e1ff3 --- /dev/null +++ b/src/la_status_area_item.c @@ -0,0 +1,348 @@ +/* + * Load applet - Maemo5 edition - status area plugin + */ + + +#include +#include +#include +#include +#include +#include + +#include "la_status_area_item.h" + +#define LA_ICON_WIDTH 16 +#define LA_ICON_HEIGHT 16 +#define LA_BOX_WIDTH 5 +#define LA_BOX_HEIGHT 3 +#define LA_CPU_MAX 5 + + + +#define LOAD_APPLET_STATUS_AREA_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE (obj, LOAD_APPLET_TYPE_STATUS_AREA_ITEM, LoadAppletStatusAreaItemPrivate)) + +struct _LoadAppletStatusAreaItemPrivate { + guint timeout_id; + gint lastU, lastN, lastIO, lastI; + guchar last_mem_level; + guchar last_cpu_level; + GdkPixbuf *pixbuf; + GdkPixbuf *pixbuf_on; + GdkPixbuf *pixbuf_red; + GdkPixbuf *pixbuf_off; + osso_context_t *osso; + gboolean red; +}; + +HD_DEFINE_PLUGIN_MODULE (LoadAppletStatusAreaItem, load_applet_status_area_item, HD_TYPE_STATUS_PLUGIN_ITEM); + + +/* + * Read current MEM usage and return indicator between 5 and 1 - how many bars are "full" + */ +static guchar +la_check_mem (LoadAppletStatusAreaItemPrivate *priv) +{ + #define MEMFILE "/proc/meminfo" + #define MAX_READ_CHARS 128 + char read_buffer[MAX_READ_CHARS]; + FILE *fin; + int mem_used = 0; + int mem_total = 0; + int mem_cached = 0; + int mem_buffers = 0; + int mem_free = 0; + + //Open the memory info file and get current free memory + fin = fopen(MEMFILE, "r"); + if (fin == NULL) { + g_warning("Can't open "MEMFILE"\n"); + return TRUE; + } + while (fgets(read_buffer, MAX_READ_CHARS, fin) != NULL) { + if (strncmp(read_buffer, "MemTotal", 8) == 0) { + sscanf(read_buffer + 10, "%d", &mem_total); + } else if (strncmp(read_buffer, "MemFree", 6) == 0) { + sscanf(read_buffer + 9, "%d", &mem_free); + } else if (strncmp(read_buffer, "Buffers", 6) == 0) { + sscanf(read_buffer + 9, "%d", &mem_buffers); + } else if (strncmp(read_buffer, "Cached", 6) == 0) { + sscanf(read_buffer + 8, "%d", &mem_cached); + break; + } + } + fclose(fin); + + mem_used = mem_total - mem_free - mem_buffers - mem_cached; + + if (mem_used > 0.9*mem_total) + return 5; + else if (mem_used > 0.7*mem_total) + return 4; + else if (mem_used > 0.5*mem_total) + return 3; + else if (mem_used > 0.3*mem_total) + return 2; + else + return 1; +} + + +/* + * Read current CPU usage and return indicator between 5 and 1 - how many bars are "full" + */ +static guchar +la_check_cpu (LoadAppletStatusAreaItemPrivate *priv) +{ + #define CPUFILE "/proc/stat" + gint curU, curN, curIO, curI; + gint deltaU, deltaN, deltaIO, deltaI; + int load, idle; + GError *error = NULL; + gchar *contents; + gsize lenght; + gchar **splits; + + if (!g_file_get_contents (CPUFILE, &contents, &lenght, &error)) { + fprintf (stderr, "ERR: can't read file %s: %s\n", CPUFILE, error->message); + g_error_free (error); + return 0; + } + + splits = g_strsplit_set (contents, " ", -1); + + sscanf(splits[2], "%d", &curU); + sscanf(splits[3], "%d", &curN); + sscanf(splits[4], "%d", &curIO); + sscanf(splits[5], "%d", &curI); + + g_strfreev (splits); + g_free (contents); + + idle = (curI - priv->lastI); + if (idle == 0) load = 100; + else load = 100-idle; + if (load>100) load = 0; + deltaU = curU - priv->lastU; + deltaN = curN - priv->lastN; + deltaIO = curIO - priv->lastIO; + deltaI = curI - priv->lastI; + priv->lastU = curU; + priv->lastN = curN; + priv->lastIO = curIO; + priv->lastI = curI; + + if (load > 90) + return 5; + else if (load > 70) + return 4; + else if (load > 45) + return 3; + else if (load > 19) + return 2; + else + return 1; +} + + + +/* + * Compose and blit the current status of memory bars + */ +static void +la_blit_memory_bars (const guchar level, LoadAppletStatusAreaItemPrivate *priv) +{ + guint x, y; + + gdk_pixbuf_fill(priv->pixbuf, 0x00000000); + + x = 9; + y = 1; + if (level > 4) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + y = 5; + if (level > 3) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + y = 9; + if (level > 2) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + y = 13; + if (level > 1) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + else + gdk_pixbuf_composite(priv->pixbuf_off, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); +} + + +/* + * Compose and blit current status of CPU bars + */ +static void +la_blit_cpu_bars (const guchar level, LoadAppletStatusAreaItemPrivate *priv) +{ + guint x, y; + + x = 2; + y = 1; + if (level > 4) + { + if (priv->red == TRUE) { + gdk_pixbuf_composite(priv->pixbuf_red, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + priv->red = FALSE; + } else { + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + priv->red = TRUE; + } + } + y = 5; + if (level > 3) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + y = 9; + if (level > 2) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + y = 13; + if (level > 1) + gdk_pixbuf_composite(priv->pixbuf_on, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); + else + gdk_pixbuf_composite(priv->pixbuf_off, priv->pixbuf, x, y, LA_BOX_WIDTH, LA_BOX_HEIGHT, x, y, 1, 1, GDK_INTERP_NEAREST, 255); +} + + +/* + * Ran to check and update the CPU and memory reading + */ +static gboolean +la_check_load (gpointer data) +{ + guchar current_cpu_level; + guchar current_mem_level; + LoadAppletStatusAreaItem *item = (LoadAppletStatusAreaItem*)data; + LoadAppletStatusAreaItemPrivate *priv = (LoadAppletStatusAreaItemPrivate*)item->priv; + + current_cpu_level = la_check_cpu(priv); + current_mem_level = la_check_mem(priv); + //g_debug(g_strdup_printf("LOADAPLET - UPDATED CPU %d MEM %d", current_cpu_level, current_mem_level)); + + //Update and blit only if data changed! + if ((current_mem_level != priv->last_mem_level) || (current_cpu_level != priv->last_cpu_level)) { + la_blit_memory_bars (current_mem_level, priv); + la_blit_cpu_bars (current_cpu_level, priv); + if (current_cpu_level == LA_CPU_MAX) + priv->red = FALSE; + hd_status_plugin_item_set_status_area_icon (HD_STATUS_PLUGIN_ITEM(data), priv->pixbuf); + priv->last_mem_level = current_mem_level; + priv->last_cpu_level = current_cpu_level; + } else if (current_cpu_level == LA_CPU_MAX) { + //Pulsate max CPU load icon also when CPU load stays at max + la_blit_cpu_bars (current_cpu_level, priv); + hd_status_plugin_item_set_status_area_icon (HD_STATUS_PLUGIN_ITEM(data), priv->pixbuf); + } + + return TRUE; +} + +/* + * Get callback when display state changes + */ +static void +load_applet_status_area_item_display_cb(osso_display_state_t state, gpointer user_data) +{ + LoadAppletStatusAreaItem *item = LOAD_APPLET_STATUS_AREA_ITEM(user_data); + + g_return_if_fail (item != NULL && item->priv != NULL); + + if (state == OSSO_DISPLAY_ON) + { + //Restart the updates, do one right away + if (item->priv->timeout_id == -1) + { + //g_debug("LOADAPPLET - restarting periodic updates"); + item->priv->timeout_id = gtk_timeout_add(1000, la_check_load, item); + } + } else { + //Suspend the updates - screen is off + //g_debug("LOADAPPLET - Turning updates off"); + if (g_source_remove(item->priv->timeout_id) != TRUE) + { + //g_error("LOADAPPLET - couldn't stop the updates!the timer still running ..."); + } else { + item->priv->timeout_id = -1; + } + } +} + + +/***************************************************************************** + * + * Boilerplate code area - do not enter + * + *****************************************************************************/ + +static void +load_applet_status_area_item_set_area_icon (LoadAppletStatusAreaItem *item) +{ + item->priv = LOAD_APPLET_STATUS_AREA_ITEM_GET_PRIVATE (item); + + hd_status_plugin_item_set_status_area_icon (HD_STATUS_PLUGIN_ITEM(item), item->priv->pixbuf); +} + + +static void +load_applet_status_area_item_class_finalize (LoadAppletStatusAreaItemClass *klass) +{ +} + + + +static void +load_applet_status_area_item_finalize (GObject *object) +{ + LoadAppletStatusAreaItemPrivate *priv = LOAD_APPLET_STATUS_AREA_ITEM(object)->priv; + // Release and clean our stuff + G_OBJECT_CLASS (load_applet_status_area_item_parent_class)->finalize (object); + if (priv->osso) + { + osso_deinitialize(priv->osso); + priv->osso = NULL; + } + +} + + + +static void +load_applet_status_area_item_class_init (LoadAppletStatusAreaItemClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = load_applet_status_area_item_finalize; + + g_type_class_add_private (klass, sizeof (LoadAppletStatusAreaItemPrivate)); + +} + +static void +load_applet_status_area_item_init (LoadAppletStatusAreaItem *item) +{ + item->priv = LOAD_APPLET_STATUS_AREA_ITEM_GET_PRIVATE (item); + + item->priv->last_mem_level = -1; + item->priv->last_cpu_level = -1; + item->priv->timeout_id = -1; + item->priv->red = FALSE; + item->priv->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, LA_ICON_WIDTH, LA_ICON_HEIGHT); + gdk_pixbuf_fill(item->priv->pixbuf, 0x00000000); + item->priv->pixbuf_on = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, LA_BOX_WIDTH, LA_BOX_HEIGHT); + gdk_pixbuf_fill(item->priv->pixbuf_on, 0xffffffff); + item->priv->pixbuf_red = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, LA_BOX_WIDTH, LA_BOX_HEIGHT); + gdk_pixbuf_fill(item->priv->pixbuf_red, 0xff0000ff); + item->priv->pixbuf_off = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, LA_BOX_WIDTH, LA_BOX_HEIGHT); + gdk_pixbuf_fill(item->priv->pixbuf_off, 0x777777ff); + load_applet_status_area_item_set_area_icon(item); + + item->priv->osso = osso_initialize ("load_applet_status_area_item", "Maemo5", TRUE, NULL); + item->priv->timeout_id = gtk_timeout_add(1000, la_check_load, item); + osso_hw_set_display_event_cb (item->priv->osso, load_applet_status_area_item_display_cb, item); +} + diff --git a/src/la_status_area_item.h b/src/la_status_area_item.h new file mode 100644 index 0000000..f95b19d --- /dev/null +++ b/src/la_status_area_item.h @@ -0,0 +1,33 @@ +#ifndef __LOAD_APPLET_STATUS_AREA_ITEM_H__ +#define __LOAD_APPLET_STATUS_AREA_ITEM_H__ + +#include + +G_BEGIN_DECLS + +#define LOAD_APPLET_TYPE_STATUS_AREA_ITEM (load_applet_status_area_item_get_type ()) +#define LOAD_APPLET_STATUS_AREA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LOAD_APPLET_TYPE_STATUS_AREA_ITEM, LoadAppletStatusAreaItem)) +#define LOAD_APPLET_STATUS_AREA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), LOAD_APPLET_TYPE_STATUS_AREA_ITEM, LoadAppletStatusAreaItemClass)) +#define LOAD_APPLET_IS_STATUS_AREA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LOAD_APPLET_TYPE_STATUS_AREA_ITEM)) +#define LOAD_APPLET_IS_STATUS_AREA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), LOAD_APPLET_TYPE_STATUS_AREA_ITEM)) +#define LOAD_APPLET_STATUS_AREA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), LOAD_APPLET_TYPE_STATUS_AREA_ITEM, LoadAppletStatusAreaItemClass)) + +typedef struct _LoadAppletStatusAreaItem LoadAppletStatusAreaItem; +typedef struct _LoadAppletStatusAreaItemClass LoadAppletStatusAreaItemClass; +typedef struct _LoadAppletStatusAreaItemPrivate LoadAppletStatusAreaItemPrivate; + +struct _LoadAppletStatusAreaItem { + HDStatusPluginItem parent; + + LoadAppletStatusAreaItemPrivate *priv; +}; + +struct _LoadAppletStatusAreaItemClass { + HDStatusPluginItemClass parent; +}; + +GType load_applet_status_area_item_get_type (void); + +G_END_DECLS + +#endif -- 1.7.9.5