From e28a07fba67af0af818dda6afa4cf67c09700816 Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Fri, 16 Dec 2005 00:53:00 +0000 Subject: checking in pdp 0.12.4 from http://zwizwa.fartit.com/pd/pdp/pdp-0.12.4.tar.gz svn path=/trunk/externals/pdp/; revision=4231 --- CHANGES.LOG | 161 ++ COPYING | 340 +++ README | 267 ++ TAGS | 2617 ++++++++++++++++++ TODO | 93 + abstractions/pdp_affine.pd | 15 + abstractions/pdp_agc.pd | 28 + abstractions/pdp_blur.pd | 27 + abstractions/pdp_blur_hor.pd | 27 + abstractions/pdp_blur_ver.pd | 27 + abstractions/pdp_cheby3o.pd | 22 + abstractions/pdp_contrast.pd | 41 + abstractions/pdp_conv_alledge.pd | 28 + abstractions/pdp_conv_emboss.pd | 37 + abstractions/pdp_conv_smooth.pd | 14 + abstractions/pdp_conv_sobel_edge.pd | 21 + abstractions/pdp_conv_sobel_hor.pd | 15 + abstractions/pdp_conv_sobel_ver.pd | 16 + abstractions/pdp_diff.pd | 14 + abstractions/pdp_dither.pd | 30 + abstractions/pdp_gain3.pd | 27 + abstractions/pdp_gradient.pd | 58 + abstractions/pdp_grey.pd | 7 + abstractions/pdp_invert.pd | 18 + abstractions/pdp_m_inverse.pd | 11 + abstractions/pdp_motion_blur.pd | 14 + abstractions/pdp_motion_fade.pd | 19 + abstractions/pdp_motion_phase.pd | 14 + abstractions/pdp_offset.pd | 17 + abstractions/pdp_phase.pd | 70 + abstractions/pdp_phase_hor.pd | 41 + abstractions/pdp_phase_ver.pd | 41 + abstractions/pdp_png_to.pd | 21 + abstractions/pdp_pps.pd | 18 + abstractions/pdp_qt_control.pd | 147 + abstractions/pdp_qtloop2~.pd | 190 ++ abstractions/pdp_qtloop~.pd | 183 ++ abstractions/pdp_saturation.pd | 18 + abstractions/pdp_save_png_sequence.pd | 28 + abstractions/pdp_sub.pd | 8 + abstractions/pdp_tag.pd | 19 + abstractions/pdp_xv_keycursor.pd | 77 + abstractions/rgb2ycrcb.pd | 7 + bin/pdp-config | 39 + bin/pdp-config.in | 39 + buildall | 18 + configure | 4827 +++++++++++++++++++++++++++++++++ configure.ac | 272 ++ debug/c++test.cc | 4 + debug/quicktime_crashtest.pd | 164 ++ debug/teststuff.c | 29 + doc/misc/devdoc.html | 167 ++ doc/misc/layers.txt | 222 ++ doc/misc/overview.html | 102 + doc/misc/todo.jme | 4 + doc/reference.txt | 156 ++ 56 files changed, 10936 insertions(+) create mode 100644 CHANGES.LOG create mode 100644 COPYING create mode 100644 README create mode 100644 TAGS create mode 100644 TODO create mode 100644 abstractions/pdp_affine.pd create mode 100644 abstractions/pdp_agc.pd create mode 100644 abstractions/pdp_blur.pd create mode 100644 abstractions/pdp_blur_hor.pd create mode 100644 abstractions/pdp_blur_ver.pd create mode 100644 abstractions/pdp_cheby3o.pd create mode 100644 abstractions/pdp_contrast.pd create mode 100644 abstractions/pdp_conv_alledge.pd create mode 100644 abstractions/pdp_conv_emboss.pd create mode 100644 abstractions/pdp_conv_smooth.pd create mode 100644 abstractions/pdp_conv_sobel_edge.pd create mode 100644 abstractions/pdp_conv_sobel_hor.pd create mode 100644 abstractions/pdp_conv_sobel_ver.pd create mode 100644 abstractions/pdp_diff.pd create mode 100644 abstractions/pdp_dither.pd create mode 100644 abstractions/pdp_gain3.pd create mode 100644 abstractions/pdp_gradient.pd create mode 100644 abstractions/pdp_grey.pd create mode 100644 abstractions/pdp_invert.pd create mode 100644 abstractions/pdp_m_inverse.pd create mode 100644 abstractions/pdp_motion_blur.pd create mode 100644 abstractions/pdp_motion_fade.pd create mode 100644 abstractions/pdp_motion_phase.pd create mode 100644 abstractions/pdp_offset.pd create mode 100644 abstractions/pdp_phase.pd create mode 100644 abstractions/pdp_phase_hor.pd create mode 100644 abstractions/pdp_phase_ver.pd create mode 100644 abstractions/pdp_png_to.pd create mode 100644 abstractions/pdp_pps.pd create mode 100644 abstractions/pdp_qt_control.pd create mode 100644 abstractions/pdp_qtloop2~.pd create mode 100644 abstractions/pdp_qtloop~.pd create mode 100644 abstractions/pdp_saturation.pd create mode 100644 abstractions/pdp_save_png_sequence.pd create mode 100644 abstractions/pdp_sub.pd create mode 100644 abstractions/pdp_tag.pd create mode 100644 abstractions/pdp_xv_keycursor.pd create mode 100644 abstractions/rgb2ycrcb.pd create mode 100644 bin/pdp-config create mode 100755 bin/pdp-config.in create mode 100755 buildall create mode 100755 configure create mode 100644 configure.ac create mode 100644 debug/c++test.cc create mode 100644 debug/quicktime_crashtest.pd create mode 100644 debug/teststuff.c create mode 100644 doc/misc/devdoc.html create mode 100644 doc/misc/layers.txt create mode 100644 doc/misc/overview.html create mode 100644 doc/misc/todo.jme create mode 100644 doc/reference.txt diff --git a/CHANGES.LOG b/CHANGES.LOG new file mode 100644 index 0000000..976955c --- /dev/null +++ b/CHANGES.LOG @@ -0,0 +1,161 @@ +last modified: 2003/02/27 + + +ChangeLog: + +v0.1: 2002/11/23 + initial release + +v0.2: 2002/11/27 + added support for BC_YUV422 video and audio playback in pdp_qt / + pdp_qt~ (thanks to Yves Degoyon for contrib) + some makefile cleanups + +v0.3: 2002/11/28 + pdp_qt / pdp_qt~: fixed some bugs in audio playback and added + suport for BC_RGB888 colormodel (loads as greyscale until there + is internal support for a rgb image packet) + +v0.4: 2002/12/03 + code style changes + added scaf / cellular automata support. + added some basic filter abstractions. (blur, phase) + +v0.5: 2002/12/13 + first attempt at a documentation (see doc/) + added support for processing in separate lower priority thread + with a packet dropping mechanism to avoid audio dropouts. + added pdp_control object for controlling pdp's scheduling and + detecting packet drops + pdp api cleanup (name changes) + added some more filter abstractions + (motion blur/phase, emboss, sobel, edge) + added pdp_route + +v0.6: 2003/01/03 + added pdp_gain, finished pdp_gradient + added channel method to pdp_v4l, display method to pdp_xv + added some examples in doc/examples + fixed gcc3 compilation probs + fixed some pdp_qt bugs (shouldn't crash any more) + +v0.7: 2003/01/12 + moved image format conversion routines to pdp_llconv.c + added support for rgb->PDP_IMAGE_YV12 in pdp_v4l, pdp_qt + added pdp_grey, pdp_chrot, pdp_scope~ + moved mmx wrappers to pdp_imageproc_mmx.c + added portable c code in pdp_imageproc_portable.c + added mmx code for pdp_gain + fixed bug in pdp_mix/pdp_mix2 + fixed bug in pdp_bq (removed state reset) + moved CA stuff to separate lib (see scaf/) + (0.7.1) fixed rgb colour conversion bug + +v0.8: 2003/02/02 + added pdp_scale, pdp_zoom, pdp_rotate, pdp_zrot, pdp_scan~, pdp_cheby + added support for 1D ca's + shift compensation in pdp_ca + thread processing is off by default now + added cursor method to pdp_xv, freq method to pdp_v4l (thanks CK) + added pdp_sdl (thanks Martin Pi) + added some example patches in doc/examples + (0.8.1) fixed scaf + gcc<3 compilation problem + (0.8.2) fixed compile prob + added documentation + (0.8.3) completed documentation + +v0.9: 2003/02/27 + added pdp_scanxy~, pdp_invert + now uses autoconf for configuration + standard "make install" target + optional compililation for external dependencies (xv,qt,v4l,sdl) + experimental OSX port (without i/o) + fixed crash when closing xv window manually + added mouse event output to pdp_xv + pdp_ca now automaticly compiles rule files + fixed image dimension crashes + fixed pdp_xv bang crash + added pdp_grey2mask + added pdp_slice_cut/pdp_slice_glue (experimental/nondoc) + +v0.10: 2003/03/06 + modules code reorganization + removed pdp_affine object and added compatibility object based on pdp_cheby + added pdp_mchp and PDP_IMAGE_MCHP packet format (experimental) + added pdp_and, pdp_or, pdp_xor, pdp_not, pdp_bitmask, pdp_bitdepth + added base class for pdp objects + added incremental garbage collector + added support for "not so pure" data packets + added opengl subproject containing a pdp_glx display object + added a PDP_TEX opengl texture packet (opengl lib) + added PDP_IMAGE_GREY8, PDP_IMAGE_RGB8, PDP_IMAGE_RGBA8 packets + (0.10.1) fixed (fatal) bug in pdp_base, and bug in pdp_noise (non-mmx) + (0.10.1) pdp_glx now compiles on mac osx + +v0.11: 2003/04/08 + updated pdp_trigger to behave like pd's trigger object + added automatic philips web cam detection + removed "zombie" packet passing and made pool manager thread safe + (this required an api change: backward compat for pdp thread proc broken) + added gem style object rendering & transformation objects (opengl lib) + removed pdp_gradient binary module (it is now an abstraction) + added pdp_loop (a packet array / loop sampler) + added pdp_description + added support for libquicktime on osx (thanks Jamie) + added support for accumulation packets (dpd) (still experimental) + (0.11.1) fixed some packet registering and frame dropping bugs + +v0.12: 2003/06/21 + added support for high level packet conversion (mime-like descriptions) + added pdp_convert + added "memlimit" message to pdp_control (to limit pdp's mem usage) + maximum nb of packets is now only limited by the memlimit + added new basic type: bitmap/*/* (PDP_BITMAP) for standard fourcc formats + cleaned up pdp_xv/glx (x window glue code reuse) + fixed rgb/bgr bug in conversion code + added pdp_abs, pdp_zthresh + completed dpd framework (for context based processing, i.e. 3dp) + rewrote gem like 3d library on top of dpd (it's almost stable) + added a matrix type (float/double real/complex) for linear algebra stuff + added matrix processors pdp_m_*: mv, mm, +=mm, LU, LU_inverse, LU_solve + pdp_cheby now accepts an array with a mapping function + added pdp_plasma + fixed outlet_pdp bug (this caused all kind of weirdness) + added embedded scheme interpreter for testing (see the guile/ dir) + added simple forth-style scripting language (pdp's rpn calculator) + added png load/save support to pdp_reg + (0.12.1) fixed OSX compilation probs + (0.12.1) fixed texture coordinate bugs (pdp_opengl) + (0.12.1) added multipass rendering support (pdp_opengl) + (0.12.1) pdp_cog (Johannes Taelman's gaussian blob estimator) + (0.12.1) pdp_sthresh, hthresh, positive, offset, sign + (0.12.1) pdp_agc, contrast, flip_lr, flip_tb + (0.12.1) added pdp and pdp_opengl examples + (0.12.2) pdp_histo, dither, pointcloud + (0.12.2) more examples & added some conversion code + (0.12.2) fixed c++ compilation issues + +0.12.3: 2004/01/13 + various bug fixes + added pdp_grey2array + fixed window event routing problem (3dp) + cleaned up source tree (for libpdp) + added pdp_netsend / pdp_netreceive to send packets over udp (experimental) + more forth scripting stuff + added "norm" message and rgb32 colour model to pdp_v4l + added keyboard and mouse motion events to pdp_xv and pdp_glx + compiles without x support, for use with sdl (i.e. svgalib) + more packet forth work + started sliceforth library (core signal processing routines) + finished pd interface to forth scripting language + fixed some crashes with pdp_xv and pdp_glx + removed "passing packet" hack + added minimal OO support to packet forth + moved all the forth stuff to libpdp project (no longer in pdp distro) + fixed (worked around) pdp_opengl deadlock bug on startup + pdp_opengl still not working properly + + +0.12.4: 2004/07/09 + build fixes + + + diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..7f87ef8 --- /dev/null +++ b/COPYING @@ -0,0 +1,340 @@ + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 675 Mass Ave, Cambridge, MA 02139, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR PDP.LICENSE, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/README b/README new file mode 100644 index 0000000..7ced23a --- /dev/null +++ b/README @@ -0,0 +1,267 @@ +PDP - Pure Data Packet v0.12.4 +a packet processing library for pure data + +Copyright (c) by Tom Schouten + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +The GNU Public Licence can be found in the file COPYING + + +------------------------------------------------------------------ + +This external pd library is a framework for image/video processing (and +other raw data packets) that is fast, simple and flexible and as much +as possible compatible with the pd messaging system. + +This distro contains the main pdp library and 3 extension libs: +* pdp_scaf (in directory scaf/) +* pdp_opengl (in directory opengl/) +* pdp_guile (in directory guile) + +Features: + +* packet formats: greyscale and YCrCb encoded images, + binary cellular automata (CA), textures, render buffers, + matrices. +* sources: noise, video4linux and quicktime (with audio), CA, plasma +* sinks: xvideo display, sdl, glx display +* filters: convolution, biquad time, biquad space, CA +* warping: rotate, zoom, stretch +* transforms: colour translation/scaling, grey->palette +* add, mul, mix, random pixel mix +* utility objs: packet register, snapshot, trigger +* packet delay line, loop, .. +* and more.. (see doc/reference.txt) + +Optional features + +* cellular automata simulator and effects processor with + built in forth extension language (only for mmx) +* opengl 3d processing (gem like, but built around packets) +* embedded guile interpreter + +See the README files in the scaf/ opengl/ and guile/ dirs for more +info on the extension libraries. + + +Requirements: + +* pd +* linux +* libgsl +* a video4linux device for video input. special support for +philips webcam included. +* libquicktime (not quicktime4linux!) for quicktime playback. +* libpng for png image loading/saving +* an X display with XVideo extension, glx or SDL for video display. + + +Documentation: + +When you use "make install" to install pd, all docs will be in +the pd doc directory. Right click on an object and select help +for a help patch. The pdp directory in pd's doc contains a +reference.txt file which lists all objects and abstractions and +an introduction and example section. + +NOTE: all help patches use a pdp_help_input and pdp_help_output +abstraction. you can edit these to choose which input or output +object you want for the help patches. + + +Building: + +./configure +make + +Options for configure: +--enable-mmx compile with mmx support +--enable-pwc force pdp_v4l to use philips web cam + +If pd is not installed in /usr/local you'll have to +specify the prefix on the configure command line with + +./configure --prefix=/prefix + +type + +make install + +To install pdp in $prefix/lib/pd: the library in externs/ +the abstractions in extra/ and the documentation in doc/5.reference +and doc/pdp + +You can also try the "buildall" script. This will configure, build +and install the whole distribution. It works for intel/mmx. + +NOTE: If you're not using the standard pd install location, and have +everything in a single tree, just untar pdp next to the pd source tree, +or set the prefix dir to the location of the pd source. + + +Bugs: + +See the TODO file. Apart from the few items listed on top of this +file, pdp is fairly stable: i am unaware of crash bugs. If you encounter +a crash please consider sending a bug report. + + +PiDiP Is Definitely In Pieces + +Have a look at Yves Degoyon's PiDiP library, the must have addition +to the basic pdp library. It contains a lot of extra effects (from +EffecTV and FreeJ), a quicktime recording object, streaming modules, +ascii art objects ... (the list is growing rapidly ;) +Yves also did a gem2pd and a pdp2gem object to connect pdp and gem +together. + +http://ydegoyon.free.fr/ + + +Acknowledgements + +PDP is no longer a one man show. Many thanks to the people who +directly or indirectly contributed to this project. Either by +writing a giant extension lib (thanks Yves) or by contributing code +snippets (Thanks Martin, CK), or by giving mental support, feedback, +bug reports and ideas. + +I also wish to thank the GEM crew. This project borrows a lot of ideas +and some code from the GEM project. And while i'm at it, i wish to +thank everyone who contributed code to the PD project as a whole and +the people that are very helpful at answering questions on the mailing +list. + +Last but not least i wish to thank Miller for making the PD project +open source. If that didn't happen i wouldn't know what i'd be doing +now :) + + +Some Remarks: + +* New versions of this package can be found at +http://zwizwa.fartit.com/pd/pdp +Experimental relases are in the subdirectory test/ + +* If you have libquicktime and quicktime4linux installed, this can +give problems with the configure script. Consider removing +quicktime4linux. (libquicktime is a drop-in replacement). + +* The modules that depend on system libraries only get compiled when +the configure script can locate them. If compilation or linking fails +please let me know. + +* Packets can be processed in a low priority thread with a dropping +mechanism to prevent overload or audio drops, or they can be processed +in the main pd thread. This can be set/unset by sending a "thread x" +message to pdp_control. Processing in pdp thread is off by default. +Use the pd thread for rock solid video timing. Increase the audio +latency to avoid dropouts. If you want low audio latency, and don't +care about a dropped video frame here and there, switch on the pdp +thread. Note that when using the pdp thread, the control flow is no +longer depth first. Additinal delays will be introduced. + +* Pdp runs on osx, using an x server (apple or fink) and libquickime +(fink). pdp_xv does not work yet. Once apple includes xv support in +their x server, it should. Until then, use pdp_glx for output. + +* Some quicktime remarks: pdp_qt~ is still a bit experimental, you might +try pdp_yqt in yves' lib to see if it works better for you. Also, it +seems that libquicktime does not work with compressed headers. The +suggested codec is jpeg (photo) and uncompressed audio with the same +samplerate as the one pd is using. You can use other codecs, but i've +found this one to perform the best. (hint: compile libquicktime with +mmx jpeg support) Try to avoid the mpga codec. It is haunted. + +* The reason i use YV12 and not RGB is simple: it's faster, and for +linear operations it doesn't make much difference. Most camera's and +codecs use a luma/chroma system, and most video cards support hardware +accellerated display. Note that in YUV, the u (Cb) and v (Cr) components +can be negative, so saturation after multiplication with a positive +(or negative) value produces not only black and white, but also red, +green, blue and their complements. In short, in YUV, nonlinear operations +have a different effect than in RGB. Another thing: all the spatial +operations are not implemented "correctly" because of the subsampling +involved.The image packets are 16bit/component planar. This is to +simplify the mmx code and to have a little more headroom and precision +for processing. + +* Since version 0.11 there is a type system used for identifying a +packet type and performing type conversion. A type is represented +by a symbol, with subtypes separated by the "/" character. I.e. +"image/grey/320x240" is a grey 16 bit/component image with dimensions +320 by 240. For conversions a wildcard can be specified. I.e. +"image/*/*" which matches image type packets with all encodings +and dimensions. + +* Since version 0.12 there are 2 different image data types: "image/*/*" +and "bitmap/*/*". The image type is the native 16 bit/component pdp +type. It supports the subtypes "image/grey/*": one channel grey +scale images, "image/YCrCb/*": luma/chroma packets with subsampled +chroma planes and "image/multi/*": a multi channel planar format (i.e. +to store 3 or 4 channel rgb or rgba data). Almost all processors +use this data type. The bitmap type is an intermediate type which +can contain standard fourcc encoded 8 bit/component images i.e. +"bitmap/rgb/*", "bitmap/yv12/*", "bitmap/grey/*". Currently no processors +support this type natively, so you have to use pdp_convert to convert +them to "image/*/*". + +* Writing new objects is not much different than normal pd externs. +Pdp just adds some functions to the pd kernel for package allocation, +manipulation and communication. The api is very raw to keep it as +simple as possible. Since 0.10 there is a pdp_base object you can +derive your objects from. Have a look at pdp_add, pdp_gain and +pdp_noise to see how it works. There is not much documentation, but +i do my best to keep things clean so the code and the header files +should get you started. You can always just send me an email for info, +or ask on the pd-dev list. Since version 0.12 there is a simple forth +scripting language in pdp. This is far from finished, but it should +make pdp programming a lot easier. + +* Philips webcam detection is now automatic. However this requires a +fairly recent kernel (one which includes the pwc driver version 8.6 +or higher). If you have a pwc and pdp_v4l does not display a +"pwc detected" message, you can conifigure with --enable-pwc. This +forces pdp_v4l to use the pwc api extensions. + + + +Directory structure: + +abstractions/ some abstractions that use the pdp objects +doc/introduction/ getting started with pdp +doc/examples/ some example patches +doc/objects/ pd style reference documentation +include/ header files +modules/ pd object code +opengl/ opengl extension lib (experimental) +scaf/ CA extension lib +guile/ scheme extension lib +system/ core pdp system + + + + +Bugreports, feature suggestions, code, documentation, example patches +and general comments and questions are welcome. + +Have Fun, + +Tom + + +last modified: 2003/07/20 + diff --git a/TAGS b/TAGS new file mode 100644 index 0000000..09dbcfe --- /dev/null +++ b/TAGS @@ -0,0 +1,2617 @@ + +include/pdp.h,21 +#define PDP_H24,840 + +include/pdp_ascii.h,140 +#define PDP_H23,858 +} t_ascii;t_ascii31,1093 +#define PDP_ASCII_BW 35,1128 +#define PDP_ASCII_IBM 36,1198 +#define PDP_ASCII_RGB 37,1324 + +include/pdp_base.h,221 +#define MAX_NB_PDP_BASE_INLETS 30,1059 +#define MAX_NB_PDP_BASE_OUTLETS 31,1092 +typedef void (*t_pdp_method)t_pdp_method41,1288 +typedef void* (*t_pdp_newmethod)t_pdp_newmethod42,1326 +} t_pdp_base;t_pdp_base78,2653 + +include/pdp_bitmap.h,327 +#define PDP_BITMAP_H32,1089 +typedef struct _bitmap_bitmap37,1142 +} t_bitmap;t_bitmap45,1450 +#define PDP_BITMAP_RGB 52,1515 +#define PDP_BITMAP_RGBA 53,1550 +#define PDP_BITMAP_GREY 54,1585 +#define PDP_BITMAP_YUY2 57,1638 +#define PDP_BITMAP_UYVY 58,1673 +#define PDP_BITMAP_I420 61,1726 +#define PDP_BITMAP_YV12 62,1761 + +include/pdp_comm.h,246 +#define PDP_COMM_H24,906 +#define S_PDP 52,1420 +#define S_REGISTER_RO 53,1449 +#define S_REGISTER_RW 54,1486 +#define S_PROCESS 55,1523 +#define S_DPD 56,1556 +#define S_INSPECT 57,1585 +#define S_ACCUMULATE 58,1618 +#define S_CHANMASK 59,1654 + +include/pdp_compat.h,26 +#define PDP_COMPAT_H8,97 + +include/pdp_config.h,790 +#define HAVE_INTTYPES_H 5,191 +#define HAVE_LIBGSLCBLAS 8,285 +#define HAVE_LIBM 11,366 +#define HAVE_MEMORY_H 14,445 +#define HAVE_PDP_GLX 17,490 +#define HAVE_PDP_GSL 20,532 +#define HAVE_PDP_PNG 23,580 +#define HAVE_PDP_QT 26,623 +#define HAVE_PDP_SDL 32,740 +#define HAVE_PDP_V4L 35,784 +#define HAVE_PDP_X 41,899 +#define HAVE_PDP_XV 44,940 +#define HAVE_STDINT_H 50,1083 +#define HAVE_STDLIB_H 53,1166 +#define HAVE_STRINGS_H 56,1250 +#define HAVE_STRING_H 59,1334 +#define HAVE_SYS_STAT_H 62,1419 +#define HAVE_SYS_TYPES_H 65,1507 +#define HAVE_UNISTD_H 68,1593 +#define PACKAGE_BUGREPORT 71,1697 +#define PACKAGE_NAME 74,1774 +#define PACKAGE_STRING 77,1858 +#define PACKAGE_TARNAME 80,1944 +#define PACKAGE_VERSION 83,2017 +#define PDP_DEBUG 86,2079 +#define STDC_HEADERS 89,2155 + +include/pdp_control.h,107 +#define __PDP_CONTROL_H__2,26 +typedef void (t_pdp_control_method_notify)t_pdp_control_method_notify7,95 + +include/pdp_debug.h,104 +#define __PDP_DEBUG_H_2,23 +#define PDP_ASSERT(PDP_ASSERT11,182 +#define PDP_ASSERT(PDP_ASSERT13,263 + +include/pdp_dpd_base.h,273 +#define PDP_DPD_MAX_CONTEXT_OUTLETS 48,2164 +typedef struct pdp_dpd_base_structpdp_dpd_base_struct50,2203 +} t_pdp_dpd_base;t_pdp_dpd_base78,3443 +#define pdp_dpd_base_set_queue 133,5290 +#define pdp_dpd_base_get_queue 134,5342 +#define pdp_dpd_base_queue_wait 135,5394 + +include/pdp_dpd_command.h,268 +#define PDP_DPD_COMMAND46,1777 +typedef struct _pdp_dpd_command_pdp_dpd_command52,1852 +} t_pdp_dpd_command;t_pdp_dpd_command57,1936 +typedef struct _pdp_dpd_commandfactory_pdp_dpd_commandfactory61,2002 +} t_pdp_dpd_commandfactory;t_pdp_dpd_commandfactory66,2118 + +include/pdp_image.h,347 +#define PDP_IMAGE_H32,1082 +typedef struct _image_image38,1176 +} t_image;t_image47,1585 +#define PDP_IMAGE_YV12 51,1620 +#define PDP_IMAGE_GREY 52,1725 +#define PDP_IMAGE_MCHP 53,1781 +#define PDP_IMAGE_SLICE_FIRST 56,1902 +#define PDP_IMAGE_SLICE_LAST 57,1939 +#define PDP_IMAGE_SLICE_BODY 58,1976 +#define pdp_packet_new_image_multi 81,2503 + +include/pdp_imagebase.h,43 +} t_pdp_imagebase;t_pdp_imagebase38,1183 + +include/pdp_imageproc.h,477 +#define PDP_IMAGEPROC_H27,985 +typedef long long t_pdp_imageproc_stackword;t_pdp_imageproc_stackword36,1104 +#define PDP_IMAGEPROC_NB_STACKWORDS(PDP_IMAGEPROC_NB_STACKWORDS39,1195 +#define PDP_IMAGEPROC_CONV_HORIZONTAL 123,4492 +#define PDP_IMAGEPROC_CONV_VERTICAL 124,4532 +#define PDP_IMAGEPROC_BIQUAD_TOP2BOTTOM 155,5707 +#define PDP_IMAGEPROC_BIQUAD_BOTTOM2TOP 156,5754 +#define PDP_IMAGEPROC_BIQUAD_LEFT2RIGHT 157,5801 +#define PDP_IMAGEPROC_BIQUAD_RIGHT2LEFT 158,5848 + +include/pdp_internals.h,32 +#define PDP_INTERNALS_H31,1013 + +include/pdp_list.h,2132 +#define PDP_LIST_H38,1305 + a_undef 47,1424 + a_pointer,48,1441 + a_float,49,1456 + a_int,50,1469 + a_symbol,51,1480 + a_packet,52,1494 + a_list,53,1508 + a_atom_pointer,54,1520 + a_forthword,57,1563 + a_vmword,58,1626 + a_vmmacro 59,1699 +} t_pdp_word_type;t_pdp_word_type60,1783 +typedef union _pdp_word_pdp_word62,1803 +} t_pdp_word;t_pdp_word72,2097 +typedef struct _pdp_atom_pdp_atom75,2133 +} t_pdp_atom;t_pdp_atom80,2229 +typedef struct _pdp_list_pdp_list83,2267 +} t_pdp_list;t_pdp_list89,2362 +typedef void (*t_pdp_atom_method)t_pdp_atom_method107,3006 +typedef void (*t_pdp_word_method)t_pdp_word_method108,3055 +typedef void (*t_pdp_pword_method)t_pdp_pword_method109,3102 +typedef void (*t_pdp_free_method)t_pdp_free_method110,3152 +#define pdp_list_add_front 186,6642 +#define pdp_list_push 187,6682 +#define pdp_list_queue 188,6722 +#define pdp_list_unqueue 189,6766 +#define PDP_ATOM_IN(PDP_ATOM_IN195,6885 +#define PDP_WORD_IN(PDP_WORD_IN200,7030 +#define PDP_POINTER_IN(PDP_POINTER_IN203,7177 +#define PDP_INT_IN(PDP_INT_IN204,7253 +#define PDP_FLOAT_IN(PDP_FLOAT_IN205,7325 +#define PDP_SYMBOL_IN(PDP_SYMBOL_IN206,7399 +#define PDP_PACKET_IN(PDP_PACKET_IN207,7474 +#define PDP_LIST_IN(PDP_LIST_IN208,7549 +#define pdp_list_add_pointer(pdp_list_add_pointer213,7664 +#define pdp_list_add_back_pointer(pdp_list_add_back_pointer214,7763 +#define pdp_list_add_pointer_to_set(pdp_list_add_pointer_to_set215,7867 +#define pdp_list_remove_pointer(pdp_list_remove_pointer216,7973 +#define pdp_list_contains_pointer(pdp_list_contains_pointer217,8075 +#define PDP_LIST_ATOM_0(PDP_LIST_ATOM_0220,8198 +#define PDP_LIST_ATOM_1(PDP_LIST_ATOM_1221,8238 +#define PDP_LIST_ATOM_2(PDP_LIST_ATOM_2222,8284 +#define PDP_LIST_ATOM_3(PDP_LIST_ATOM_3223,8336 +#define PDP_LIST_ATOM_4(PDP_LIST_ATOM_4224,8394 +static inline void pdp_atom_set(227,8484 +static inline void pdp_list_set_0(228,8586 +static inline void pdp_list_set_1(229,8700 +static inline void pdp_list_set_2(230,8820 +typedef t_pdp_list* (*t_pdp_list_evaluator_function)t_pdp_list_evaluator_function237,8981 + +include/pdp_list_macros.h,355 +#define __PDP_LIST_MACROS__2,28 +#define FIRST(FIRST8,201 +#define SIZE(SIZE9,232 +#define NEXT(NEXT11,267 +#define N(N12,297 +#define FLOAT(FLOAT14,330 +#define PACKET(PACKET15,392 +#define INT(INT16,454 +#define LIST(LIST20,576 +#define LFREE(LFREE21,614 +#define QFLOAT(QFLOAT22,653 +#define QINT(QINT23,731 +#define QPACKET(QPACKET24,807 + +include/pdp_llconv.h,399 +#define PDP_LLCONV_H30,1177 +enum RIF RIF51,1669 + RIF_YVU__P411_U8,52,1680 + RIF_YUV__P411_U8,53,1699 + RIF_YVU__P411_S16,54,1718 + RIF_YVU__P444_S16,55,1738 + RIF_YUYV_P____U8,56,1758 + RIF_RGB__P____U8,57,1777 + RIF_RGBA_P____U8,58,1803 + RIF_RGB__P444_S16,59,1822 + RIF_GREY______S16,60,1842 + RIF_GREY______U8,61,1862 + RIF_BGR__P____U8,62,1881 + RIF_BGRA_P____U863,1907 + +include/pdp_matrix.h,341 +#define PDP_MATRIX_H22,879 +#define gsl_rows 33,1083 +#define gsl_columns 34,1106 +typedef struct _matrix_matrix36,1133 +} t_matrix;t_matrix51,1644 +#define PDP_MATRIX 53,1657 +#define PDP_MATRIX_TYPE_RFLOAT 55,1679 +#define PDP_MATRIX_TYPE_CFLOAT 56,1712 +#define PDP_MATRIX_TYPE_RDOUBLE 57,1745 +#define PDP_MATRIX_TYPE_CDOUBLE 58,1779 + +include/pdp_mem.h,169 +#define _PDP_MEM_H_22,862 +#define PDP_FASTALLOC_BLOCK_ELEMENTS 32,1090 +typedef struct _pdp_fastalloc_pdp_fastalloc33,1132 +} t_pdp_fastalloc;t_pdp_fastalloc40,1278 + +include/pdp_mmx.h,25 +#define PDP_MMX_H24,862 + +include/pdp_net.h,693 +#define __PDP_UDP_H_2,21 +#define MAX_UDP_PACKET 53,1542 +#define RESEND_MAX_CHUNKS 54,1570 +#define PDP_UDP_VERSION 56,1664 +typedef struct _pdp_udp_header_pdp_udp_header60,1745 +} t_pdp_udp_header;t_pdp_udp_header67,2083 +#define PDP_UDP_NEW 71,2146 +typedef struct _pdp_udp_new_pdp_udp_new72,2200 +} t_pdp_udp_newpacket;t_pdp_udp_newpacket80,2587 +#define PDP_UDP_DONE 82,2611 +#define PDP_UDP_RESEND 84,2665 +#define PDP_UDP_ACKNEW 85,2762 +#define PDP_UDP_BUFSIZE 90,2892 +typedef struct _pdp_udp_receiver_pdp_udp_receiver93,2939 +} t_pdp_udp_receiver;t_pdp_udp_receiver123,3973 +typedef struct _pdp_udp_sender_pdp_udp_sender143,4553 +} t_pdp_udp_sender;t_pdp_udp_sender177,5625 + +include/pdp_packet.h,466 +#define PDP_PACKET_H69,3247 +#define PDP_HEADER_SIZE 79,3414 +typedef int (*t_pdp_factory_method)t_pdp_factory_method91,3517 +typedef struct _pdp_class_pdp_class94,3620 +}t_pdp_class;t_pdp_class103,4278 +#define PDP_GC_COLOUR_GREY 111,4427 +#define PDP_GC_COLOUR_WHITE 112,4502 +#define PDP_GC_COLOUR_BLACK 113,4532 +struct _pdp_pdp117,4591 +#define PDP_IMAGE 146,5771 +#define PDP_BITMAP 151,6152 +#define PDP_FOB 153,6327 +#define PDP_FLAG_DONOTCOPY 156,6420 + +include/pdp_pd.h,22 +#define _M_PD_H_4,41 + +include/pdp_png.h,29 +#define __PDP_PNG_H__22,861 + +include/pdp_post.h,28 +#define _PDP_POST_H_23,859 + +include/pdp_queue.h,279 +#define PDP_QUEUE_H23,860 +typedef void (*t_pdpmethod)t_pdpmethod30,1009 +typedef struct process_queue_structprocess_queue_struct33,1089 +} t_process_queue_item;t_process_queue_item39,1394 +typedef struct _pd_queue_pd_queue43,1452 +} t_pdp_procqueue;t_pdp_procqueue69,2108 + +include/pdp_resample.h,30 +#define PDP_RESAMPLE_H22,877 + +include/pdp_symbol.h,970 +#define _PDP_SYMBOL_22,884 +typedef struct _pdp_symbol_pdp_symbol41,1173 +} t_pdp_symbol;t_pdp_symbol57,1560 +typedef void (*t_pdp_symbol_iterator)t_pdp_symbol_iterator67,1769 +#define PDP_SYM_WILDCARD 99,2878 +#define PDP_SYM_FLOAT 100,2928 +#define PDP_SYM_INT 101,2975 +#define PDP_SYM_SYMBOL 102,3020 +#define PDP_SYM_PACKET 103,3068 +#define PDP_SYM_POINTER 104,3116 +#define PDP_SYM_LIST 105,3165 +#define PDP_SYM_INVALID 106,3211 +#define PDP_SYM_QUESTION_MARK 107,3260 +#define PDP_SYM_ATOM 108,3315 +#define PDP_SYM_NULL 109,3361 +#define PDP_SYM_QUOTE_START 110,3407 +#define PDP_SYM_QUOTE_END 111,3460 +#define PDP_SYM_RETURN 112,3511 +#define PDP_SYM_NRETURN 113,3559 +#define PDP_SYM_DEF_START 114,3608 +#define PDP_SYM_DEF_END 115,3658 +#define PDP_SYM_IF 116,3706 +#define PDP_SYM_THEN 117,3750 +#define PDP_SYM_LOCAL 118,3796 +#define PDP_SYM_FORTH 119,3843 +#define PDP_SYM_CALL 120,3890 +#define PDP_SYM_PUSH 121,3936 +#define PDP_SYM_POP 122,3982 + +include/pdp_type.h,281 +#define PDP_TYPE_H126,4477 +typedef int (*t_pdp_conversion_method)t_pdp_conversion_method133,4711 +typedef t_pdp_list t_pdp_conversion_program;t_pdp_conversion_program136,4831 +typedef struct _pdp_conversion_pdp_conversion139,4952 +} t_pdp_conversion;t_pdp_conversion144,5226 + +include/pdp_types.h,663 +#define PDP_TYPES_H25,911 +typedef signed char s8;s827,932 +typedef signed short s16;s1628,963 +typedef signed long s32;s3229,995 +typedef signed long long s64;s6430,1027 +typedef unsigned char u8;u832,1060 +typedef unsigned short u16;u1633,1091 +typedef unsigned long u32;u3234,1123 +typedef unsigned long long u64;u6435,1155 +typedef int bool;bool39,1209 +#define true 40,1227 +#define false 41,1243 +typedef struct _pdp t_pdp;t_pdp45,1269 +typedef void (*t_pdp_packet_method1)t_pdp_packet_method146,1296 +typedef void (*t_pdp_packet_method2)t_pdp_packet_method247,1366 +typedef unsigned int t_raw;t_raw54,1527 + +include/pdp_xvideo.h,171 +#define FOURCC_YV12 30,1019 +#define FOURCC_YUV2 31,1072 +#define FOURCC_I420 32,1124 +typedef struct _pdp_xvideo_pdp_xvideo37,1205 +} t_pdp_xvideo;t_pdp_xvideo59,1526 + +include/pdp_xwindow.h,179 +typedef struct _pdp_xdisplay_pdp_xdisplay30,966 +} t_pdp_xdisplay;t_pdp_xdisplay39,1260 +typedef struct _pdp_xwindow_pdp_xwindow54,1600 +} t_pdp_xwindow;t_pdp_xwindow78,2102 + +include/pwc-ioctl.h,1259 +#define PWC_IOCTL_H2,20 +#define PWC_FPS_SHIFT 51,1771 +#define PWC_FPS_MASK 52,1797 +#define PWC_FPS_FRMASK 53,1830 +#define PWC_FPS_SNAPSHOT 54,1865 +struct pwc_probepwc_probe58,1904 +#define PWC_WB_INDOOR 66,1990 +#define PWC_WB_OUTDOOR 67,2015 +#define PWC_WB_FL 68,2041 +#define PWC_WB_MANUAL 69,2062 +#define PWC_WB_AUTO 70,2087 +struct pwc_whitebalancepwc_whitebalance81,2482 +struct pwc_wb_speedpwc_wb_speed93,2814 +struct pwc_ledspwc_leds101,2914 +#define VIDIOCPWCRUSER 110,3072 +#define VIDIOCPWCSUSER 112,3136 +#define VIDIOCPWCFACTORY 114,3206 +#define VIDIOCPWCSCQUAL 124,3756 +#define VIDIOCPWCGCQUAL 126,3842 +#define VIDIOCPWCPROBE 139,4444 +#define VIDIOCPWCSAGC 142,4576 +#define VIDIOCPWCGAGC 144,4680 +#define VIDIOCPWCSSHUTTER 146,4794 +#define VIDIOCPWCSAWB 149,4888 +#define VIDIOCPWCGAWB 150,4960 +#define VIDIOCPWCSAWBSPEED 153,5054 +#define VIDIOCPWCGAWBSPEED 154,5117 +#define VIDIOCPWCSLED 157,5226 +#define VIDIOCPWCGLED 158,5290 +#define VIDIOCPWCSCONTOUR 161,5417 +#define VIDIOCPWCGCONTOUR 162,5463 +#define VIDIOCPWCSBACKLIGHT 165,5564 +#define VIDIOCPWCGBACKLIGHT 166,5612 +#define VIDIOCPWCSFLICKER 169,5709 +#define VIDIOCPWCGFLICKER 170,5755 +#define VIDIOCPWCSDYNNOISE 173,5869 +#define VIDIOCPWCGDYNNOISE 174,5916 + +system/pdp.c,25 +void pdp_setup(106,2812 + +system/mmx/pixel_add_s16.s,78 +.globl .globl18,815 +.type .type19,836 +pixel_add_s16:pixel_add_s1624,949 + +system/mmx/pixel_biquad_dirI_s16.s,204 +.globl .globl255,6234 +.type .type256,6264 +pixel_biquad_vertb_s16:pixel_biquad_vertb_s16262,6422 +.globl .globl307,7190 +.type .type308,7220 +pixel_biquad_horlr_s16:pixel_biquad_horlr_s16314,7375 + +system/mmx/pixel_biquad_s16.s,508 +.globl .globl189,5038 +.type .type190,5068 +pixel_biquad_vertb_s16:pixel_biquad_vertb_s16196,5226 +.globl .globl240,5987 +.type .type241,6017 +pixel_biquad_verbt_s16:pixel_biquad_verbt_s16247,6175 +.globl .globl300,7090 +.type .type301,7120 +pixel_biquad_horlr_s16:pixel_biquad_horlr_s16304,7271 +.globl .globl351,8046 +.type .type352,8076 +pixel_biquad_horrl_s16:pixel_biquad_horrl_s16355,8229 +.globl .globl408,9104 +.type .type409,9133 +pixel_biquad_time_s16:pixel_biquad_time_s16412,9291 + +system/mmx/pixel_ca_s1.s,0 + +system/mmx/pixel_cascade_s16.s,208 +.globl .globl168,4556 +.type .type169,4587 +pixel_cascade_vertb_s16:pixel_cascade_vertb_s16175,4747 +.globl .globl237,5692 +.type .type238,5723 +pixel_cascade_horlr_s16:pixel_cascade_horlr_s16244,5880 + +system/mmx/pixel_cheby_s16.s,114 +.globl .globl18,815 +.type .type19,844 +pixel_cheby_s16_3plus:pixel_cheby_s16_3plus25,1011 +skip:skip82,2374 + +system/mmx/pixel_conv_hor_s16.s,91 +.globl .globl66,1684 +.type .type67,1710 +pixel_conv_hor_s16:pixel_conv_hor_s1675,1932 + +system/mmx/pixel_conv_ver_s16.s,91 +.globl .globl58,1462 +.type .type59,1488 +pixel_conv_ver_s16:pixel_conv_ver_s1667,1709 + +system/mmx/pixel_crot_s16.s,173 +.globl .globl18,815 +.type .type19,839 +pixel_crot3d_s16:pixel_crot3d_s1627,1084 +.globl .globl97,2377 +.type .type98,2401 +pixel_crot2d_s16:pixel_crot2d_s16105,2646 + +system/mmx/pixel_gain.s,72 +.globl .globl18,815 +.type .type19,833 +pixel_gain:pixel_gain25,987 + +system/mmx/pixel_gain_s16.s,81 +.globl .globl18,815 +.type .type19,837 +pixel_gain_s16:pixel_gain_s1624,1012 + +system/mmx/pixel_mix_s16.s,79 +.globl .globl18,815 +.type .type19,836 +pixel_mix_s16:pixel_mix_s1625,1010 + +system/mmx/pixel_mul_s16.s,78 +.globl .globl18,815 +.type .type19,836 +pixel_mul_s16:pixel_mul_s1624,949 + +system/mmx/pixel_pack_s16u8.s,181 +.globl .globl18,815 +.type .type19,841 +pixel_pack_s16u8_y:pixel_pack_s16u8_y24,975 +.globl .globl78,2094 +.type .type79,2121 +pixel_pack_s16u8_uv:pixel_pack_s16u8_uv81,2159 + +system/mmx/pixel_rand_s16.s,80 +.globl .globl18,815 +.type .type19,837 +pixel_rand_s16:pixel_rand_s1624,970 + +system/mmx/pixel_randmix_s16.s,87 +.globl .globl18,815 +.type .type19,840 +pixel_randmix_s16:pixel_randmix_s1624,1020 + +system/mmx/pixel_resample_s16.s,257 +getpixelsbilin:getpixelsbilin90,2042 +skipfetch:skipfetch198,4771 +.globl .globl237,5405 +.type .type238,5438 +pixel_resample_linmap_s16:pixel_resample_linmap_s16244,5600 +linmap_looprow:linmap_looprow259,5953 +linmap_loopcol:linmap_loopcol263,6076 + +system/mmx/pixel_s1.s,84 +.globl .globl162,3387 +.type .type163,3408 +pixel_test_s1:pixel_test_s1173,3538 + +system/mmx/pixel_unpack_u8s16.s,189 +.globl .globl18,815 +.type .type19,843 +pixel_unpack_u8s16_y:pixel_unpack_u8s16_y24,982 +.globl .globl67,1901 +.type .type68,1930 +pixel_unpack_u8s16_uv:pixel_unpack_u8s16_uv69,1969 + +system/X11/pdp_xvideo.c,362 +#define D 32,1123 +static void pdp_xvideo_create_xvimage(39,1232 +static void pdp_xvideo_destroy_xvimage(59,1992 +void pdp_xvideo_display_packet(67,2176 +void pdp_xvideo_close(109,3427 +void pdp_xvideo_cleanup(121,3710 +void pdp_xvideo_free(130,3871 +void pdp_xvideo_init(135,3969 +t_pdp_xvideo *pdp_xvideo_new(153,4246 +int pdp_xvideo_open_on_display(160,4381 + +system/X11/pdp_xwindow.c,1152 +#define D 33,1144 +t_pdp_xdisplay *pdp_xdisplay_new(51,1649 +void pdp_xdisplay_free(67,2019 +static int _windowset_contains(76,2271 +static void _windowset_add(85,2484 +static t_pdp_list *_windowset_get_info_for_Window(96,2874 +static t_pdp_list *_windowset_get_info(105,3136 +static void _windowset_remove(114,3367 +void pdp_xdisplay_register_window(123,3579 +void pdp_xdisplay_unregister_window(128,3717 +void pdp_xdisplay_get_events(136,3969 +t_pdp_list *pdp_xdisplay_get_events_for_window(299,8517 +void pdp_xwindow_warppointer(319,9070 +static void pdp_xwindow_overrideredirect(329,9247 +void pdp_xwindow_moveresize(339,9536 +void pdp_xwindow_fullscreen(357,9991 +void pdp_xwindow_tile(384,10726 +void pdp_xwindow_resize(412,11714 +void pdp_xwindow_move(427,12158 +t_pdp_list *pdp_xwindow_get_eventlist(434,12426 +void pdp_xwindow_cursor_image(448,12690 +void pdp_xwindow_cursor(468,13280 +void pdp_xwindow_title(481,13558 +int pdp_xwindow_create_on_display(489,13721 +void pdp_xwindow_init(570,15858 +t_pdp_xwindow *pdp_xwindow_new(585,16129 +void pdp_xwindow_close(593,16273 +void pdp_xwindow_cleanup(609,16642 +void pdp_xwindow_free(617,16770 + +system/image/pdp_imageproc_common.c,1470 +#define CLAMP16(CLAMP1640,1270 +u32 pdp_imageproc_legalwidth(42,1352 +u32 pdp_imageproc_legalheight(50,1483 +u32 pdp_imageproc_legalwidth_round_down(56,1609 +u32 pdp_imageproc_legalheight_round_down(64,1743 +bool pdp_packet_compat(73,1936 +void pdp_imageproc_xor_process(88,2259 +void pdp_imageproc_and_process(100,2526 +void pdp_imageproc_or_process(112,2793 +void pdp_imageproc_not_process(124,3059 +void pdp_imageproc_mask_process(135,3281 +} t_plasma;t_plasma157,3766 +static inline s16 _rand_s16(159,3779 +static inline s16 _new_color(164,3847 +void *pdp_imageproc_plasma_new(170,4021 +void pdp_imageproc_plasma_delete(171,4095 +void pdp_imageproc_plasma_setseed(172,4154 +void pdp_imageproc_plasma_setturbulence(176,4239 +static void _plasma_subdiv(181,4361 +void pdp_imageproc_plasma_process(251,6656 +void pdp_imageproc_zero_process(271,7163 +void pdp_imageproc_constant_process(277,7318 +static inline u32 _sign(296,7792 +static inline void _decouple(312,8337 +void pdp_imageproc_abs_process(317,8409 +void pdp_imageproc_zthresh_process(332,8789 +void pdp_imageproc_hardthresh_process(344,9136 +void pdp_imageproc_softthresh_process(368,9803 +void pdp_imageproc_ispositive_process(395,10422 +void pdp_imageproc_sign_process(407,10674 +void pdp_imageproc_flip_lr_process(419,10943 +void pdp_imageproc_flip_tb_process(440,11319 +void pdp_imageproc_dispatch_1buf(451,11704 +void pdp_imageproc_dispatch_2buf(502,12961 +void pdp_imageproc_dispatch_3buf(554,14415 + +system/image/pdp_imageproc_mmx.c,3195 +inline static s16 float2fixed(33,1119 +inline static void setvec(41,1245 +void pdp_imageproc_add_process(53,1397 +void pdp_imageproc_mul_process(60,1609 +#define MIX_SIZE 68,1820 +void *pdp_imageproc_mix_new(69,1851 +int pdp_imageproc_mix_nb_stackwords(70,1914 +void pdp_imageproc_mix_delete(71,2003 +void pdp_imageproc_mix_setleftgain(72,2061 +void pdp_imageproc_mix_setrightgain(73,2142 +void pdp_imageproc_mix_process(74,2228 +#define RANDMIX_SIZE 83,2477 +void *pdp_imageproc_randmix_new(84,2512 +int pdp_imageproc_randmix_nb_stackwords(85,2583 +void pdp_imageproc_randmix_delete(86,2683 +void pdp_imageproc_randmix_setthreshold(87,2745 +void pdp_imageproc_randmix_setseed(88,2845 +void pdp_imageproc_randmix_process(98,3061 +} t_conv;t_conv116,3472 +void *pdp_imageproc_conv_new(117,3482 +void pdp_imageproc_conv_delete(118,3553 +void pdp_imageproc_conv_setmin1(119,3610 +void pdp_imageproc_conv_setzero(120,3697 +void pdp_imageproc_conv_setplus1(121,3784 +void pdp_imageproc_conv_setbordercolor(122,3873 +void pdp_imageproc_conv_setorientation(123,3969 +void pdp_imageproc_conv_setnbpasses(124,4061 +void pdp_imageproc_conv_process(125,4147 +void *pdp_imageproc_gain_new(152,4705 +void pdp_imageproc_gain_delete(153,4775 +void pdp_imageproc_gain_setgain(154,4832 +void pdp_imageproc_gain_process(190,5370 +void *pdp_imageproc_crot2d_new(197,5576 +void pdp_imageproc_crot2d_delete(198,5648 +void pdp_imageproc_crot2d_setmatrix(199,5707 +void pdp_imageproc_crot2d_process(207,5905 +} t_bq;t_bq227,6289 +void *pdp_imageproc_bq_new(229,6298 +void pdp_imageproc_bq_delete(230,6364 +void pdp_imageproc_bq_setcoef(231,6419 +void pdp_imageproc_bq_setnbpasses(254,7010 +void pdp_imageproc_bq_setdirection(255,7102 +void pdp_imageproc_bqt_process(259,7275 +void pdp_imageproc_bq_process(265,7476 +void *pdp_imageproc_random_new(339,9357 +void pdp_imageproc_random_delete(340,9428 +void pdp_imageproc_random_setseed(341,9487 +void pdp_imageproc_random_process(351,9702 +} t_resample_id;t_resample_id378,10474 +static void pdp_imageproc_resample_init_id(381,10563 +} t_resample_cid;t_resample_cid399,11169 +static void pdp_imageproc_resample_init_cid(402,11290 +} t_resample_clmd;t_resample_clmd433,12366 +static void pdp_imageproc_resample_cookedlinmap_init(436,12493 +} t_resample_cbrd;t_resample_cbrd461,13347 +} t_resample_zrd;t_resample_zrd473,13588 +static void pdp_imageproc_resample_clmd_init_from_id_zrd(477,13698 +} t_resample_zoom_rotate;t_resample_zoom_rotate513,15164 +void *pdp_imageproc_resample_affinemap_new(516,15208 +void pdp_imageproc_resample_affinemap_delete(526,15509 +void pdp_imageproc_resample_affinemap_setcenterx(527,15580 +void pdp_imageproc_resample_affinemap_setcentery(528,15696 +void pdp_imageproc_resample_affinemap_setzoomx(529,15812 +void pdp_imageproc_resample_affinemap_setzoomy(530,15924 +void pdp_imageproc_resample_affinemap_setangle(531,16036 +void pdp_imageproc_resample_affinemap_process(532,16148 +} t_cheby;t_cheby559,16908 +void *pdp_imageproc_cheby_new(561,16920 +void pdp_imageproc_cheby_delete(574,17259 +void pdp_imageproc_cheby_setcoef(575,17317 +void pdp_imageproc_cheby_setnbpasses(582,17504 +void pdp_imageproc_cheby_process(584,17589 + +system/image/pdp_imageproc_portable.c,2909 +inline static s32 float2fixed(34,1048 +#define CLAMP16(CLAMP1644,1176 +void pdp_imageproc_add_process(47,1276 +void pdp_imageproc_mul_process(60,1542 +void *pdp_imageproc_mix_new(73,1803 +int pdp_imageproc_mix_nb_stackwords(74,1871 +void pdp_imageproc_mix_delete(75,1967 +void pdp_imageproc_mix_setleftgain(76,2025 +void pdp_imageproc_mix_setrightgain(81,2138 +void pdp_imageproc_mix_process(86,2252 +void *pdp_imageproc_randmix_new(103,2560 +int pdp_imageproc_randmix_nb_stackwords(104,2633 +void pdp_imageproc_randmix_delete(105,2733 +void pdp_imageproc_randmix_setthreshold(106,2794 +void pdp_imageproc_randmix_setseed(113,3010 +void pdp_imageproc_randmix_process(118,3123 +void *pdp_imageproc_conv_new(136,3493 +void pdp_imageproc_conv_delete(137,3563 +void pdp_imageproc_conv_setmin1(138,3620 +void pdp_imageproc_conv_setzero(143,3728 +void pdp_imageproc_conv_setplus1(148,3836 +void pdp_imageproc_conv_setbordercolor(153,3945 +void pdp_imageproc_conv_setorientation(158,4060 +void pdp_imageproc_conv_setnbpasses(159,4139 +static inline void pdp_imageproc_conv_scanline(161,4216 +void pdp_imageproc_conv_process(189,4807 +void *pdp_imageproc_gain_new(215,5352 +void pdp_imageproc_gain_delete(216,5422 +void pdp_imageproc_gain_setgain(217,5479 +void pdp_imageproc_gain_process(247,5940 +void *pdp_imageproc_crot2d_new(259,6215 +void pdp_imageproc_crot2d_delete(260,6286 +void pdp_imageproc_crot2d_setmatrix(261,6345 +void pdp_imageproc_crot2d_process(270,6573 +} t_bq;t_bq310,7177 +void *pdp_imageproc_bq_new(311,7185 +void pdp_imageproc_bq_delete(312,7251 +void pdp_imageproc_bq_setnbpasses(313,7306 +void pdp_imageproc_bq_setdirection(314,7384 +void pdp_imageproc_bq_setcoef(315,7464 +#define A1 340,8110 +#define A2 341,8126 +#define B0 342,8142 +#define B1 343,8158 +#define B2 344,8174 +static inline void pdp_imageproc_bq_scanline(356,8418 +void pdp_imageproc_bqt_process(386,8863 +void pdp_imageproc_bq_process(410,9354 +void *pdp_imageproc_random_new(485,11216 +void pdp_imageproc_random_delete(486,11285 +void pdp_imageproc_random_setseed(487,11344 +void pdp_imageproc_random_process(495,11490 +static inline s32 pdp_resample_bilin(515,11889 +} t_affine_map;t_affine_map553,12666 +void *pdp_imageproc_resample_affinemap_new(556,12684 +void pdp_imageproc_resample_affinemap_delete(568,12938 +void pdp_imageproc_resample_affinemap_setcenterx(569,13009 +void pdp_imageproc_resample_affinemap_setcentery(570,13111 +void pdp_imageproc_resample_affinemap_setzoomx(571,13213 +void pdp_imageproc_resample_affinemap_setzoomy(572,13311 +void pdp_imageproc_resample_affinemap_setangle(573,13409 +void pdp_imageproc_resample_affinemap_process(574,13507 +} t_cheby;t_cheby632,15153 +void *pdp_imageproc_cheby_new(634,15165 +void pdp_imageproc_cheby_delete(646,15471 +void pdp_imageproc_cheby_setnbpasses(647,15529 +void pdp_imageproc_cheby_setcoef(648,15613 +void pdp_imageproc_cheby_process(657,15804 + +system/image/pdp_llconv.c,877 +#define CLAMP8(CLAMP842,1351 +#define CLAMP16(CLAMP1643,1406 +#define FP(FP44,1481 +#define CLAMP 46,1527 +static inline int rgb2y(55,1945 +static inline int rgb2v(59,2067 +static inline int rgb2u(63,2190 +static inline void _exchange_row(70,2341 +void pdp_llconv_flip_top_bottom(96,2810 +static void llconv_rgb2yvu(114,3225 +static void llconv_yvu16planar2rgbpacked(135,3562 +inline static void llconv_rgb2yvu_planar16sub_indexed(244,5946 +static void llconv_rgb2yvu_planar16sub(313,7871 +static void llconv_rgba2yvu_planar16sub(319,8075 +static void llconv_bgr2yvu_planar16sub(325,8279 +static void llconv_bgra2yvu_planar16sub(331,8483 +static void llconv_rgb2yvu_planar8sub(338,8687 +static void llconv_yvu2rgb(409,10482 +static void llconv_yvu2yuyv(434,10992 +static void llconv_yuyv_packed_u8s16(459,11404 +#define CONVERT(CONVERT512,12779 +void pdp_llconv(514,12819 + +system/image/pdp_llconv_mmx.c,145 +void llconv_grey_s16u8(28,966 +void llconv_yvu_planar_s16u8(34,1161 +void llconv_yvu_planar_u8s16(42,1444 +void llconv_yuv_planar_u8s16(49,1733 + +system/image/pdp_llconv_portable.c,369 +#define CLAMP(CLAMP22,879 +#define FP(FP23,933 +void pixel_unpack_portable_u8s16_y(25,979 +void pixel_unpack_portable_u8s16_uv(31,1166 +void pixel_pack_portable_s16u8_y(38,1366 +void pixel_pack_portable_s16u8_uv(44,1558 +void llconv_grey_s16u8(53,1845 +void llconv_yvu_planar_s16u8(59,2046 +void llconv_yvu_planar_u8s16(68,2345 +void llconv_yuv_planar_u8s16(75,2649 + +system/image/pdp_resample.c,219 +static s32 pdp_resample_bilin(38,1168 +void pdp_resample_scale_bilin(70,1829 +void pdp_resample_scale_nn(89,2313 +void pdp_resample_halve(142,3622 +void pdp_resample_double(174,4371 +void pdp_resample_padcrop(198,4895 + +system/kernel/pdp_debug.c,95 +int pdp_debug_sigtrap_on_assert;6,86 +void pdp_assert_hook 9,121 +void pdp_debug_setup(18,423 + +system/kernel/pdp_dpd_command.c,231 +void pdp_dpd_commandfactory_init(27,963 +void _pdp_dpd_commandfactory_free(34,1112 +void pdp_dpd_commandfactory_free(40,1243 +t_pdp_dpd_command *pdp_dpd_commandfactory_get_new_command(49,1422 +void pdp_dpd_command_suicide(78,2107 + +system/kernel/pdp_list.c,2559 +#define D 42,1303 +t_pdp_fastalloc *_fast_atom_allocator;45,1322 +t_pdp_fastalloc *_fast_list_allocator;46,1361 +static void _pdp_list_dealloc(51,1404 +#define PDP_ATOM_ALLOC(PDP_ATOM_ALLOC57,1526 +#define PDP_ATOM_DEALLOC(PDP_ATOM_DEALLOC58,1596 +#define PDP_LIST_ALLOC(PDP_LIST_ALLOC59,1673 +#define PDP_LIST_DEALLOC(PDP_LIST_DEALLOC60,1743 +void pdp_list_setup(69,1932 +t_pdp_list* pdp_list_new(98,2421 +void pdp_list_clear(129,2883 +void pdp_list_free(147,3132 +void pdp_tree_free(157,3258 +void pdp_tree_clear(166,3379 +static inline int _is_whitespace(190,3745 +static inline void _skip_real_whitespace(191,3832 +static inline int _is_left_comment(194,3944 +static inline int _is_right_comment(195,4008 +static inline void _skip_comment(196,4074 +static inline void _skip_whitespace(208,4319 +static inline int _is_left_separator(220,4562 +static inline int _is_right_separator(221,4628 +static inline int _is_terminator(222,4695 +static inline int _is_separator(225,4806 +static inline void _parse_pure_atom(235,5098 +t_pdp_atom *pdp_atom_new(274,5967 +void pdp_atom_free(275,6056 +t_pdp_atom *pdp_atom_from_cstring(282,6309 +t_pdp_list *pdp_tree_from_cstring(338,7458 +int pdp_tree_check_syntax(376,8466 +void pdp_list_apply(510,11529 +void pdp_tree_apply(517,11664 +void pdp_list_apply_word_method(527,11870 +void pdp_list_apply_pword_method(536,12075 +void pdp_tree_apply_word_method(546,12286 +void pdp_tree_apply_pword_method(556,12572 +static void _atom_packet_mark_unused(567,12866 +static void _atom_packet_copy_ro(575,13019 +void pdp_tree_strip_packets 583,13168 +static void _pdp_tree_copy_ro_packets 588,13266 +t_pdp_list *pdp_tree_copy_ro(593,13370 +static void _pdp_atom_fprint(602,13567 +static void _pdp_atomlist_fprint(635,14645 +void _pdp_list_fprint(646,14840 +void pdp_list_print(652,14952 +void pdp_atom_print(657,15025 +void pdp_list_add_atom(668,15178 +void pdp_list_add(676,15328 +void pdp_list_add_back_atom(686,15535 +void pdp_list_add_back(700,15731 +int pdp_list_size(709,15927 +t_pdp_atom *pdp_list_pop_atom(718,16032 +t_pdp_word pdp_list_pop(732,16293 +void pdp_list_pop_push(744,16486 +t_pdp_word pdp_list_index(763,16843 +void pdp_list_remove(775,17022 +t_pdp_list* pdp_tree_copy_reverse(804,17639 +t_pdp_list* pdp_list_copy_reverse(818,17981 +t_pdp_list* pdp_tree_copy(827,18203 +t_pdp_list* pdp_list_copy(847,18656 +void pdp_list_join 862,18971 +void pdp_list_cat 878,19291 +void pdp_list_reverse(887,19521 +void pdp_list_reverse_old(902,19813 +int pdp_list_contains(913,20080 +void pdp_list_add_to_set(923,20360 + +system/kernel/pdp_mem.c,388 +void *pdp_alloc(27,958 +void pdp_dealloc(42,1223 +typedef struct _fastalloc_fastalloc55,1476 +} t_fastalloc;t_fastalloc58,1532 +static void _pdp_fastalloc_lock(63,1551 +static void _pdp_fastalloc_unlock(64,1633 +static void _pdp_fastalloc_refill_freelist(66,1720 +void *pdp_fastalloc_new_atom(90,2341 +void pdp_fastalloc_save_atom(111,2744 +t_pdp_fastalloc *pdp_fastalloc_new(119,2946 + +system/kernel/pdp_packet.c,1097 +#define PDP_INITIAL_POOL_SIZE 82,2453 +static int pdp_pool_size;83,2486 +static t_pdp** pdp_pool;84,2512 +static pthread_mutex_t pdp_pool_mutex;87,2605 +#define LOCK 88,2644 +#define UNLOCK 89,2698 +static t_pdp_list *class_list;92,2779 +pdp_packet_print_debug(96,2828 +pdp_packet_setup(118,3302 +t_pdp_class *pdp_class_new(129,3606 +int pdp_factory_newpacket(139,3954 +_pdp_pool_expand_nolock(166,4668 +_pdp_packet_dealloc_nolock(188,5242 +_pdp_packet_alloc_nolock(195,5341 +_pdp_packet_create_nolock(211,5734 +pdp_packet_destroy(231,6169 +pdp_packet_create(254,6694 +pdp_packet_new(291,7827 +_pdp_packet_save_nolock(328,8742 +pdp_packet_reuse(343,9186 +pdp_packet_copy_ro(395,10542 +pdp_packet_clone_rw(413,10902 +pdp_packet_copy_rw(447,11837 +void pdp_packet_mark_unused(480,12627 +void pdp_packet_delete(516,13455 +pdp_packet_header(551,14062 +pdp_packet_subheader(558,14198 +pdp_packet_data(566,14356 +pdp_packet_data_size(579,14577 +int pdp_packet_writable(594,14802 +void pdp_packet_replace_with_writable(601,14976 +pdp_pool_collect_garbage(615,15252 +pdp_pool_set_max_mem_usage(622,15365 + +system/kernel/pdp_packet2.c,1097 +#define PDP_INITIAL_POOL_SIZE 82,2453 +static int pdp_pool_size;83,2486 +static t_pdp** pdp_pool;84,2512 +static pthread_mutex_t pdp_pool_mutex;87,2605 +#define LOCK 88,2644 +#define UNLOCK 89,2698 +static t_pdp_list *class_list;92,2779 +pdp_packet_print_debug(96,2828 +pdp_packet_setup(118,3302 +t_pdp_class *pdp_class_new(129,3606 +int pdp_factory_newpacket(139,3954 +_pdp_pool_expand_nolock(166,4668 +_pdp_packet_dealloc_nolock(188,5242 +_pdp_packet_alloc_nolock(195,5341 +_pdp_packet_create_nolock(211,5734 +pdp_packet_destroy(231,6169 +pdp_packet_create(254,6694 +pdp_packet_new(291,7827 +_pdp_packet_save_nolock(328,8665 +pdp_packet_reuse(343,9109 +pdp_packet_copy_ro(395,10465 +pdp_packet_clone_rw(413,10825 +pdp_packet_copy_rw(436,11358 +void pdp_packet_mark_unused(469,12148 +void pdp_packet_delete(505,12976 +pdp_packet_header(540,13583 +pdp_packet_subheader(547,13719 +pdp_packet_data(555,13877 +pdp_packet_data_size(568,14098 +int pdp_packet_writable(583,14323 +void pdp_packet_replace_with_writable(590,14497 +pdp_pool_collect_garbage(604,14773 +pdp_pool_set_max_mem_usage(611,14886 + +system/kernel/pdp_post.c,48 +void pdp_post_n(32,1044 +void pdp_post(39,1166 + +system/kernel/pdp_symbol.c,1336 +static pthread_mutex_t pdp_hash_mutex;32,1099 +#define HASHSIZE 34,1139 +static t_pdp_symbol *pdp_symhash[35,1161 +#define LOCK 38,1207 +#define UNLOCK 39,1256 +static void _pdp_symbol_init(42,1311 +t_pdp_symbol *_pdp_dogensym(50,1479 +t_pdp_symbol *pdp_gensym(93,2283 +int pdp_symbol_set_typelist(101,2462 +void pdp_symbol_apply_all(114,2659 +t_pdp_symbol _pdp_sym_wildcard;126,2843 +t_pdp_symbol _pdp_sym_float;127,2875 +t_pdp_symbol _pdp_sym_int;128,2904 +t_pdp_symbol _pdp_sym_symbol;129,2931 +t_pdp_symbol _pdp_sym_packet;130,2961 +t_pdp_symbol _pdp_sym_pointer;131,2991 +t_pdp_symbol _pdp_sym_invalid;132,3022 +t_pdp_symbol _pdp_sym_list;133,3053 +t_pdp_symbol _pdp_sym_question_mark;134,3081 +t_pdp_symbol _pdp_sym_atom;135,3118 +t_pdp_symbol _pdp_sym_null;136,3146 +t_pdp_symbol _pdp_sym_quote_start;137,3174 +t_pdp_symbol _pdp_sym_quote_end;138,3209 +t_pdp_symbol _pdp_sym_return;139,3242 +t_pdp_symbol _pdp_sym_nreturn;140,3272 +t_pdp_symbol _pdp_sym_defstart;141,3303 +t_pdp_symbol _pdp_sym_defend;142,3335 +t_pdp_symbol _pdp_sym_if;143,3365 +t_pdp_symbol _pdp_sym_then;144,3391 +t_pdp_symbol _pdp_sym_local;145,3419 +t_pdp_symbol _pdp_sym_forth;146,3448 +t_pdp_symbol _pdp_sym_call;147,3477 +t_pdp_symbol _pdp_sym_push;148,3505 +t_pdp_symbol _pdp_sym_pop;149,3533 +static void _sym(151,3561 +void pdp_symbol_setup(160,3804 + +system/kernel/pdp_type.c,1116 +#define D 37,1157 +static t_pdp_list *conversion_list;40,1176 +#define INIT_MAX_CACHE_SIZE 42,1213 +static t_pdp_list *cached_conversion_list;44,1245 +static int max_cache_size;45,1288 +static pthread_mutex_t pdp_conversion_mutex;48,1328 +static pthread_mutex_t pdp_cache_mutex;49,1373 +t_pdp_list *pdp_type_to_list(54,1447 +#define TMPSIZE 56,1498 +t_pdp_symbol *pdp_packet_get_description(86,2043 +int _pdp_type_run_conversion_program(104,2529 +_pdp_type_find_conversion_program(139,3643 +_pdp_type_find_cached_conversion_program(173,4647 +void pdp_conversion_program_free(215,5699 +void _pdp_conversion_program_print(221,5818 +t_pdp_conversion_program *pdp_conversion_program_new(227,5983 +t_pdp_conversion_program *pdp_conversion_program_copy(245,6484 +void pdp_conversion_program_add(251,6645 +void pdp_type_register_conversion 258,6825 +void pdp_type_register_cached_conversion 277,7379 +int _pdp_packet_convert(304,8333 +int pdp_packet_convert_ro(365,10567 +int pdp_packet_convert_rw(377,10967 +static void _setup_type_cache(395,11597 +int pdp_type_description_match(405,11879 +void pdp_type_setup(457,13340 + +system/mmx/pdp_mmx_test.c,397 +#define FP(FP3,22 +#define nbp 5,78 + short int a1[7,95 + short int a2[8,148 + short int b0[9,201 + short int b1[10,254 + short int b2[11,307 + short int u1[13,361 + short int u2[14,414 + short int x0[16,468 + short int x1[17,521 + short int x2[18,574 + short int x3[19,627 +void print_pixel(21,681 +void print_line(27,767 +void print_square(32,812 +main(43,970 + +system/net/pdp_net.c,1209 +#define D 7,89 +#define DD 8,121 +static int _is_udp_header(12,183 +static void _make_udp_header(20,430 +static void _send_packet(34,611 +static void _send_ack_new(46,1035 +static int _handle_PDP_UDP_NEW(58,1327 +static void _handle_PDP_UDP_DONE(111,2944 +static int _handle_UDP_DATA(160,4400 +t_pdp_udp_receiver *pdp_udp_receiver_new(192,5332 +void pdp_udp_receiver_free(222,6123 +void pdp_udp_receiver_reset(231,6398 +int pdp_udp_receiver_receive(238,6551 +char *pdp_udp_receiver_type(309,8235 +unsigned int pdp_udp_receiver_size(310,8310 +void *pdp_udp_receiver_data(311,8392 +static void _sleep(318,8500 +static void _send(328,8711 +static void _prepare_for_new_transmission(345,9120 +static void _send_header_packet(367,9854 +static void _send_chunks(386,10475 +static void _send_done(424,11536 +static int _receive_packet(429,11668 +static int _need_resend(497,13203 +void pdp_udp_sender_timeout_us(547,14213 +void pdp_udp_sender_sleepgrain_us(553,14330 +void pdp_udp_sender_sleepperiod(558,14458 +void pdp_udp_sender_udp_packet_size(564,14580 +void pdp_udp_sender_connect(572,14842 +t_pdp_udp_sender *pdp_udp_sender_new(601,15613 +void pdp_udp_sender_free(623,16096 +int pdp_udp_sender_send(632,16317 + +system/png/pdp_png.c,885 +#define READING 36,1037 +#define WRITING 37,1055 +#define SIG_BYTES 38,1073 +#define D 40,1094 +} t_png_image;t_png_image62,1474 +static t_png_image *_init(64,1490 +static int _cleanup(74,1650 +#define INTERNAL_ERROR 76,1688 +static int _open_read(89,2065 +static int _open_write(107,2461 +static void _row_callback(123,2719 +static int _initio_read(128,2818 +static int _initio_write(137,3013 +static int _checkimagetype(146,3167 +#define user_error_ptr 212,4888 +#define user_error_fn 213,4916 +#define user_warning_fn 214,4943 +static int _buildstruct_read(216,4973 +static int _buildstruct_write(230,5347 +static int _getimagedata(243,5652 +static int _saveimagedata(274,6392 +int pdp_packet_bitmap_from_png_file(321,7766 +int pdp_packet_bitmap_save_png_file(346,8250 +int pdp_packet_bitmap_save_png_file(369,8665 +int pdp_packet_bitmap_from_png_file(375,8823 +int main(397,9012 + +system/type/pdp_bitmap.c,1251 +static t_pdp_class* bitmap_class;32,1054 +t_bitmap *pdp_packet_bitmap_info(35,1090 +int pdp_packet_bitmap_isvalid(41,1239 +t_pdp_symbol *pdp_packet_bitmap_get_description(55,1504 +int pdp_packet_new_bitmap_yv12(88,2521 +int pdp_packet_new_bitmap_grey(113,3097 +int pdp_packet_new_bitmap_rgb(137,3667 +int pdp_packet_new_bitmap_rgba(162,4240 +int pdp_packet_new_bitmap(187,4815 +void pdp_packet_bitmap_flip_top_bottom(203,5317 +static int _pdp_packet_bitmap_convert_grey_to_grey8(226,5925 +static int _pdp_packet_bitmap_convert_YCrCb_to_rgb8(252,6676 +static int _pdp_packet_bitmap_convert_image_to_yv12(277,7386 +static int _pdp_packet_bitmap_convert_rgb8_to_YCrCb(315,8380 +static int _pdp_packet_bitmap_convert_rgb8_to_bitmap_YCrCb(336,8982 +static int _pdp_packet_bitmap_convert_grey8_to_grey(357,9588 +static int _pdp_packet_bitmap_convert_rgb8_to_rgba8(377,10188 +static int _pdp_packet_bitmap_convert_rgba8_to_rgb8(400,10832 +static int _pdp_packet_bitmap_convert_rgb8_to_mchp(422,11450 +static int _pdp_packet_bitmap_convert_yv12_to_image(447,12147 +static int _pdp_packet_bitmap_convert_mchp_to_rgb8(466,12711 +static int _pdp_packet_bitmap_convert_fallback(517,14087 +static int pdp_bitmap_factory(525,14316 +void pdp_bitmap_setup(569,15329 + +system/type/pdp_image.c,1057 +static t_pdp_class* image_class;41,1280 +static void _checkdim(46,1339 +int pdp_packet_new_image_YCrCb(55,1638 +int pdp_packet_new_image_grey(82,2238 +int pdp_packet_new_image_mchp(109,2823 +int pdp_packet_new_image(139,3441 +int pdp_packet_image_compat(157,3834 +int pdp_packet_image_isvalid(186,4684 +void pdp_packet_image_set_chanmask(201,5093 +t_image *pdp_packet_image_info(208,5268 +t_pdp_symbol *pdp_packet_image_get_description(214,5369 +static int _pdp_packet_image_convert_YCrCb_to_grey(266,6789 +static int _pdp_packet_image_convert_grey_to_YCrCb(279,7220 +static int _pdp_packet_image_convert_grey_to_multi(296,7755 +static int _pdp_packet_image_convert_multi_to_YCrCb(312,8274 +static int _pdp_packet_image_convert_YCrCb_to_multi(352,9331 +static void _pdp_description_get_dims(389,10227 +static int _pdp_packet_image_convert_resample_YCrCb(403,10531 +static int _pdp_packet_image_convert_resample_multi(440,12204 +static int _pdp_packet_image_convert_fallback(482,13381 +static int pdp_image_factory(493,13646 +void pdp_image_setup(548,14861 + +system/type/pdp_matrix.c,1605 +static t_pdp_class *matrix_class;11,245 +#define VALID_MATRIX_HEADER(VALID_MATRIX_HEADER16,359 +int pdp_packet_matrix_isvalid(24,707 +void *pdp_packet_matrix_get_gsl_matrix(31,804 +void *pdp_packet_matrix_get_gsl_vector(37,931 +int pdp_packet_matrix_get_type(43,1058 +int pdp_packet_matrix_isvector(49,1161 +int pdp_packet_matrix_ismatrix(55,1294 +int pdp_packet_matrix_LU_to_inverse(113,2216 +int pdp_packet_matrix_LU(141,3154 +int pdp_packet_matrix_LU_solve(172,4204 +int pdp_packet_matrix_blas_mm202,5260 +int pdp_packet_matrix_blas_mv247,6763 +t_pdp_symbol *_pdp_matrix_get_description(292,8155 +static size_t _pdp_matrix_mdata_byte_size(332,9346 +static size_t _pdp_matrix_pdata_vector_size(346,9805 +static void _pdp_matrix_init(352,9922 +static void _pdp_matrix_clone(396,11177 +static void _pdp_matrix_copy(402,11341 +static void _pdp_matrix_reinit(408,11556 +static void _pdp_matrix_cleanup(412,11653 +int pdp_packet_new_matrix(417,11736 +int pdp_packet_new_matrix_product_result(436,12286 +void pdp_packet_matrix_setzero(479,13268 +static int _pdp_packet_convert_matrix_to_greyimage(490,13499 +static int _pdp_packet_convert_image_to_matrix(525,14731 +static int _pdp_packet_convert_image_to_floatmatrix(583,16332 +static int _pdp_packet_convert_image_to_doublematrix(585,16522 +static int _pdp_packet_convert_image_to_complexfloatmatrix(587,16714 +static int _pdp_packet_convert_image_to_complexdoublematrix(589,16911 +static int _pdp_packet_matrix_convert_fallback(593,17112 +static void _gsl_error_handler 603,17412 +static int pdp_matrix_factory(611,17660 +void pdp_matrix_setup(615,17729 + +puredata/pdp_base.c,1054 +static void pdp_base_debug(35,1143 +static void pdp_base_thread(46,1436 +static void pdp_base_process(52,1573 +static void pdp_base_postprocess(60,1749 +void pdp_base_movepassive(73,2122 +void pdp_base_bang(88,2448 +void pdp_base_input_hot(119,3220 +void pdp_base_input_cold(164,4411 +void pdp_base_set_process_method(207,5211 +void pdp_base_set_preproc_method(213,5340 +void pdp_base_set_postproc_method(220,5470 +void pdp_base_queue_wait(227,5602 +void pdp_base_set_queue(233,5710 +t_pdp_procqueue *pdp_base_get_queue(240,5849 +void pdp_base_setup(246,5955 +void pdp_base_init(261,6446 +void pdp_base_free(290,7039 +void pdp_base_readonly_active_inlet(305,7397 +void pdp_base_disable_active_inlet(311,7520 +void pdp_base_add_pdp_inlet(319,7661 +t_outlet *pdp_base_add_pdp_outlet(336,8076 +void pdp_base_set_packet(351,8358 +int pdp_base_get_packet(363,8634 +int pdp_base_move_packet(375,8867 +t_object *pdp_base_get_object(391,9085 +void pdp_base_add_gen_inlet(396,9155 +void pdp_base_disable_thread(402,9299 +void pdp_base_set_type_template(409,9413 + +puredata/pdp_comm.c,734 +void outlet_pdp_register(56,1743 +void outlet_pdp_process(77,2357 +void outlet_pdp(93,2780 +void outlet_dpd(100,2946 +pdp_packet_pass_if_valid(117,3271 +pdp_packet_replace_if_valid(136,3620 +pdp_packet_copy_ro_or_drop(148,3795 +pdp_packet_copy_rw_or_drop(162,4074 +pdp_packet_convert_ro_or_drop(175,4352 +pdp_packet_convert_rw_or_drop(192,4745 +void outlet_pdp_atom(209,5207 +void outlet_pdp_list(234,5693 +void pd_atom_to_pdp_atom(303,6919 +t_symbol s_pdp 323,7311 +t_symbol s_register_ro 324,7351 +t_symbol s_register_rw 325,7399 +t_symbol s_process 326,7447 +t_symbol s_dpd 327,7491 +t_symbol s_inspect 328,7531 +t_symbol s_accumulate 329,7575 +t_symbol s_chanmask 330,7622 +static void _addsym(334,7737 +pdp_pdsym_setup(349,8163 + +puredata/pdp_compat.c,57 +pdp_pass_if_valid(38,1078 +pdp_replace_if_valid(44,1183 + +puredata/pdp_control.c,671 +static long dropped_packets;38,1109 +static t_class* pdp_control_class;40,1139 +typedef struct _pdp_control_pdp_control46,1230 +} t_pdp_control;t_pdp_control52,1339 +static t_pdp_control *pdp_control_list;56,1359 +static void pdp_control_info(58,1400 +static void pdp_control_collectgarbage(62,1452 +static void pdp_control_set_mem_limit(69,1636 +static void pdp_control_thread(79,1935 +static void pdp_control_send_drop_message(94,2237 +static void pdp_control_free(104,2455 +static void *pdp_control_new(122,2787 +void pdp_control_addmethod(136,3130 +void pdp_control_setup(141,3250 +void pdp_control_notify_broadcast(160,3967 +void pdp_control_notify_drop(173,4230 + +puredata/pdp_dpd_base.c,766 +#define THIS(THIS26,906 +static void _pdp_dpd_base_context_input(42,1071 +void *_pdp_dpd_base_get_command_object(79,1900 +void pdp_dpd_base_queue_command(84,1983 +void pdp_dpd_base_bang(94,2315 +int pdp_dpd_base_get_context_packet(134,3410 +int pdp_dpd_base_move_context_packet(138,3503 +void pdp_dpd_base_set_context_packet(145,3644 +void pdp_dpd_base_add_cleanup(152,3882 +void pdp_dpd_base_add_inspector(161,4152 +t_outlet *pdp_dpd_base_add_outlet(169,4351 +void pdp_dpd_base_free(191,4926 +void pdp_dpd_base_disable_active_inlet(200,5020 +void pdp_dpd_base_enable_outlet(208,5128 +void pdp_dpd_base_register_complete_notify(218,5319 +void pdp_dpd_base_register_command_factory_method(224,5445 +void pdp_dpd_base_init(232,5639 +void pdp_dpd_base_setup(260,6243 + +puredata/pdp_imagebase.c,183 +static void pdp_imagebase_chanmask(31,966 +void pdp_imagebase_setup(38,1105 +void pdp_imagebase_init(49,1370 +void pdp_imagebase_free(66,1729 +u32 pdp_imagebase_get_chanmask(74,1833 + +puredata/pdp_queue.c,815 +#define D 43,1343 +#define PDP_QUEUE_LOGSIZE 50,1401 +#define PDP_QUEUE_DELTIME 51,1430 +void pdp_procqueue_wait(70,1946 +void pdp_procqueue_finish(82,2354 +void pdp_procqueue_flush(100,2746 +static void pdp_procqueue_signal_processor(119,3133 +static void pdp_procqueue_wait_for_feeder(133,3566 +int pdp_procqueue_full(157,4173 +void pdp_procqueue_add(163,4273 +static void *pdp_procqueue_thread(210,5661 +static void pdp_procqueue_callback 244,6285 +static void pdp_procqueue_tick 262,6766 +void pdp_procqueue_use_thread(281,7094 +void pdp_procqueue_init(299,7482 +static t_pdp_procqueue pdp_queue;357,9087 +t_pdp_procqueue *pdp_queue_get_queue(361,9151 +void pdp_queue_wait(366,9263 +void pdp_queue_finish(367,9319 +void pdp_queue_add(368,9396 +void pdp_queue_use_thread(371,9549 +void pdp_queue_setup(372,9625 + +puredata/pdp_ut.c,1459 +t_class *pdp_ut_addscaleclip_class;32,1107 +typedef struct pdp_ut_addscaleclip_structpdp_ut_addscaleclip_struct34,1144 +} t_pdp_ut_addscaleclip;t_pdp_ut_addscaleclip42,1314 +static void pdp_ut_addscaleclip_float(45,1341 +static void pdp_ut_addscaleclip_free(54,1580 +void *pdp_ut_addscaleclip_new(56,1646 +void pdp_ut_addscaleclip_setup(67,2006 +t_class *pdp_ut_linmap_class;80,2589 +t_class *pdp_ut_logmap_class;81,2619 +t_class *pdp_ut_logmap_comp_class;82,2649 +typedef struct pdp_ut_map_structpdp_ut_map_struct84,2685 +} t_pdp_ut_map;t_pdp_ut_map90,2803 +static void pdp_ut_logmap_float(93,2821 +static void pdp_ut_linmap_float(103,3038 +static void pdp_ut_logmap_comp_float(113,3253 +static void pdp_ut_map_free(123,3484 +void pdp_ut_map_init(126,3533 +void *pdp_ut_logmap_new(133,3701 +void *pdp_ut_linmap_new(140,3885 +void *pdp_ut_logmap_comp_new(147,4069 +void pdp_ut_logmap_setup(154,4263 +void pdp_ut_logmap_comp_setup(162,4550 +void pdp_ut_linmap_setup(170,4867 +t_class *pdp_ut_rgb2ycrcb_class;180,5156 +typedef struct pdp_ut_rgb2ycrcbpdp_ut_rgb2ycrcb182,5190 +} t_pdp_ut_rgb2ycrcb;t_pdp_ut_rgb2ycrcb191,5382 +static void pdp_ut_rgb2ycrcb_bang 194,5406 +static void pdp_ut_rgb2ycrcb_red 208,5810 +static void pdp_ut_rgb2ycrcb_green 209,5929 +static void pdp_ut_rgb2ycrcb_blue 210,6048 +static void pdp_ut_rgb2ycrcb_free 214,6170 +static void* pdp_ut_rgb2ycrcb_new(215,6233 +void pdp_ut_rgb2ycrcb_setup(235,6799 +void pdp_ut_setup(250,7356 + +modules/generic/pdp_convert.c,311 +typedef struct pdp_convert_structpdp_convert_struct26,840 +} t_pdp_convert;t_pdp_convert33,968 +static void pdp_convert_type_mask(37,988 +static void pdp_convert_input_0(42,1082 +t_class *pdp_convert_class;62,1572 +void pdp_convert_free(66,1603 +void *pdp_convert_new(71,1690 +void pdp_convert_setup(89,1966 + +modules/generic/pdp_del.c,353 +typedef struct pdp_del_structpdp_del_struct26,840 +} t_pdp_del;t_pdp_del39,1033 +static void pdp_del_input_0(45,1051 +static void pdp_del_delay(100,2306 +static void pdp_del_reset(110,2484 +static void pdp_del_debug(121,2666 +static void pdp_del_free(132,2889 +t_class *pdp_del_class;138,2982 +void *pdp_del_new(142,3009 +void pdp_del_setup(176,3641 + +modules/generic/pdp_description.c,367 +typedef struct pdp_description_structpdp_description_struct27,841 +} t_pdp_description;t_pdp_description32,926 +static void pdp_description_input_pdp(37,951 +static void pdp_description_input_dpd(47,1200 +static void pdp_description_free(58,1446 +t_class *pdp_description_class;63,1507 +static void *pdp_description_new(67,1542 +void pdp_description_setup(83,1814 + +modules/generic/pdp_inspect.c,463 +#define TR_BANG 27,881 +#define TR_FLOAT 28,899 +#define TR_SYMBOL 29,918 +#define TR_POINTER 30,938 +#define TR_LIST 31,959 +#define TR_ANYTHING 32,977 +#define TR_PDP 33,999 +typedef struct pdp_inspect_structpdp_inspect_struct47,1294 +} t_pdp_inspect;t_pdp_inspect54,1393 +static void pdp_inspect_input_0(59,1414 +static void pdp_inspect_free(82,1897 +t_class *pdp_inspect_class;87,1950 +static void *pdp_inspect_new(91,1981 +void pdp_inspect_setup(108,2213 + +modules/generic/pdp_loop.c,627 +typedef struct pdp_loop_structpdp_loop_struct40,1146 +} t_pdp_loop;t_pdp_loop56,1596 +static void pdp_loop_input_0(62,1615 +static void pdp_loop_bang(91,2326 +static void pdp_loop_reset(118,2873 +static void pdp_loop_record(130,3086 +static void pdp_loop_store(142,3404 +static void pdp_loop_seek(152,3593 +static void pdp_loop_seek_hot(161,3748 +static void pdp_loop_stop(168,3860 +static void pdp_loop_loop(173,3937 +static void pdp_loop_free(179,4065 +static int pdp_loop_realsize(185,4161 +static void pdp_loop_resize(193,4278 +t_class *pdp_loop_class;240,5287 +void *pdp_loop_new(244,5315 +void pdp_loop_setup(274,5948 + +modules/generic/pdp_rawin.c,520 +#define PERIOD 39,1160 +#define D 40,1180 +typedef struct rawin_structrawin_struct47,1235 +} t_rawin;t_rawin72,1762 +static inline void lock(75,1775 +static inline void unlock(76,1843 +static void tick(79,1953 +static void move_current_to_queue(95,2309 +static void *rawin_thread(102,2465 +static void rawin_type(192,4202 +static void rawin_open(197,4300 +static void rawin_close(213,4653 +static void rawin_free(233,4972 +t_class *rawin_class;241,5131 +static void *rawin_new(244,5155 +void pdp_rawin_setup(281,5981 + +modules/generic/pdp_rawout.c,530 +#define D 41,1199 +#define MAX_QUEUESIZE 42,1216 +#define PIPE_BLOCKSIZE 43,1240 +typedef struct rawout_structrawout_struct50,1306 +} t_rawout;t_rawout74,1814 +static inline void lock(77,1828 +static inline void unlock(78,1897 +static void pdp_in(81,2010 +static void *rawout_thread(107,2548 +static void rawout_type(213,4587 +static void rawout_open(218,4687 +static void rawout_close(234,5043 +static void rawout_free(254,5364 +t_class *rawout_class;261,5498 +static void *rawout_new(264,5523 +void pdp_rawout_setup(299,6272 + +modules/generic/pdp_reg.c,393 +typedef struct pdp_reg_structpdp_reg_struct28,888 +} t_pdp_reg;t_pdp_reg37,1004 +static void pdp_reg_load_png(40,1019 +static void pdp_reg_save_png(55,1352 +static void pdp_reg_bang(73,1751 +static void pdp_reg_input_0(82,1867 +static void pdp_reg_input_1(103,2384 +static void pdp_reg_free(120,2838 +t_class *pdp_reg_class;126,2925 +void *pdp_reg_new(130,2952 +void pdp_reg_setup(150,3257 + +modules/generic/pdp_route.c,381 +#define PDP_ROUTE_MAX_NB_OUTLETS 27,882 +typedef struct pdp_route_structpdp_route_struct29,920 +} t_pdp_route;t_pdp_route41,1106 +static void pdp_route_input_0(44,1123 +static void pdp_route_input_0_dpd(62,1514 +static void pdp_route_route(77,1791 +static void pdp_route_free(90,2009 +t_class *pdp_route_class;95,2062 +void *pdp_route_new(99,2091 +void pdp_route_setup(130,2671 + +modules/generic/pdp_snap.c,321 +typedef struct pdp_snap_structpdp_snap_struct26,866 +} t_pdp_snap;t_pdp_snap36,1004 +static void pdp_snap_bang(39,1020 +static void pdp_snap_input_1(50,1141 +static void pdp_snap_snap(67,1591 +static void pdp_snap_free(72,1661 +t_class *pdp_snap_class;78,1750 +void *pdp_snap_new(82,1778 +void pdp_snap_setup(103,2114 + +modules/generic/pdp_trigger.c,595 +#define TR_BANG 28,908 +#define TR_FLOAT 29,926 +#define TR_SYMBOL 30,945 +#define TR_POINTER 31,965 +#define TR_LIST 32,986 +#define TR_ANYTHING 33,1004 +#define TR_PDP 34,1026 +typedef struct triggerouttriggerout48,1321 +} t_triggerout;t_triggerout52,1426 +typedef struct pdp_trigger_structpdp_trigger_struct55,1444 +} t_pdp_trigger;t_pdp_trigger63,1557 +static void pdp_trigger_input_pdp(68,1578 +static void pdp_trigger_input_dpd(93,2237 +static void pdp_trigger_free(119,2816 +t_class *pdp_trigger_class;124,2895 +static void *pdp_trigger_new(128,2926 +void pdp_trigger_setup(175,4067 + +modules/generic/pdp_udp_receive.c,359 +#define D 28,967 +typedef struct pdp_udp_receive_structpdp_udp_receive_struct30,984 +} t_pdp_udp_receive;t_pdp_udp_receive54,1379 +static void clock_tick(57,1402 +static void *receive_thread(68,1587 +static void pdp_udp_receive_free(133,3183 +t_class *pdp_udp_receive_class;147,3504 +void *pdp_udp_receive_new(151,3539 +void pdp_udp_receive_setup(191,4405 + +modules/generic/pdp_udp_send.c,768 +#define DD 36,1085 +#define D 37,1128 +#define V 38,1182 +typedef struct pdp_udp_send_structpdp_udp_send_struct40,1243 +} t_pdp_udp_send;t_pdp_udp_send68,1732 +static int _wait_for_feeder(76,1780 +static void _signal_sender(100,2364 +static void _wait_until_done(108,2536 +static void _remove_packet_from_queue(118,2772 +static void *send_thread(127,2839 +static void pdp_udp_send_input_0(166,3849 +static void pdp_udp_send_timeout(211,4891 +static void pdp_udp_send_sleepgrain(218,5043 +static void pdp_udp_send_sleepperiod(224,5200 +static void pdp_udp_send_udpsize(231,5347 +static void pdp_udp_send_connect(237,5493 +static void pdp_udp_send_free(255,5920 +t_class *pdp_udp_send_class;272,6338 +void *pdp_udp_send_new(276,6370 +void pdp_udp_send_setup(318,7309 + +modules/image_basic/pdp_add.c,241 +typedef struct pdp_add_structpdp_add_struct26,866 +} t_pdp_add;t_pdp_add32,1088 +static void pdp_add_process(36,1128 +static void pdp_add_free(56,1645 +t_class *pdp_add_class;66,1937 +void *pdp_add_new(69,1963 +void pdp_add_setup(97,2491 + +modules/image_basic/pdp_bq.c,1231 +typedef struct pdp_bq_structpdp_bq_struct36,1043 +} t_pdp_bq;t_pdp_bq61,1517 +static void pdp_bq_a0(66,1609 +static void pdp_bq_a1(67,1680 +static void pdp_bq_a2(68,1752 +static void pdp_bq_b0(70,1825 +static void pdp_bq_b1(71,1896 +static void pdp_bq_b2(72,1967 +static void pdp_bq_u0(74,2039 +static void pdp_bq_u1(75,2115 +static void pdp_bq_setcoefs(78,2193 +static void pdp_bq_setstate(91,2497 +static void pdp_bq_lpf(101,2683 +static void pdp_bq_hpf(121,3109 +static void pdp_bq_apf(143,3536 +static void pdp_bq_bsf(163,3970 +static void pdp_bq_onep(183,4356 +static void pdp_bq_twop(199,4637 +static void pdp_bqt_process(225,5026 +static void pdp_bq_process(237,5338 +static void pdp_bqt_reset(250,5738 +static void pdp_bqt_preproc(258,5950 +static void pdp_bq_passes(283,6643 +static void pdp_bq_lr(291,6793 +static void pdp_bq_rl(297,6988 +static void pdp_bq_tb(302,7182 +static void pdp_bq_bt(308,7377 +static void pdp_bq_hor(315,7573 +static void pdp_bq_ver(320,7669 +static void pdp_bq_free(329,7842 +void pdp_bq_init(339,8039 +t_class *pdp_bq_class;358,8314 +t_class *pdp_bqt_class;359,8371 +void *pdp_bq_new(361,8426 +void *pdp_bqt_new(375,8742 +void pdp_bq_coefmethods_setup(403,9186 +void pdp_bq_setup(426,10412 + +modules/image_basic/pdp_cheby.c,467 +typedef struct pdp_cheby_structpdp_cheby_struct29,942 +} t_pdp_cheby;t_pdp_cheby40,1150 +static double pdp_cheby_mappingfunction(44,1168 +static void pdp_cheby_coef(58,1508 +static void pdp_cheby_approx(63,1640 +static void pdp_cheby_process(96,2280 +static void pdp_cheby_reset(106,2570 +static void pdp_cheby_iterations(114,2717 +static void pdp_cheby_free(121,2844 +t_class *pdp_cheby_class;129,2993 +void *pdp_cheby_new(133,3022 +void pdp_cheby_setup(171,3802 + +modules/image_basic/pdp_constant.c,474 +typedef struct pdp_constant_structpdp_constant_struct27,867 +} t_pdp_constant;t_pdp_constant42,1080 +void pdp_constant_type(46,1101 +void pdp_constant_value(52,1181 +static void pdp_constant_process(62,1349 +static void pdp_constant_postproc(79,2011 +static void pdp_constant_bang(84,2128 +static void pdp_constant_dim(89,2204 +static void pdp_constant_free(97,2443 +t_class *pdp_constant_class;104,2567 +void *pdp_constant_new(108,2599 +void pdp_constant_setup(144,3324 + +modules/image_basic/pdp_conv.c,693 +typedef struct pdp_conv_structpdp_conv_struct27,867 +} t_pdp_conv;t_pdp_conv39,1059 +static void pdp_conv_process(43,1076 +static void pdp_conv_passes(62,1589 +static void pdp_conv_hor(69,1742 +static void pdp_conv_ver(75,1857 +static void pdp_conv_free(80,1969 +static void pdp_conv_hleft(89,2163 +static void pdp_conv_hmiddle(94,2279 +static void pdp_conv_hright(98,2396 +static void pdp_conv_hmask(103,2514 +static void pdp_conv_vtop(110,2678 +static void pdp_conv_vmiddle(114,2792 +static void pdp_conv_vbottom(119,2910 +static void pdp_conv_vmask(124,3029 +static void pdp_conv_mask(132,3194 +t_class *pdp_conv_class;138,3342 +void *pdp_conv_new(142,3370 +void pdp_conv_setup(181,4307 + +modules/image_basic/pdp_gain.c,276 +typedef struct pdp_gain_structpdp_gain_struct27,867 +} t_pdp_gain;t_pdp_gain32,947 +static void pdp_gain_process(37,965 +static void pdp_gain_gain(48,1229 +t_class *pdp_gain_class;55,1337 +void pdp_gain_free(59,1365 +void *pdp_gain_new(65,1473 +void pdp_gain_setup(96,2017 + +modules/image_basic/pdp_logic.c,952 +typedef struct pdp_logic_structpdp_logic_struct26,866 +} t_pdp_logic;t_pdp_logic32,951 +static void pdp_logic_process_and(35,968 +static void pdp_logic_process_or(43,1227 +static void pdp_logic_process_xor(51,1484 +static void pdp_logic_process_not(59,1743 +static void pdp_logic_process_mask(66,1958 +static void pdp_logic_process_softthresh(73,2183 +static void pdp_logic_process_hardthresh(81,2421 +static void pdp_logic_set_mask(89,2659 +static void pdp_logic_set_threshold(96,2837 +static void pdp_logic_set_depth(104,3059 +static void pdp_logic_free(116,3307 +t_class *pdp_logic_class;122,3446 +void *pdp_logic_new(126,3498 +void *pdp_logic_new_and(140,3732 +void *pdp_logic_new_or(150,3960 +void *pdp_logic_new_xor(159,4185 +void *pdp_logic_new_not(168,4412 +void *pdp_logic_new_mask(176,4606 +void *pdp_logic_new_depth(187,4901 +void *pdp_logic_new_softthresh(198,5198 +void *pdp_logic_new_hardthresh(210,5521 +void pdp_logic_setup(228,5885 + +modules/image_basic/pdp_mix.c,482 +typedef struct pdp_mix_structpdp_mix_struct26,866 +} t_pdp_mix;t_pdp_mix37,1027 +static void pdp_mix_process(40,1042 +static void pdp_mix_mix(49,1303 +static void pdp_mix_mix1(63,1583 +static void pdp_mix_mix2(68,1691 +static void pdp_mix_extrapolate(73,1802 +static void pdp_mix_free(80,1950 +t_class *pdp_mix_class;86,2063 +t_class *pdp_mix2_class;87,2087 +void *pdp_mix_common_init(90,2114 +void *pdp_mix_new(107,2447 +void *pdp_mix2_new(118,2713 +void pdp_mix_setup(139,3165 + +modules/image_basic/pdp_mul.c,239 +typedef struct pdp_mul_structpdp_mul_struct26,866 +} t_pdp_mul;t_pdp_mul30,927 +static void pdp_mul_process(34,943 +static void pdp_mul_free(44,1196 +t_class *pdp_mul_class;49,1267 +void *pdp_mul_new(53,1294 +void pdp_mul_setup(73,1627 + +modules/image_basic/pdp_noise.c,433 +typedef struct pdp_noise_structpdp_noise_struct27,867 +} t_pdp_noise;t_pdp_noise40,1079 +void pdp_noise_type(44,1097 +void pdp_noise_random(50,1171 +static void pdp_noise_process(58,1364 +static void pdp_noise_postproc(78,1986 +static void pdp_noise_bang(83,2097 +static void pdp_noise_dim(88,2167 +static void pdp_noise_free(96,2400 +t_class *pdp_noise_class;105,2584 +void *pdp_noise_new(108,2612 +void pdp_noise_setup(142,3226 + +modules/image_basic/pdp_plasma.c,483 +typedef struct pdp_plasma_structpdp_plasma_struct27,867 +} t_pdp_plasma;t_pdp_plasma40,1081 +void pdp_plasma_type(44,1100 +void pdp_plasma_random(50,1176 +void pdp_plasma_turbulence(57,1341 +static void pdp_plasma_process(64,1495 +static void pdp_plasma_postproc(80,2107 +static void pdp_plasma_bang(85,2220 +static void pdp_plasma_dim(90,2292 +static void pdp_plasma_free(98,2527 +t_class *pdp_plasma_class;107,2714 +void *pdp_plasma_new(110,2743 +void pdp_plasma_setup(147,3476 + +modules/image_basic/pdp_randmix.c,351 +typedef struct pdp_randmix_structpdp_randmix_struct26,866 +} t_pdp_randmix;t_pdp_randmix31,955 +void pdp_randmix_random(34,974 +static void pdp_randmix_process(40,1096 +static void pdp_randmix_threshold(50,1374 +static void pdp_randmix_free(58,1507 +t_class *pdp_randmix_class;64,1636 +void *pdp_randmix_new(67,1666 +void pdp_randmix_setup(97,2203 + +modules/image_basic/pdp_stateless.c,851 +typedef struct pdp_stateless_structpdp_stateless_struct26,899 +} t_pdp_stateless;t_pdp_stateless30,966 +static void pdp_stateless_process_abs(34,988 +static void pdp_stateless_process_hardthresh(41,1211 +static void pdp_stateless_process_zthresh(48,1448 +static void pdp_stateless_process_positive(55,1679 +static void pdp_stateless_process_sign(62,1914 +static void pdp_stateless_process_flip_tb(69,2139 +static void pdp_stateless_process_flip_lr(76,2370 +static void pdp_stateless_free(83,2601 +t_class *pdp_stateless_class;89,2748 +void *pdp_stateless_new(93,2804 +void *pdp_stateless_new_abs(106,3035 +void *pdp_stateless_new_zthresh(114,3245 +void *pdp_stateless_new_positive(122,3463 +void *pdp_stateless_new_sign(130,3683 +void *pdp_stateless_new_flip_tb(138,3895 +void *pdp_stateless_new_flip_lr(147,4114 +void pdp_stateless_setup(162,4374 + +modules/image_basic/pdp_zoom.c,720 +typedef struct pdp_zoom_structpdp_zoom_struct28,868 +} t_pdp_zoom;t_pdp_zoom39,1029 +static void pdp_zoom_process(42,1045 +static void pdp_zoom_postproc(49,1291 +static void pdp_zoom_preproc(58,1544 +static void pdp_zoom_zoom_x(70,1776 +static void pdp_zoom_angle(75,1899 +static void pdp_zoom_zoom_y(80,2021 +static void pdp_zoom_zoom(85,2144 +static void pdp_zoom_center_x(91,2258 +static void pdp_zoom_center_y(96,2385 +static void pdp_zoom_center(100,2511 +static void pdp_zoom_quality(107,2661 +t_class *pdp_zoom_class;114,2789 +void pdp_zoom_free(118,2817 +void pdp_zoom_init_common(126,2982 +void *pdp_zoom_new(145,3556 +void *pdp_zrot_new(159,3865 +void *pdp_rotate_new(175,4259 +void pdp_zoom_setup(196,4581 + +modules/image_io/pdp_glx.c,1138 +#define PDP_OGL_W 41,1133 +#define PDP_OGL_H 42,1155 +#define PDP_OGL_AUTOCREATE_RETRY 44,1178 +typedef struct pdp_glx_structpdp_glx_struct47,1216 +} t_pdp_glx;t_pdp_glx76,1696 +static void pdp_glx_cursor(80,1712 +static void pdp_glx_destroy(86,1833 +static void pdp_glx_fullscreen(105,2214 +static void pdp_glx_resize(111,2326 +static void pdp_glx_move(117,2482 +static void pdp_glx_moveresize(123,2634 +static void pdp_glx_tile(129,2844 +void pdp_glx_generate_texture(138,3035 +void pdp_glx_regenerate_texture(169,3877 +static void pdp_glx_create(176,4033 +static int pdp_glx_try_autocreate(242,5654 +static void pdp_glx_fill_texture(264,6116 +static void pdp_glx_process(314,7555 +static void pdp_glx_display_texture(354,8405 +static void pdp_glx_bang_thread(403,9882 +static void pdp_glx_bang_callback(412,9996 +static void pdp_glx_bang(431,10466 +static void pdp_glx_input_0(456,10944 +static void pdp_glx_vga(465,11160 +static void pdp_glx_autocreate(470,11236 +static void pdp_glx_display(476,11389 +static void pdp_glx_free(490,11663 +t_class *pdp_glx_class;499,11909 +void *pdp_glx_new(503,11936 +void pdp_glx_setup(543,12535 + +modules/image_io/pdp_qt.c,1241 +#define min(min29,926 +#define FREE(FREE33,962 +#define DEBUG_MSG(DEBUG_MSG41,1117 +#define DEBUG_MSG(DEBUG_MSG47,1292 +typedef struct pdp_qt_structpdp_qt_struct50,1328 +} t_pdp_qt;t_pdp_qt122,2847 +static void pdp_qt_close(127,2900 +void pdp_qt_create_pdp_packet(171,3754 +static void pdp_qt_open(207,4629 +static void pdp_qt_bangaudio(408,10700 +static void pdp_qt_bangvideo(492,13003 +static void pdp_qt_sendpacket(552,14436 +static void pdp_qt_thread_bang(565,14691 +static void pdp_qt_bang(582,15094 +static void pdp_qt_loop(651,16779 +static void pdp_qt_autoplay(657,16896 +static void pdp_qt_frame_cold(671,17118 +static void pdp_qt_frame(689,17486 +static void pdp_qt_stop(695,17610 +static void pdp_qt_continue(700,17679 +static void pdp_qt_play(707,17773 +static void pdp_qt_importaudio(715,17870 +static t_int *pdp_qt_perform(773,19408 +static void pdp_qt_dsp(832,20981 +static void pdp_qt_process_in_thread(838,21113 +static void pdp_qt_tick(849,21309 +static void pdp_qt_free(856,21396 +t_class *pdp_qt_class;867,21549 +t_class *pdp_qt_tilde_class;868,21572 +void pdp_qt_init_common(871,21603 +void *pdp_qt_new(904,22353 +void *pdp_qt_tilde_new(913,22538 +void pdp_qt_setup_common(936,22979 +void pdp_qt_setup(953,24135 + +modules/image_io/pdp_sdl.c,1202 +#define PDP_SDL_W 43,1155 +#define PDP_SDL_H 44,1177 +typedef struct pdp_sdl_struct pdp_sdl_struct47,1201 +} t_pdp_sdl;t_pdp_sdl75,1656 +static SDL_Surface *pdp_sdl_getSurface(77,1670 +static SDL_Surface *pdp_sdl_recreateSurface(127,3100 +static inline void pdp_sdl_getOverlay(133,3421 +static inline void pdp_sdl_freeOverlay(137,3583 +static int pdp_sdl_drawImage(141,3683 +static inline void pdp_sdl_recreate(175,4770 +static int pdp_sdl_create(179,4975 +static void pdp_sdl_checkEvents(205,5681 +static void pdp_sdl_process(237,6278 +static void pdp_sdl_destroy(274,7142 +static void pdp_sdl_random(283,7319 +static void pdp_sdl_bang_thread(292,7619 +static void pdp_sdl_bang_callback(297,7785 +static void pdp_sdl_bang(305,7977 +static void pdp_sdl_input_0(315,8248 +static void pdp_sdl_resize(322,8463 +static void pdp_sdl_fullscreen(333,8760 +static void pdp_sdl_cursor(342,8947 +static void pdp_sdl_win(352,9141 +static void pdp_sdl_renderer(362,9433 +static void pdp_sdl_free(376,9741 +static void pdp_sdl_listmodes(384,9907 +static void pdp_sdl_modes(408,10483 +static void pdp_sdl_info(416,11123 +t_class *pdp_sdl_class;433,12178 +void *pdp_sdl_new(435,12203 +void pdp_sdl_setup(474,12776 + +modules/image_io/pdp_v4l.c,1063 +#define PDP_XV_RETRIES 47,1400 +#define DEVICENO 55,1502 +#define NBUF 56,1521 +#define COMPOSITEIN 57,1536 +typedef struct pdp_v4l_structpdp_v4l_struct62,1562 +} t_pdp_v4l;t_pdp_v4l118,2658 +static void pdp_v4l_audio(124,2676 +static void pdp_v4l_close(148,3424 +static void pdp_v4l_close_manual(174,3873 +static void pdp_v4l_close_error(181,3986 +static void pdp_v4l_pwc_init(188,4103 +static void pdp_v4l_sync_frame(249,5459 +static void pdp_v4l_capture_frame(258,5670 +static void *pdp_v4l_thread(277,6275 +static void pdp_v4l_open(306,6837 +#define TRYPALETTE(TRYPALETTE448,10778 +static void pdp_v4l_open_manual(505,12283 +static void pdp_v4l_channel(512,12416 +static void pdp_v4l_norm(525,12652 +static void pdp_v4l_freq(545,13079 +static void pdp_v4l_freqMHz(558,13368 +static void pdp_v4l_bang(564,13457 +static void pdp_v4l_setlegaldim(690,16501 +static void pdp_v4l_dim(708,16929 +static void pdp_v4l_format(721,17196 +static void pdp_v4l_free(740,17711 +t_class *pdp_v4l_class;745,17777 +void *pdp_v4l_new(749,17804 +void pdp_v4l_setup(810,18951 + +modules/image_io/pdp_xv.c,993 +#define PDP_XV_AUTOCREATE_RETRY 30,977 +typedef struct pdp_xv_structpdp_xv_struct33,1014 +} t_pdp_xv;t_pdp_xv53,1310 +static void pdp_xv_cursor(56,1324 +static void _pdp_xv_cleanup(62,1463 +static void _pdp_xv_waitforthread(74,1768 +static void pdp_xv_destroy(82,2021 +static void pdp_xv_create(98,2388 +static int pdp_xv_try_autocreate(126,3053 +static void pdp_xv_bang_thread(148,3506 +static void pdp_xv_bang_callback(154,3623 +static void pdp_xv_poll(175,4123 +static void pdp_xv_bang(181,4217 +static void pdp_xv_input_0(202,4751 +static void pdp_xv_autocreate(212,4994 +static void pdp_xv_display(218,5144 +static void pdp_xv_movecursor(230,5367 +static void pdp_xv_fullscreen(239,5570 +static void pdp_xv_resize(245,5680 +static void pdp_xv_move(251,5834 +static void pdp_xv_moveresize(257,5984 +static void pdp_xv_tile(263,6192 +static void pdp_xv_vga(269,6378 +static void pdp_xv_free(274,6451 +t_class *pdp_xv_class;279,6516 +void *pdp_xv_new(283,6542 +void pdp_xv_setup(309,6928 + +modules/image_special/pdp_array.c,410 +typedef struct _pdp_array_pdp_array28,912 +} t_pdp_array;t_pdp_array38,1099 +static void pdp_array_bang(41,1119 +static void pdp_array_input_0(47,1203 +static void pdp_array_array(107,2736 +static void pdp_array_free(115,2890 +t_class *pdp_array2grey_class;121,2987 +t_class *pdp_grey2array_class;122,3019 +void *pdp_array2grey_new(126,3057 +void *pdp_grey2array_new(133,3235 +void pdp_array_setup(155,3638 + +modules/image_special/pdp_chrot.c,393 +typedef struct pdp_chrot_structpdp_chrot_struct28,880 +} t_pdp_chrot;t_pdp_chrot35,982 +static void pdp_chrot_process(39,1000 +static void pdp_chrot_setelement(73,1733 +static void pdp_chrot_angle_radians(79,1841 +static void pdp_chrot_angle_degrees(92,2173 +static void pdp_chrot_free(98,2307 +t_class *pdp_chrot_class;104,2423 +void *pdp_chrot_new(108,2452 +void pdp_chrot_setup(130,2891 + +modules/image_special/pdp_cog.c,401 +typedef struct pdp_cog_structpdp_cog_struct28,977 +} t_pdp_cog;t_pdp_cog42,1257 +static void _pdp_cog_perform(45,1275 +static void pdp_cog_perform(140,3185 +static void pdp_cog_input_0(154,3496 +static void pdp_cog_threshold(173,3914 +static void pdp_cog_free(180,4035 +t_class *pdp_cog_class;186,4128 +void *pdp_cog_new(190,4159 +void *pdp_cog_abs_thresh_new(208,4609 +void pdp_cog_setup(225,4925 + +modules/image_special/pdp_grey2mask.c,487 +typedef struct pdp_grey2mask_structpdp_grey2mask_struct28,1011 +} t_pdp_grey2mask;t_pdp_grey2mask40,1173 +static void pdp_grey2mask_process_grey(44,1195 +static void pdp_grey2mask_process_yv12(81,2342 +static void pdp_grey2mask_process(89,2488 +static void pdp_grey2mask_sendpacket(117,3098 +static void pdp_grey2mask_input_0(123,3270 +static void pdp_grey2mask_free(147,3879 +t_class *pdp_grey2mask_class;155,4070 +void *pdp_grey2mask_new(159,4103 +void pdp_grey2mask_setup(180,4393 + +modules/image_special/pdp_histo.c,796 +typedef void (*t_histo_proc)t_histo_proc28,930 +typedef struct _pdp_histo_pdp_histo31,986 +} t_pdp_histo;t_pdp_histo55,1553 +static int round_up_2log(58,1573 +static void dump_to_array(73,1777 +static void get_sampleset(106,2622 +static void get_brightest(193,5011 +static void _pdp_histo_perform(229,5871 +static void pdp_histo_perform(268,6655 +static void pdp_histo_input_0(284,7052 +static void pdp_histo_samplesize(304,7481 +static void pdp_histo_scale(311,7614 +static void pdp_histo_size(315,7696 +static void pdp_histo_array(323,7844 +static void pdp_histo_free(330,7974 +t_class *pdp_histo_class;336,8071 +void *pdp_histo_new(340,8104 +void *pdp_histo_array_new(353,8364 +void *pdp_histo_sample_new(363,8648 +void *pdp_histo_sample_matrix_new(379,9181 +void pdp_histo_setup(393,9436 + +modules/image_special/pdp_scale.c,581 +typedef struct pdp_scale_structpdp_scale_struct28,867 +} t_pdp_scale;t_pdp_scale46,1122 +static void pdp_scale_process_yv12(49,1139 +static void pdp_scale_process_grey(87,2654 +static void pdp_scale_sendpacket(112,3443 +static void pdp_scale_process(122,3709 +static void pdp_scale_input_0(173,4923 +static void pdp_scale_width(194,5318 +static void pdp_scale_height(201,5445 +static void pdp_scale_dim(209,5575 +static void pdp_scale_quality(215,5705 +t_class *pdp_scale_class;222,5835 +void pdp_scale_free(226,5864 +void *pdp_scale_new(234,6081 +void pdp_scale_setup(259,6522 + +modules/image_special/pdp_scan.c,406 +#define PDP_SCAN_COSTABLE_SIZE 27,878 +static float pdp_cos[28,914 +typedef struct pdp_scan_structpdp_scan_struct30,961 +} t_pdp_scan;t_pdp_scan49,1228 +static t_int *pdp_scan_perform(52,1244 +static void pdp_scan_input_0(122,3354 +static void pdp_scan_interpolate(164,4413 +static void pdp_scan_free(173,4607 +t_class *pdp_scan_class;179,4696 +void *pdp_scan_new(183,4724 +void pdp_scan_setup(210,5164 + +modules/image_special/pdp_scanxy.c,360 +typedef struct pdp_scanxy_structpdp_scanxy_struct26,857 +} t_pdp_scanxy;t_pdp_scanxy40,1045 +static t_int *pdp_scanxy_perform(43,1063 +static void pdp_scanxy_input_0(107,2727 +static void pdp_scanxy_interpolate(149,3810 +static void pdp_scanxy_free(158,4008 +t_class *pdp_scanxy_class;164,4101 +void *pdp_scanxy_new(168,4131 +void pdp_scanxy_setup(190,4508 + +modules/image_special/pdp_scope.c,756 +#define BUFSIZE 26,859 +typedef struct pdp_scope_datapdp_scope_data28,881 +}t_pdp_scope_data;t_pdp_scope_data32,944 +typedef struct pdp_scope_structpdp_scope_struct34,964 +} t_pdp_scope;t_pdp_scope54,1259 +void pdp_scope_type(58,1277 +static void pdp_scope_createpacket_yv12(71,1525 +static void pdp_scope_generate_yv12(92,2053 +static void pdp_scope_createpacket_grey(120,2635 +static void pdp_scope_generate_grey(147,3255 +static void pdp_scope_sendpacket(172,3816 +static void pdp_scope_bang(179,3959 +static void pdp_scope_dim(214,4701 +static void pdp_scope_free(224,4903 +static t_int *pdp_scope_perform(237,5179 +static void pdp_scope_dsp(256,5516 +t_class *pdp_scope_class;262,5645 +void *pdp_scope_new(267,5675 +void pdp_scope_setup(300,6213 + +modules/matrix_basic/clusterstuff.c,1094 +typedef void (*t_histo_proc)t_histo_proc28,930 +typedef struct _cluster_cluster32,1012 +} t_cluster;t_cluster37,1084 +typedef struct _pdp_histo_pdp_histo41,1104 +} t_pdp_histo;t_pdp_histo68,1826 +static void cluster_join(72,1888 +static void cluster_copy(82,2151 +static void cluster_clear(89,2279 +static void cluster_new(94,2346 +static float cluster_dsquared(101,2461 +static int round_up_2log(109,2625 +static void compute_clusters(124,2829 +static void dump_to_array(217,5168 +static void get_sampleset(250,6013 +static void get_brightest(314,7840 +static void _pdp_histo_perform(350,8700 +static void pdp_histo_perform(389,9484 +static void pdp_histo_input_0(405,9881 +static void pdp_histo_samplesize(425,10310 +static void pdp_histo_clusters(431,10458 +static void pdp_histo_scale(440,10685 +static void pdp_histo_size(444,10767 +static void pdp_histo_array(452,10915 +static void pdp_histo_free(459,11045 +t_class *pdp_histo_class;466,11192 +void *pdp_histo_new(470,11225 +void *pdp_histo_array_new(485,11535 +void *pdp_histo_sample_new(495,11819 +void pdp_histo_setup(518,12437 + +modules/matrix_basic/pdp_mat_lu.c,492 +typedef struct pdp_mat_LU_structpdp_mat_LU_struct29,1002 +} t_pdp_mat_LU;t_pdp_mat_LU33,1061 +static void pdp_mat_LU_process_LU_inverse(37,1080 +static void pdp_mat_LU_process_LU(44,1289 +static void pdp_mat_LU_process_LU_solve(51,1479 +static void pdp_mat_LU_free(74,1992 +t_class *pdp_mat_LU_class;80,2128 +t_pdp_mat_LU *pdp_mat_LU_base_new(84,2182 +void *pdp_mat_LU_inverse_new(92,2359 +void *pdp_mat_LU_new(101,2586 +void *pdp_mat_LU_solve_new(109,2796 +void pdp_mat_lu_setup(124,3090 + +modules/matrix_basic/pdp_mat_mul.c,778 +typedef struct pdp_mat_mm_structpdp_mat_mm_struct29,1006 +} t_pdp_mat_mm;t_pdp_mat_mm40,1192 +static void pdp_mat_mm_rscale(43,1210 +static void pdp_mat_mm_cscale(49,1323 +static void pdp_mat_mv_process_mul(57,1470 +static void pdp_mat_mm_process_mul(93,2263 +static void pdp_mat_mm_process_mac(121,2960 +static void pdp_mat_mm_free(139,3411 +t_class *pdp_mat_mm_class;145,3547 +void *pdp_mat_mm_new(149,3600 +static int pdp_mat_mm_setup_routing_M0(165,3827 +static int pdp_mat_mm_setup_routing_M1(177,4298 +static int pdp_mat_mm_setup_scaling(192,4822 +void *pdp_mat_mm_new_mul_common(208,5304 +void *pdp_mat_mv_new_mul_common(229,5856 +void *pdp_mat_mm_new_mul(249,6336 +void *pdp_mat_mv_new_mul(259,6616 +void *pdp_mat_mm_new_mac(269,6878 +void pdp_mat_mul_setup(285,7165 + +modules/matrix_basic/pdp_mat_vec.c,491 +typedef struct pdp_mat_vec_structpdp_mat_vec_struct29,993 +} t_pdp_mat_vec;t_pdp_mat_vec38,1154 +#define GETFLOAT(GETFLOAT41,1173 +#define GETDOUBLE(GETDOUBLE42,1244 +static void pdp_mat_vec_list_in(45,1287 +static void pdp_mat_vec_list_out(87,2364 +static void pdp_mat_vec_free(136,3679 +t_class *pdp_mat_vec_class;145,3884 +t_pdp_mat_vec *pdp_mat_vec_base_new(149,3939 +void *pdp_mat_vec_list2vec_new(160,4198 +void *pdp_mat_vec_vec2list_new(178,4814 +void pdp_mat_vec_setup(194,5143 + +modules/test/pdp_dpd_test.c,473 +typedef struct pdp_dpd_test_structpdp_dpd_test_struct26,865 +} t_pdp_dpd_test;t_pdp_dpd_test30,930 +static void pdp_dpd_test_1(35,972 +static void pdp_dpd_test_2(36,1039 +static void pdp_dpd_test_3(37,1106 +static void pdp_dpd_test_cleanup(38,1175 +static void pdp_dpd_test_inspect(39,1252 +static void pdp_dpd_test_bang(43,1332 +static void pdp_dpd_test_free(53,1538 +t_class *pdp_dpd_test_class;59,1619 +void *pdp_dpd_test_new(62,1650 +void pdp_dpd_test_setup(89,2285 + +scaf/pdp/pdp_ca.c,1904 +t_class *pdp_ca_class;28,928 +t_class *pdp_ca2image_class;30,1116 +t_class *pdp_image2ca_class;31,1181 +#define PDP_CA_STACKSIZE 40,1400 +#define PDP_CA_MODE_1D 41,1429 +#define PDP_CA_MODE_2D 42,1454 +typedef struct pdp_ca_data_structpdp_ca_data_struct44,1480 +} t_pdp_ca_data;t_pdp_ca_data50,1644 +typedef struct pdp_ca_structpdp_ca_struct52,1662 +} t_pdp_ca;t_pdp_ca89,2361 +static void pdp_ca_process_ca_1D(93,2417 +static void pdp_ca_process_ca_2D(180,4994 +static void pdp_ca_swappackets(301,8735 +static void pdp_ca_bang_thread(314,8933 +static void pdp_ca_sendpacket(353,9963 +static void pdp_ca_bang(387,10851 +static void pdp_ca_copy_rw_if_valid(412,11452 +static void pdp_ca_input_0(453,12584 +static void pdp_ca_input_1(467,12824 +static void pdp_ca_rule_string(478,12984 +static void pdp_ca_rule(498,13410 +static void pdp_ca_rule_index(507,13605 +static void pdp_ca_close(524,13914 +static void pdp_ca_printrules(540,14157 +static void pdp_ca_openlib(552,14414 +static void pdp_ca_opensrc(605,15632 + #define TMPSIZE 607,15687 +static void pdp_ca_open(631,16222 +static void pdp_ca_rand(652,16672 +static void pdp_ca_newca(666,17005 +static void pdp_ca_iterations(680,17340 +static void pdp_ca_horshift16(689,17468 +static void pdp_ca_vershift(694,17560 +static void pdp_ca_set1d(699,17645 +static void pdp_ca_set2d(704,17720 +static void pdp_ca_fullscreen1d(709,17795 +static void pdp_ca_free(715,17943 +void *pdp_ca_new(725,18113 +#define PDP_CA2IMAGE 762,19108 +#define PDP_IMAGE2CA 763,19131 +typedef struct pdp_ca_conv_structpdp_ca_conv_struct765,19155 +} t_pdp_ca_conv;t_pdp_ca_conv784,19440 +static void pdp_ca_conv_input_0(787,19481 +void pdp_ca_conv_free(824,20297 +void pdp_image2ca_threshold(830,20385 +void *pdp_ca2image_new(840,20567 +void *pdp_image2ca_new(850,20840 +void pdp_ca2image_setup(872,21338 +void pdp_image2ca_setup(879,21644 +void pdp_ca_setup(887,22064 + +scaf/pdp/pdp_ca_system.c,505 +int pdp_packet_ca_isvalid(32,1018 +static t_pdp_symbol *pdp_packet_ca_get_description(43,1266 +int pdp_packet_new_ca(69,1950 +inline void _pdp_type_ca2grey_convert_word(113,2977 +int pdp_type_ca2grey(123,3209 +#define check_srcindex 156,4199 +#define check_dstindex 159,4301 +inline unsigned short int _pdp_type_grey2ca_convert_word(220,5826 +int pdp_type_grey2ca(236,6082 +t_ca *pdp_type_ca_info(274,7102 +static int _ca_to_image(282,7258 +static int _image_to_ca(287,7360 +void pdp_scaf_setup(293,7513 + +scaf/compiler/scafmacro.s,0 + +scaf/pdp/scaf_feeder.s,103 +.include .include20,837 +.globl .globl26,1049 +.type .type27,1068 +scaf_feeder:scaf_feeder28,1097 + +opengl/modules/pdp_3d_color.c,630 +typedef struct _color_command_color_command27,891 +} t_color_command;t_color_command33,1022 +typedef struct _pdp_3d_color_pdp_3d_color35,1042 +} t_pdp_3d_color;t_pdp_3d_color45,1213 +static void pdp_3d_color_process_right(50,1256 +static void pdp_3d_color_process_left(65,1562 +static void *pdp_3d_color_get_new_command(81,1901 +static void pdp_3d_color_set_r(93,2279 +static void pdp_3d_color_set_g(94,2359 +static void pdp_3d_color_set_b(95,2441 +static void pdp_3d_color_set_a(96,2522 +t_class *pdp_3d_color_class;99,2606 +void pdp_3d_color_free(102,2637 +void *pdp_3d_color_new(107,2710 +void pdp_3d_color_setup(146,3726 + +opengl/modules/pdp_3d_context.c,478 +typedef struct pdp_3d_context_structpdp_3d_context_struct28,886 +} t_pdp_3d_context;t_pdp_3d_context43,1096 +static void pdp_3d_context_preproc(49,1121 +static void pdp_3d_context_process(79,1790 +static void pdp_3d_context_postproc(83,1851 +static void pdp_3d_context_bang(88,1965 +static void pdp_3d_context_dim(93,2045 +static void pdp_3d_context_free(101,2288 +t_class *pdp_3d_context_class;108,2411 +void *pdp_3d_context_new(112,2445 +void pdp_3d_context_setup(146,3113 + +opengl/modules/pdp_3d_dlist.c,431 +typedef struct pdp_3d_dlist_structpdp_3d_dlist_struct29,938 +} t_pdp_3d_dlist;t_pdp_3d_dlist36,1043 +static void pdp_3d_dlist_complete_notify(40,1064 +static void pdp_3d_dlist_compile(46,1206 +static void pdp_3d_dlist_process_start(53,1363 +static void pdp_3d_dlist_process_cleanup(82,2019 +t_class *pdp_3d_dlist_class;120,2576 +void pdp_3d_dlist_free(124,2608 +void *pdp_3d_dlist_new(130,2731 +void pdp_3d_dlist_setup(164,3439 + +opengl/modules/pdp_3d_draw.c,1391 +typedef struct _drawcommand_drawcommand29,932 +} t_drawcommand;t_drawcommand42,1225 +typedef struct _pdp_3d_draw_pdp_3d_draw45,1244 +} t_pdp_3d_draw;t_pdp_3d_draw60,1538 +void pdp_3d_draw_delete_texture(63,1557 +void *pdp_3d_draw_get_command_object(69,1678 +static void draw_clear(88,2305 +static void draw_square(94,2408 +static void draw_wsquare(112,2801 +static void draw_triangle(125,3056 +static void draw_wtriangle(146,3561 +static void draw_wcube(163,3927 +static void draw_cube(168,4001 +static void draw_wtorus(194,4475 +static void draw_torus(208,4703 +static void draw_cone(222,4931 +static void draw_wcone(236,5169 +static void draw_wteapot(250,5407 +static void draw_teapot(257,5502 +static void draw_wsphere(264,5597 +static void draw_sphere(277,5797 +static void draw_dodeca(292,6038 +static void draw_octa(293,6106 +static void draw_tetra(294,6172 +static void draw_icosa(295,6239 +static void draw_wdodeca(297,6307 +static void draw_wocta(298,6375 +static void draw_wtetra(299,6441 +static void draw_wicosa(300,6508 +static void draw_process(310,6698 +static void pdp_3d_draw_p0(369,8362 +static void pdp_3d_draw_p1(370,8435 +static void pdp_3d_draw_p2(371,8508 +static void pdp_3d_draw_p3(372,8581 +t_class *pdp_3d_draw_class;375,8656 +void pdp_3d_draw_free(379,8687 +void pdp_3d_draw_object(386,8840 +void *pdp_3d_draw_new(427,11462 +void pdp_3d_draw_setup(480,12582 + +opengl/modules/pdp_3d_drawmesh.c,1326 +typedef struct _pdp_3d_drawmesh_pdp_3d_drawmesh38,1107 +} t_pdp_3d_drawmesh;t_pdp_3d_drawmesh47,1273 +typedef struct _meshcommand_meshcommand52,1322 +} t_meshcommand;t_meshcommand67,1617 +static void meshcommand_draw(73,1683 +static void meshcommand_relax(106,2302 +static void meshcommand_execute(113,2459 +static void meshcommand_split_all_four(133,2896 +static void meshcommand_split_all_three(137,3003 +static void meshcommand_split_random_three(140,3111 +static void meshcommand_reset(145,3227 +static void meshcommand_debug(151,3360 +static void meshcommand_calculate_normals(156,3450 +void *pdp_3d_drawmesh_get_command_object(169,3684 +static void pdp_3d_drawmesh_queue_command(182,4122 +static void pdp_3d_drawmesh_queue_simple_command(187,4288 +static void pdp_3d_drawmesh_debug(198,4709 +static void pdp_3d_drawmesh_relax(203,4848 +void pdp_3d_drawmesh_normal(215,5193 +void pdp_3d_drawmesh_wireframe(228,5833 +void pdp_3d_drawmesh_flatshading(233,5936 +static void pdp_3d_drawmesh_split_all_four(239,6044 +static void pdp_3d_drawmesh_split_all_three(244,6201 +static void pdp_3d_drawmesh_split_random_three(249,6360 +static void pdp_3d_drawmesh_reset(255,6526 +t_class *pdp_3d_drawmesh_class;270,6675 +void pdp_3d_drawmesh_free(273,6709 +void *pdp_3d_drawmesh_new(283,6948 +void pdp_3d_drawmesh_setup(316,7754 + +opengl/modules/pdp_3d_for.c,306 +typedef struct pdp_3d_for_structpdp_3d_for_struct28,966 +} t_pdp_3d_for;t_pdp_3d_for37,1101 +static void pdp_3d_for_input_0(41,1120 +static void pdp_3d_for_count(55,1413 +static void pdp_3d_for_free(62,1543 +t_class *pdp_3d_for_class;66,1593 +void *pdp_3d_for_new(70,1623 +void pdp_3d_for_setup(92,2055 + +opengl/modules/pdp_3d_light.c,282 +typedef struct pdp_3d_light_structpdp_3d_light_struct26,890 +} t_pdp_3d_light;t_pdp_3d_light35,1042 +static void pdp_3d_light_process(39,1063 +t_class *pdp_3d_light_class;96,2717 +void pdp_3d_light_free(100,2749 +void *pdp_3d_light_new(105,2822 +void pdp_3d_light_setup(137,3539 + +opengl/modules/pdp_3d_push.c,530 +typedef struct pdp_3d_push_structpdp_3d_push_struct27,891 +} t_pdp_3d_push;t_pdp_3d_push33,999 +static void pdp_3d_push_process_right(37,1019 +static void pdp_3d_push_process_left(51,1322 +static void pdp_3d_mode_process_right(68,1608 +static void pdp_3d_mode_process_left(79,1797 +static void pdp_3d_push_setmatrix(91,2004 +t_class *pdp_3d_push_class;108,2424 +void pdp_3d_push_free(112,2455 +void *pdp_3d_push_mode_new(117,2526 +void *pdp_3d_push_new(132,2820 +void *pdp_3d_mode_new(146,3185 +void pdp_3d_push_setup(166,3538 + +opengl/modules/pdp_3d_snap.c,524 +typedef struct _pdp_3d_snap_pdp_3d_snap27,907 +} t_pdp_3d_snap;t_pdp_3d_snap39,1171 +typedef struct _snap_command_snap_command42,1190 +} t_snap_command;t_snap_command49,1349 +static void snap_texture_process(56,1393 +static void snap_callback(103,2691 +static void pdp_3d_snap_snap(114,2913 +static void pdp_3d_snap_autosnap(119,2992 +static void *pdp_3d_snap_get_new_command(131,3186 +t_class *pdp_3d_snap_class;143,3565 +void pdp_3d_snap_free(147,3596 +void *pdp_3d_snap_new(153,3701 +void pdp_3d_snap_setup(200,5030 + +opengl/modules/pdp_3d_state.c,463 +typedef struct pdp_3d_state_structpdp_3d_state_struct35,1195 +} t_pdp_3d_state;t_pdp_3d_state43,1356 +static void _setflag(46,1376 +static void pdp_3d_state_process_right(52,1490 +static void pdp_3d_state_process_left(64,1812 +static void pdp_3d_state_flag(74,2077 +static void _blend(79,2195 +static void _blend_add(80,2277 +t_class *pdp_3d_state_class;82,2344 +void pdp_3d_state_free(83,2373 +void *pdp_3d_state_new(84,2438 +void pdp_3d_state_setup(121,3399 + +opengl/modules/pdp_3d_subcontext.c,382 +typedef struct pdp_3d_subcontext_structpdp_3d_subcontext_struct27,891 +} t_pdp_3d_subcontext;t_pdp_3d_subcontext33,996 +static void pdp_3d_subcontext_process_right(37,1022 +static void pdp_3d_subcontext_process_left(52,1408 +t_class *pdp_3d_subcontext_class;69,1844 +void pdp_3d_subcontext_free(73,1881 +void *pdp_3d_subcontext_new(78,1964 +void pdp_3d_subcontext_setup(103,2489 + +opengl/modules/pdp_3d_view.c,1033 +typedef struct _pdp_3d_view_pdp_3d_view30,909 +} t_pdp_3d_view;t_pdp_3d_view43,1116 +typedef struct _viewcommand_viewcommand47,1156 +} t_viewcommand;t_viewcommand57,1378 +static void view_rot2d(65,1468 +static void view_rotx(68,1585 +static void view_roty(69,1656 +static void view_rotz(70,1727 +static void view_rota(71,1798 +static void view_transx(74,1918 +static void view_transy(75,1991 +static void view_transz(76,2064 +static void view_transxyz(77,2137 +static void view_scalex(80,2268 +static void view_scaley(81,2337 +static void view_scalez(82,2406 +static void view_scale(83,2475 +static void view_reset_3d(86,2571 +static void view_scale_aspect(87,2677 +static void view_process(91,2818 +void *pdp_3d_view_get_command_object(112,3263 +static void pdp_3d_view_p0(129,3628 +static void pdp_3d_view_p1(130,3701 +static void pdp_3d_view_p2(131,3774 +static void pdp_3d_view_p3(132,3847 +t_class *pdp_3d_view_class;135,3922 +void pdp_3d_view_free(139,3953 +void *pdp_3d_view_new(145,4070 +void pdp_3d_view_setup(212,6603 + +opengl/modules/pdp_3d_windowcontext.c,687 +typedef struct pdp_3d_windowcontext_structpdp_3d_windowcontext_struct26,890 +} t_pdp_3d_windowcontext;t_pdp_3d_windowcontext35,1089 +static void pdp_3d_windowcontext_sendfinish(38,1117 +static void pdp_3d_windowcontext_clearbuffer(48,1361 +static void pdp_3d_windowcontext_swapbuffer(71,1996 +void pdp_3d_windowcontext_resize(80,2313 +void pdp_3d_windowcontext_open(92,2621 +void pdp_3d_windowcontext_close(102,2896 +void pdp_3d_windowcontext_cursor(117,3276 +static void pdp_3d_windowcontext_bang(126,3484 +static void pdp_3d_windowcontext_free(164,4504 +t_class *pdp_3d_windowcontext_class;171,4636 +void *pdp_3d_windowcontext_new(174,4675 +void pdp_3d_windowcontext_setup(208,5511 + +opengl/system/pdp_3Dcontext_common.c,620 +#define D 35,1229 +u32 pdp_packet_3Dcontext_width(41,1288 +u32 pdp_packet_3Dcontext_height(48,1439 +u32 pdp_packet_3Dcontext_subwidth(55,1592 +u32 pdp_packet_3Dcontext_subheight(63,1751 +void pdp_packet_3Dcontext_set_subwidth(71,1912 +void pdp_packet_3Dcontext_set_subheight(78,2062 +float pdp_packet_3Dcontext_subaspect(85,2214 +int pdp_packet_3Dcontext_isvalid(92,2396 +t_3Dcontext *pdp_packet_3Dcontext_info(103,2662 +int pdp_packet_3Dcontext_snap_to_bitmap(115,2972 +void pdp_packet_3Dcontext_setup_2d_context(178,4585 +void pdp_packet_3Dcontext_setup_3d_context(207,5300 +void pdp_3Dcontext_common_setup(265,6810 + +opengl/system/pdp_3Dcontext_glx.c,991 +#define PRIVATE_CONTEXT 40,1222 +typedef struct _gl_env_gl_env44,1320 +} t_gl_env;t_gl_env57,1903 +static t_gl_env pdp_glx_env;59,1916 +static t_pdp_class *context_class;60,1945 +void pdp_packet_3Dcontext_set_rendering_context(65,2063 +void pdp_packet_3Dcontext_unset_rendering_context(99,3031 +static void _3Dcontext_clone(121,3561 +static void _3Dcontext_copy(126,3681 +static void _3Dcontext_reinit(131,3799 +static void _3Dcontext_cleanup(135,3878 +static void _3Dcontext_init_methods(162,4519 +void _pdp_3Dcontext_set_window_size(173,4687 +void pdp_packet_3Dcontext_win_resize(182,4931 +t_pdp_list *pdp_packet_3Dcontext_win_get_eventlist(194,5294 +void pdp_packet_3Dcontext_win_cursor(207,5704 +void pdp_packet_3Dcontext_win_swapbuffers(218,6005 +int pdp_packet_new_3Dcontext_win(234,6393 +int pdp_packet_new_3Dcontext_pbuf(279,7581 +void pdp_3Dcontext_prepare_for_thread_switch(289,7908 +static void pdp_3Dcontext_glx_setup_inthread(299,8071 +void pdp_3Dcontext_glx_setup(384,10779 + +opengl/system/pdp_3dp_base.c,117 +#define THIS(THIS4,51 +void pdp_3dp_base_free(7,125 +void pdp_3dp_base_init(14,224 +void pdp_3dp_base_setup(25,442 + +opengl/system/pdp_mesh.c,1293 +void vertex_add_triangle(34,1056 +void vertex_remove_triangle(38,1154 +void vertex_add_neighbour(42,1258 +void _vertex_free(51,1539 +t_vertex *_vertex_new(66,1864 +void vertex_compute_normal_random(78,2119 +void vertex_compute_normal_sphere(79,2199 +void vertex_compute_normal_prism(80,2279 +void vertex_compute_normal_average(99,2780 +float vertex_normalize(117,3128 +t_triangle *_triangle_new(129,3406 +void _triangle_free(160,4152 +t_triangle *triangle_neighbour(177,4506 +void triangle_add_median(189,4878 +void triangle_compute_normal(202,5191 +void triangle_compute_unit_normal(212,5415 +t_vertex *mesh_vertex_add(221,5607 +void mesh_vertex_remove(228,5762 +t_triangle *mesh_triangle_add(234,5881 +void mesh_triangle_remove(241,6071 +void mesh_calculate_normals(248,6221 +void mesh_split_four(270,7071 +#define GET_MEDIAN(GET_MEDIAN287,7435 +void mesh_split_three(315,8177 +void mesh_split_all_four(344,8822 +void mesh_split_all_three(360,9150 +void mesh_split_random_three(375,9480 +void mesh_free(385,9709 +t_mesh *_mesh_new(414,10263 +t_mesh *mesh_new_tetra(429,10564 +void _mesh_relax_compute_resultant_spring(459,11192 +void _mesh_relax_apply_force(487,11981 +void mesh_compute_center(500,12200 +void mesh_translate(516,12490 +void mesh_relax(528,12706 +void mesh_debug(544,13171 + +opengl/system/pdp_opengl.c,244 +#define PDP_3DP_QUEUE_LOGSIZE 25,892 +#define PDP_3DP_QUEUE_DELTIME 26,925 +static t_pdp_procqueue _3dp_queue;31,1017 +static void pdp_control_thread(34,1054 +void pdp_opengl_system_setup(60,1796 +t_pdp_procqueue* pdp_opengl_get_queue(73,2229 + +opengl/system/pdp_texture.c,1580 +static t_pdp_class *texture_class;33,1096 +static t_pdp_dpd_commandfactory _tex_cf;35,1132 +typedef struct _texture_command_texture_command37,1174 +} t_texture_command;t_texture_command42,1266 +static t_texture *_pdp_tex_info(54,1430 +static int _round_to_pow_2(61,1571 +t_pdp_symbol *_pdp_get_tex_description_from_params(67,1665 +t_pdp_symbol *_pdp_tex_get_description(86,2200 +static void texture_command_convert_bitmap_to_texture(106,2804 +int _pdp_packet_texture_convert_image_to_texture(131,3606 +int _pdp_packet_texture_convert_bitmap_to_texture(148,4057 +int _pdp_packet_texture_convert_texture_to_bitmap(204,5646 +t_texture *pdp_packet_texture_info(211,5836 +int pdp_packet_texture_isvalid(219,6106 +static void _tex_init_obj(229,6335 +static void _pdp_tex_init_methods(252,7024 +static void _pdp_tex_reinit(257,7106 +static void _pdp_tex_clone(261,7221 +static void _pdp_tex_copy(298,8259 +static void _pdp_tex_cleanup(313,8820 +static int _pdp_packet_texture_old_or_dummy(324,9147 +static void _pdp_packet_gentexture(381,10597 +int pdp_packet_new_texture(398,10960 +void pdp_packet_texture_make_current(414,11386 +void pdp_packet_texture_make_current_enable(421,11573 +float pdp_packet_texture_fracx(432,12041 +float pdp_packet_texture_fracy(439,12206 +u32 pdp_packet_texture_total_width(446,12373 +u32 pdp_packet_texture_total_height(453,12524 +u32 pdp_packet_texture_sub_width(461,12678 +u32 pdp_packet_texture_sub_height(468,12831 +float pdp_packet_texture_sub_aspect(475,12983 +void pdp_packet_texture_setup_2d_context(483,13209 +void pdp_texture_setup(508,13868 + +opengl/system/setup.c,52 +#define D(D47,1258 +void pdp_opengl_setup(49,1274 diff --git a/TODO b/TODO new file mode 100644 index 0000000..318180c --- /dev/null +++ b/TODO @@ -0,0 +1,93 @@ + +todo 0.12.x: +best to do an intermediate release for documentation. 0.13 is not +there yet. + +* check reference.txt + + + +known bugs: + +* running out of memory (using delay lines or loops) will likely crash pd. +short story: don't, use pdp_control's memlimit for limiting pdp's memory usage. +* no known other fatal (crashing) bugs. please let me know if you find one. + + +pdp/libpdp remark: +i'm working on a version 2 of pdp. until that is finished, pdp proper will +probably be frozen, except for bug fixes. + + +todo 0.13: + +* yves shm code +* make fobs (all c object code usable in packet forth should be wrapped (automaticly??)) +* pdp_xwindow event handling is not thread safe (fixed ?) +* fine tune udp protocol +* solve scheduling probs: pd+3dp = ok, pd+pdp+(3dp) = not +(lots of frags -> video slow, few frags -> audio drops. +pdp threading is not implemented everywhere and is a problem for feedback stuff. think about +a synchronous dropping scheme (central point of failure), like for 3dp. most of the threading +problems could be solved with the new threadsafe pd 0.37 -> check this out) + +* add source type to source objects (noise,plasma,constant,...) (solve with forth) +* pdp_crop/pad +* seed plasma +* reorganize headers to cut down compile time (done for core stuff, move pd objects to forth) +* fullscreen x command -> add window manager suppression +* where to solve autoconvert? per type, or central in pdp_base? 2 cases: +- template based autoconvert: in pdp_base +- compatibility based autoconvert: i.e. pdp_add (solve in base: move_passive) +* finish high level packet conversion: +- move 8bit images to packet level (iow: cleanup pdp_qt, pdp_v4l, pdp_xv) (solve with forth) +- add bitmap packet support to source modules (optim for pdp_opengl usage) +(solve with sliceforth: pdp image processing should become independent of image encoding: at least +packed 8/16 rgb(a), and all planar rgb/yuv formats should be well supported: sliceforth feeders) +- get rid of pdp_type* methods +* fix mac/linux name differences (use pdp_video, pdp_movie, pdp_window) +* pdp_xv framerate doc + pwc addons + +todo 0.14: + +* stress test the memory manager. it looks like there's a bug that pops up after running for a while +* enable audio output on bttv cards in pdp_v4l +* fix cache slicer objects + thread problems (fixed in sliceforth) +* derive as much classes as possible from pdp_base class (obsolete: use forth instead) +* displacement warp, substitution warp, refraction warp, timespace warp, wormhole warp +* check the use of varargs for image processing dispatching routine (obsolete: forth) +* more scopes +* 2D affine transforms parametrized by vectors (center, x-axis, y-axis) (np1 + matrix processing objects) +* some abstractions around pdp_cheby (colour shape, ...) +* efficient rescalers: pdp_double pdp_halve (+ efficient arbitrary scaler in sliceforth) +* move float color conversion and float<->fixed point conv code to system +* crop, shift (pad+scroll) +* solve biquad (blur) mmx boundary init prob (bands at edges: solve with proper init?) (sliceforth) +* optimize blur effect (1 pole ? / dependency stalls) (sliceforth) +* jpeg/png packet and streaming support (pdp_netsend / pdp_netreceive : binary compat issues!!) +* find out why resampling code (warping) is so slow (reg->mem->reg->mem stalls?) (solve in sliceforth) +* mmx profiling (done: sliceforth) +* add audio resampling in pdp_qt~ +* use pd_error instead of post for errors +* ascii art packet processors +* 3D time space interpolation +* colour keying +* motion tracking +* moebius transforms +* type multiplexing: find a way to use the same name for packet processors. (solved in forth: polymorhpy) +i.e. pdp_add should add images, but also vectors, ascii packets, textures,... + +experimental stuff + +* modify 2D rotation to be used as arbitrary rotation (givens) +* add 3D rotation +* frame rate limited delay line (burst delay?) +* optimize resampling code (mipmapped packed 16bit format?) + +* better type handling + +core is in place. todo: +- better (tree) search algorithm (breadth first + cost) +- add more converters + + diff --git a/abstractions/pdp_affine.pd b/abstractions/pdp_affine.pd new file mode 100644 index 0000000..831d8ae --- /dev/null +++ b/abstractions/pdp_affine.pd @@ -0,0 +1,15 @@ +#N canvas 600 556 450 300 10; +#X obj 47 39 inlet; +#X obj 111 39 inlet; +#X obj 170 38 inlet; +#X obj 98 151 pdp_cheby; +#X obj 63 205 outlet; +#X text 26 7 for patch compatibility with older versions of pdp; +#X msg 119 98 coef 1 \$1; +#X msg 197 97 coef 0 \$1; +#X connect 0 0 3 0; +#X connect 1 0 6 0; +#X connect 2 0 7 0; +#X connect 3 0 4 0; +#X connect 6 0 3 0; +#X connect 7 0 3 0; diff --git a/abstractions/pdp_agc.pd b/abstractions/pdp_agc.pd new file mode 100644 index 0000000..bd67c58 --- /dev/null +++ b/abstractions/pdp_agc.pd @@ -0,0 +1,28 @@ +#N canvas 572 396 450 300 10; +#X obj 174 115 pdp_cog; +#X obj 174 222 /; +#X obj 174 147 t b f; +#X obj 116 89 pdp_t p p; +#X obj 116 252 pdp_gain; +#X text 22 13 an automatic gain control using the pdp_cog object; +#X obj 23 40 inlet; +#X obj 238 146 inlet; +#X obj 174 183 f \$1; +#X obj 116 279 outlet; +#X text 158 36 creation argument or right inlet; +#X text 157 51 is desired average intensity; +#X obj 23 62 route chanmask; +#X msg 23 102 chanmask \$1; +#X connect 0 0 2 0; +#X connect 1 0 4 1; +#X connect 2 0 8 0; +#X connect 2 1 1 1; +#X connect 3 0 4 0; +#X connect 3 1 0 0; +#X connect 4 0 9 0; +#X connect 6 0 12 0; +#X connect 7 0 8 1; +#X connect 8 0 1 0; +#X connect 12 0 13 0; +#X connect 12 1 3 0; +#X connect 13 0 4 0; diff --git a/abstractions/pdp_blur.pd b/abstractions/pdp_blur.pd new file mode 100644 index 0000000..46425dd --- /dev/null +++ b/abstractions/pdp_blur.pd @@ -0,0 +1,27 @@ +#N canvas 344 526 521 227 10; +#X obj 26 33 inlet; +#X obj 26 174 outlet; +#X obj 26 134 pdp_bq; +#X obj 70 66 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 70 33 inlet; +#X msg 181 34 2; +#X msg 70 98 lpf \$1 0.25; +#X msg 136 34 0; +#X obj 136 10 loadbang; +#X msg 163 98 hor 1; +#X msg 209 98 ver 1; +#X text 100 138 this uses pdp_bq as a 2 pass lowpass filter to produce +a blur effect in all directions; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 6 0; +#X connect 4 0 3 0; +#X connect 5 0 2 1; +#X connect 6 0 2 0; +#X connect 7 0 3 0; +#X connect 8 0 7 0; +#X connect 8 0 5 0; +#X connect 8 0 9 0; +#X connect 8 0 10 0; +#X connect 9 0 2 0; +#X connect 10 0 2 0; diff --git a/abstractions/pdp_blur_hor.pd b/abstractions/pdp_blur_hor.pd new file mode 100644 index 0000000..00c4f89 --- /dev/null +++ b/abstractions/pdp_blur_hor.pd @@ -0,0 +1,27 @@ +#N canvas 344 526 521 227 10; +#X obj 26 33 inlet; +#X obj 26 174 outlet; +#X obj 26 134 pdp_bq; +#X obj 70 66 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 70 33 inlet; +#X msg 181 34 2; +#X msg 70 98 lpf \$1 0.25; +#X msg 136 34 0; +#X obj 136 10 loadbang; +#X msg 163 98 hor 1; +#X msg 209 98 ver 0; +#X text 100 138 this uses pdp_bq as a 2 pass lowpass filter to produce +a horzontal blur effect; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 6 0; +#X connect 4 0 3 0; +#X connect 5 0 2 1; +#X connect 6 0 2 0; +#X connect 7 0 3 0; +#X connect 8 0 7 0; +#X connect 8 0 5 0; +#X connect 8 0 9 0; +#X connect 8 0 10 0; +#X connect 9 0 2 0; +#X connect 10 0 2 0; diff --git a/abstractions/pdp_blur_ver.pd b/abstractions/pdp_blur_ver.pd new file mode 100644 index 0000000..915931f --- /dev/null +++ b/abstractions/pdp_blur_ver.pd @@ -0,0 +1,27 @@ +#N canvas 368 520 521 227 10; +#X obj 26 33 inlet; +#X obj 26 174 outlet; +#X obj 26 134 pdp_bq; +#X obj 70 66 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 70 33 inlet; +#X msg 181 34 2; +#X msg 70 98 lpf \$1 0.25; +#X msg 136 34 0; +#X obj 136 10 loadbang; +#X text 100 138 this uses pdp_bq as a 2 pass lowpass filter to produce +a vertical blur effect; +#X msg 209 98 ver 1; +#X msg 163 98 hor 0; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 6 0; +#X connect 4 0 3 0; +#X connect 5 0 2 1; +#X connect 6 0 2 0; +#X connect 7 0 3 0; +#X connect 8 0 7 0; +#X connect 8 0 5 0; +#X connect 8 0 11 0; +#X connect 8 0 10 0; +#X connect 10 0 2 0; +#X connect 11 0 2 0; diff --git a/abstractions/pdp_cheby3o.pd b/abstractions/pdp_cheby3o.pd new file mode 100644 index 0000000..db9c83f --- /dev/null +++ b/abstractions/pdp_cheby3o.pd @@ -0,0 +1,22 @@ +#N canvas 29 385 450 300 10; +#X obj 42 87 inlet; +#X obj 194 189 outlet; +#X obj 194 159 pdp_cheby 3; +#X msg 115 87 coef 0 \$1; +#X msg 194 86 coef 1 \$1; +#X msg 278 85 coef 2 \$1; +#X msg 358 84 coef 3 \$1; +#X obj 115 62 inlet; +#X obj 194 62 inlet; +#X obj 278 61 inlet; +#X obj 358 60 inlet; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 2 0; +#X connect 4 0 2 0; +#X connect 5 0 2 0; +#X connect 6 0 2 0; +#X connect 7 0 3 0; +#X connect 8 0 4 0; +#X connect 9 0 5 0; +#X connect 10 0 6 0; diff --git a/abstractions/pdp_contrast.pd b/abstractions/pdp_contrast.pd new file mode 100644 index 0000000..4aaa0d3 --- /dev/null +++ b/abstractions/pdp_contrast.pd @@ -0,0 +1,41 @@ +#N canvas 700 349 450 324 10; +#X obj 42 159 pdp_sthresh; +#X obj 42 261 pdp_gain; +#X msg 100 211 -1; +#X obj 100 235 /; +#X obj 189 196 - 1; +#X obj 189 168 * 2; +#X text 10 -1 contrast enhancement (works on YCrCb and greyscale); +#X obj 170 117 moses 0.49; +#X msg 235 141 0.49; +#X obj 170 94 / 2; +#X msg 87 101 chanmask 1; +#X obj 170 46 loadbang; +#X obj 170 69 f \$1; +#X obj 42 47 inlet; +#X obj 238 47 inlet; +#X obj 42 285 outlet; +#X text 11 13 i.e. to process the output of pdp_agc; +#X obj 170 142 f; +#X obj 42 185 pdp_t p b; +#X connect 0 0 18 0; +#X connect 1 0 15 0; +#X connect 2 0 3 0; +#X connect 3 0 1 1; +#X connect 4 0 3 1; +#X connect 5 0 4 0; +#X connect 7 0 17 0; +#X connect 7 1 8 0; +#X connect 8 0 17 0; +#X connect 9 0 7 0; +#X connect 10 0 1 0; +#X connect 10 0 0 0; +#X connect 11 0 10 0; +#X connect 11 0 12 0; +#X connect 12 0 9 0; +#X connect 13 0 0 0; +#X connect 14 0 9 0; +#X connect 17 0 0 1; +#X connect 17 0 5 0; +#X connect 18 0 1 0; +#X connect 18 1 2 0; diff --git a/abstractions/pdp_conv_alledge.pd b/abstractions/pdp_conv_alledge.pd new file mode 100644 index 0000000..0433c16 --- /dev/null +++ b/abstractions/pdp_conv_alledge.pd @@ -0,0 +1,28 @@ +#N canvas 245 202 522 199 10; +#X obj 29 17 inlet; +#X obj 29 156 outlet; +#X obj 29 97 pdp_conv; +#X msg 95 36 hmask 0.33 0.33 0.33; +#X msg 95 59 vmask -0.33 -0.33 -0.33; +#X obj 29 126 pdp_add; +#X obj 95 13 loadbang; +#X obj 292 34 int; +#X obj 292 56 * 2; +#X obj 292 79 - 1; +#X obj 292 12 inlet; +#X text 101 115 pdp_alledge is an all edge sensitive convolution filter +using pdp_add and pdp_conv to compose a non separable edge detection +convolution mask (pdp_conv can only compute separable convolution masks). +the right inlet sets number of times the filter is run (2n-1); +#X connect 0 0 2 0; +#X connect 0 0 5 1; +#X connect 2 0 5 0; +#X connect 3 0 2 0; +#X connect 3 0 4 0; +#X connect 4 0 2 0; +#X connect 5 0 1 0; +#X connect 6 0 3 0; +#X connect 7 0 8 0; +#X connect 8 0 9 0; +#X connect 9 0 2 1; +#X connect 10 0 7 0; diff --git a/abstractions/pdp_conv_emboss.pd b/abstractions/pdp_conv_emboss.pd new file mode 100644 index 0000000..5346bde --- /dev/null +++ b/abstractions/pdp_conv_emboss.pd @@ -0,0 +1,37 @@ +#N canvas 172 505 641 290 10; +#X obj 30 55 inlet; +#X obj 29 206 outlet; +#X obj 29 93 pdp_conv; +#X obj 29 126 pdp_add; +#X obj 108 9 loadbang; +#X obj 218 86 pdp_conv; +#X obj 29 176 pdp_affine 1; +#X msg 108 151 0.5; +#X msg 108 37 hmask 1 0 0; +#X msg 218 35 hmask 0 0 1; +#X obj 145 151 inlet; +#X text 142 178 this uses pdp_conv \, pdp_add and pdp_affine to produce +an emboss effect using the convolution mask (-1 0 0 \; 0 0 0 \; 0 0 +1) the right inlet sets the chroma offset.; +#X msg 218 60 vmask 0 0 1; +#X msg 108 60 vmask -1 0 0; +#X msg 108 128 chanmask 1; +#X connect 0 0 2 0; +#X connect 0 0 5 0; +#X connect 2 0 3 0; +#X connect 3 0 6 0; +#X connect 4 0 8 0; +#X connect 4 0 9 0; +#X connect 5 0 3 1; +#X connect 6 0 1 0; +#X connect 7 0 6 2; +#X connect 8 0 2 0; +#X connect 8 0 13 0; +#X connect 9 0 5 0; +#X connect 9 0 12 0; +#X connect 10 0 6 2; +#X connect 12 0 5 0; +#X connect 13 0 2 0; +#X connect 13 0 14 0; +#X connect 14 0 6 0; +#X connect 14 0 7 0; diff --git a/abstractions/pdp_conv_smooth.pd b/abstractions/pdp_conv_smooth.pd new file mode 100644 index 0000000..e37320e --- /dev/null +++ b/abstractions/pdp_conv_smooth.pd @@ -0,0 +1,14 @@ +#N canvas 490 446 522 199 10; +#X obj 29 17 inlet; +#X obj 29 156 outlet; +#X obj 29 97 pdp_conv; +#X obj 95 13 loadbang; +#X obj 292 12 inlet; +#X msg 95 36 mask 0.33 0.33 0.33; +#X text 107 108 pdp_conv_smooth is an averaging convolution filter. +second inlet sets number of passes.; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 5 0; +#X connect 4 0 2 1; +#X connect 5 0 2 0; diff --git a/abstractions/pdp_conv_sobel_edge.pd b/abstractions/pdp_conv_sobel_edge.pd new file mode 100644 index 0000000..6bbb7db --- /dev/null +++ b/abstractions/pdp_conv_sobel_edge.pd @@ -0,0 +1,21 @@ +#N canvas 222 642 607 202 10; +#X obj 15 35 pdp_conv_sobel_hor; +#X obj 149 34 pdp_conv_sobel_ver; +#X obj 15 114 pdp_add; +#X obj 15 74 pdp_mul; +#X obj 149 71 pdp_mul; +#X text 123 105 this uses the horizontal and vertical sobel directional +masks squared as an edge detector.; +#X obj 14 -6 inlet; +#X obj 15 151 outlet; +#X obj 15 15 pdp_trigger p p; +#X connect 0 0 3 0; +#X connect 0 0 3 1; +#X connect 1 0 4 0; +#X connect 1 0 4 1; +#X connect 2 0 7 0; +#X connect 3 0 2 0; +#X connect 4 0 2 1; +#X connect 6 0 8 0; +#X connect 8 0 0 0; +#X connect 8 1 1 0; diff --git a/abstractions/pdp_conv_sobel_hor.pd b/abstractions/pdp_conv_sobel_hor.pd new file mode 100644 index 0000000..599034e --- /dev/null +++ b/abstractions/pdp_conv_sobel_hor.pd @@ -0,0 +1,15 @@ +#N canvas 222 642 591 202 10; +#X obj 29 55 inlet; +#X obj 29 132 outlet; +#X obj 29 93 pdp_conv; +#X obj 108 9 loadbang; +#X msg 108 37 vmask 0.5 1 0.5; +#X msg 108 60 hmask -1 0 1; +#X text 108 101 this uses pdp_conv to produce the vertical sobel edge +detector with convolution mask (-.5 0 0.5 \; -1 0 1 \; -0.5 0 .5); +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 4 0; +#X connect 4 0 2 0; +#X connect 4 0 5 0; +#X connect 5 0 2 0; diff --git a/abstractions/pdp_conv_sobel_ver.pd b/abstractions/pdp_conv_sobel_ver.pd new file mode 100644 index 0000000..5ff2edd --- /dev/null +++ b/abstractions/pdp_conv_sobel_ver.pd @@ -0,0 +1,16 @@ +#N canvas 222 642 591 202 10; +#X obj 29 55 inlet; +#X obj 29 131 outlet; +#X obj 29 93 pdp_conv; +#X obj 108 9 loadbang; +#X msg 108 37 hmask 0.5 1 0.5; +#X msg 108 60 vmask 1 0 -1; +#X text 108 101 this uses pdp_conv to produce the horizontal sobel +edge detector with convolution mask (-.5 -1 -0.5 \; 0 0 0 \; 0.5 1 +.5); +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 4 0; +#X connect 4 0 2 0; +#X connect 4 0 5 0; +#X connect 5 0 2 0; diff --git a/abstractions/pdp_diff.pd b/abstractions/pdp_diff.pd new file mode 100644 index 0000000..a3ad5f4 --- /dev/null +++ b/abstractions/pdp_diff.pd @@ -0,0 +1,14 @@ +#N canvas 550 527 517 215 10; +#X obj 62 132 pdp_sub; +#X obj 62 104 pdp_reg; +#X obj 62 72 pdp_trigger bang pdp; +#X obj 62 38 inlet; +#X obj 62 163 outlet; +#X text 161 17 compute the difference between current; +#X text 161 33 and previous frame; +#X connect 0 0 4 0; +#X connect 1 0 0 1; +#X connect 2 0 1 0; +#X connect 2 1 1 1; +#X connect 2 1 0 0; +#X connect 3 0 2 0; diff --git a/abstractions/pdp_dither.pd b/abstractions/pdp_dither.pd new file mode 100644 index 0000000..c579cc8 --- /dev/null +++ b/abstractions/pdp_dither.pd @@ -0,0 +1,30 @@ +#N canvas 563 412 450 378 10; +#X obj 209 213 pdp_abs; +#X obj 209 144 pdp_noise; +#X obj 57 249 pdp_sub; +#X obj 209 172 pdp_grey; +#X obj 57 148 pdp_grey; +#X obj 57 88 inlet; +#X msg 209 114 type grey; +#X obj 57 204 pdp_contrast \$1; +#X obj 57 308 outlet; +#X obj 57 117 pdp_t p b; +#X obj 157 87 inlet; +#X obj 209 86 loadbang; +#X text 25 8 a dither effect; +#X text 26 45 returns a grey image (image/grey/*); +#X obj 57 277 pdp_sign; +#X text 26 23 right inlet is contrast; +#X connect 0 0 2 1; +#X connect 1 0 3 0; +#X connect 2 0 14 0; +#X connect 3 0 0 0; +#X connect 4 0 7 0; +#X connect 5 0 9 0; +#X connect 6 0 1 0; +#X connect 7 0 2 0; +#X connect 9 0 4 0; +#X connect 9 1 1 0; +#X connect 10 0 7 1; +#X connect 11 0 6 0; +#X connect 14 0 8 0; diff --git a/abstractions/pdp_gain3.pd b/abstractions/pdp_gain3.pd new file mode 100644 index 0000000..76ed097 --- /dev/null +++ b/abstractions/pdp_gain3.pd @@ -0,0 +1,27 @@ +#N canvas 576 356 409 204 10; +#X obj 107 82 pdp_gain; +#X obj 107 115 pdp_gain; +#X obj 107 146 pdp_gain; +#X obj 107 50 inlet; +#X obj 184 49 inlet; +#X obj 250 49 inlet; +#X obj 309 48 inlet; +#X obj 107 178 outlet; +#X obj 19 22 loadbang; +#X msg 19 50 chanmask 1; +#X msg 19 84 chanmask 2; +#X msg 19 117 chanmask 4; +#X text 113 14 set gain independently for 3 channels; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 2 0 7 0; +#X connect 3 0 0 0; +#X connect 4 0 0 1; +#X connect 5 0 1 1; +#X connect 6 0 2 1; +#X connect 8 0 9 0; +#X connect 9 0 0 0; +#X connect 9 0 10 0; +#X connect 10 0 1 0; +#X connect 10 0 11 0; +#X connect 11 0 2 0; diff --git a/abstractions/pdp_gradient.pd b/abstractions/pdp_gradient.pd new file mode 100644 index 0000000..8867c69 --- /dev/null +++ b/abstractions/pdp_gradient.pd @@ -0,0 +1,58 @@ +#N canvas 465 0 719 454 10; +#X obj 49 19 inlet; +#X obj 216 399 outlet; +#X obj 216 235 pdp_gain; +#X obj 216 286 pdp_gain; +#X obj 216 340 pdp_gain; +#X msg 361 217 chanmask 1; +#X msg 361 268 chanmask 2; +#X obj 361 178 loadbang; +#X obj 99 267 unpack 0 0 0; +#X msg 361 322 chanmask 4; +#X obj 216 146 pdp_grey2mask; +#X obj 5 198 unpack 0 0 0; +#X obj 267 207 r \$0-ch1; +#X obj 267 260 r \$0-ch2; +#X obj 267 312 r \$0-ch3; +#X obj 5 328 s \$0-ch1; +#X obj 127 328 s \$0-ch3; +#X obj 66 328 s \$0-ch2; +#X obj 5 229 pdp_ut_rgb2ycrcb; +#X msg 111 46 rgb 1 0.5 0; +#X msg 111 74 ycrcb 1 0.5 0; +#X text 230 46 set a red/green/blue gradient; +#X text 140 16 a gradient abstraction based on gain and grey2mask; +#X obj 49 118 route rgb ycrcb; +#X text 308 391 hint: replace pdp_gain by pdp_cheby to get nonlinear +gradients.; +#X text 229 76 set a luma/chroma_red/chroma_blue gradient; +#X text 322 146 this copies luma channel to chroma channels; +#X connect 0 0 23 0; +#X connect 2 0 3 0; +#X connect 3 0 4 0; +#X connect 4 0 1 0; +#X connect 5 0 2 0; +#X connect 5 0 6 0; +#X connect 6 0 3 0; +#X connect 6 0 9 0; +#X connect 7 0 5 0; +#X connect 7 0 19 0; +#X connect 8 0 15 0; +#X connect 8 1 17 0; +#X connect 8 2 16 0; +#X connect 9 0 4 0; +#X connect 10 0 2 0; +#X connect 11 0 18 0; +#X connect 11 1 18 1; +#X connect 11 2 18 2; +#X connect 12 0 2 1; +#X connect 13 0 3 1; +#X connect 14 0 4 1; +#X connect 18 0 15 0; +#X connect 18 1 17 0; +#X connect 18 2 16 0; +#X connect 19 0 23 0; +#X connect 20 0 23 0; +#X connect 23 0 11 0; +#X connect 23 1 8 0; +#X connect 23 2 10 0; diff --git a/abstractions/pdp_grey.pd b/abstractions/pdp_grey.pd new file mode 100644 index 0000000..fb1fa20 --- /dev/null +++ b/abstractions/pdp_grey.pd @@ -0,0 +1,7 @@ +#N canvas 608 510 395 122 10; +#X obj 39 23 inlet; +#X obj 39 51 pdp_convert image/grey/*; +#X obj 39 79 outlet; +#X text 101 21 backwards compatibility abstraction; +#X connect 0 0 1 0; +#X connect 1 0 2 0; diff --git a/abstractions/pdp_invert.pd b/abstractions/pdp_invert.pd new file mode 100644 index 0000000..517de18 --- /dev/null +++ b/abstractions/pdp_invert.pd @@ -0,0 +1,18 @@ +#N canvas 487 324 440 275 10; +#X obj 34 51 inlet; +#X obj 34 236 outlet; +#X obj 34 173 pdp_gain; +#X obj 34 100 pdp_cheby 1; +#X obj 153 24 loadbang; +#X msg 141 146 chanmask 6; +#X msg 153 58 chanmask 1 \, coef 0 1 \, coef 1 -1; +#X msg 141 120 -1; +#X connect 0 0 3 0; +#X connect 2 0 1 0; +#X connect 3 0 2 0; +#X connect 4 0 6 0; +#X connect 5 0 2 0; +#X connect 6 0 3 0; +#X connect 6 0 7 0; +#X connect 7 0 2 1; +#X connect 7 0 5 0; diff --git a/abstractions/pdp_m_inverse.pd b/abstractions/pdp_m_inverse.pd new file mode 100644 index 0000000..e942e8a --- /dev/null +++ b/abstractions/pdp_m_inverse.pd @@ -0,0 +1,11 @@ +#N canvas 805 557 415 150 10; +#X obj 21 49 pdp_m_LU; +#X obj 21 24 inlet; +#X obj 21 103 outlet; +#X text 150 31 computes a matrix inverse using the; +#X text 149 48 LU decomposition (PA = LU); +#X text 148 84 (uses double precision processing); +#X obj 21 77 pdp_m_LU_inverse; +#X connect 0 0 6 0; +#X connect 1 0 0 0; +#X connect 6 0 2 0; diff --git a/abstractions/pdp_motion_blur.pd b/abstractions/pdp_motion_blur.pd new file mode 100644 index 0000000..cc3b8c9 --- /dev/null +++ b/abstractions/pdp_motion_blur.pd @@ -0,0 +1,14 @@ +#N canvas 119 483 508 168 10; +#X obj 29 17 inlet; +#X obj 29 124 outlet; +#X obj 29 99 pdp_bqt; +#X obj 87 18 inlet; +#X obj 87 42 pdp_ut_logmap_comp 0.005 0.4; +#X msg 87 68 lpf \$1 0.25; +#X text 97 108 pdp_motion_blur uses pdp_bqt (time biquad filter) configured +as a lowpass filter to produce a motion blur effect.; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 4 0; +#X connect 4 0 5 0; +#X connect 5 0 2 0; diff --git a/abstractions/pdp_motion_fade.pd b/abstractions/pdp_motion_fade.pd new file mode 100644 index 0000000..fa61735 --- /dev/null +++ b/abstractions/pdp_motion_fade.pd @@ -0,0 +1,19 @@ +#N canvas 58 0 508 168 10; +#X obj 29 17 inlet; +#X obj 29 124 outlet; +#X obj 29 99 pdp_bqt; +#X obj 87 18 inlet; +#X text 94 102 pdp_motion_fade uses pdp_bqt (time biquad filter) configured +as an highpass filter to produce a motion triggered fade-out effect. +; +#X obj 340 -1 loadbang; +#X obj 340 24 f \$1; +#X obj 87 42 pdp_ut_logmap_comp 0.01 0.4; +#X msg 87 68 hpf \$1 0.25; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 7 0; +#X connect 5 0 6 0; +#X connect 6 0 7 0; +#X connect 7 0 8 0; +#X connect 8 0 2 0; diff --git a/abstractions/pdp_motion_phase.pd b/abstractions/pdp_motion_phase.pd new file mode 100644 index 0000000..2bded3d --- /dev/null +++ b/abstractions/pdp_motion_phase.pd @@ -0,0 +1,14 @@ +#N canvas 58 0 508 168 10; +#X obj 29 17 inlet; +#X obj 29 124 outlet; +#X obj 29 99 pdp_bqt; +#X obj 87 18 inlet; +#X text 94 102 pdp_motion_blur uses pdp_bqt (time biquad filter) configured +as an allpass filter to produce a motion phase shift effect.; +#X obj 87 42 pdp_ut_logmap_comp 0.01 0.4; +#X msg 87 68 apf \$1 0.25; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 5 0; +#X connect 5 0 6 0; +#X connect 6 0 2 0; diff --git a/abstractions/pdp_offset.pd b/abstractions/pdp_offset.pd new file mode 100644 index 0000000..da8a8a4 --- /dev/null +++ b/abstractions/pdp_offset.pd @@ -0,0 +1,17 @@ +#N canvas 515 434 450 300 10; +#X obj 48 69 inlet; +#X obj 48 243 outlet; +#X obj 48 191 pdp_cheby; +#X msg 173 93 coef 0 \$1; +#X obj 103 69 loadbang; +#X obj 173 68 inlet; +#X obj 103 111 float \$1; +#X text 45 21 add an offset to an image; +#X msg 103 138 reset \, coef 1 1 \, coef 0 \$1; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 2 0; +#X connect 4 0 6 0; +#X connect 5 0 3 0; +#X connect 6 0 8 0; +#X connect 8 0 2 0; diff --git a/abstractions/pdp_phase.pd b/abstractions/pdp_phase.pd new file mode 100644 index 0000000..c615d2e --- /dev/null +++ b/abstractions/pdp_phase.pd @@ -0,0 +1,70 @@ +#N canvas 304 524 746 291 10; +#X obj 25 21 inlet; +#X obj 25 249 outlet; +#X obj 25 209 pdp_bq; +#X obj 42 144 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 42 44 inlet; +#X msg 118 109 0; +#X obj 178 22 loadbang; +#X msg 304 191 lr 1; +#X msg 344 191 rl 0; +#X msg 42 176 apf \$1 0.15; +#X obj 287 22 inlet; +#X msg 384 191 lr 0; +#X msg 422 191 rl 1; +#X msg 539 191 bt 1; +#X msg 579 191 tb 0; +#X msg 619 191 bt 0; +#X msg 672 191 tb 1; +#X obj 287 86 select 0; +#X msg 227 191 lr 0; +#X msg 265 191 rl 0; +#X obj 522 19 inlet; +#X obj 522 84 select 0; +#X obj 338 114 moses 0; +#X obj 573 114 moses 0; +#X msg 241 53 1; +#X msg 463 191 tb 0; +#X msg 501 191 bt 0; +#X text 99 235 this uses pdp_bq as an allpass filter to produce a phase +shift effect. 2nd inlet sets amount. 3rd and 4th inlets set directions. +; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 9 0; +#X connect 4 0 3 0; +#X connect 5 0 3 0; +#X connect 6 0 5 0; +#X connect 6 0 7 0; +#X connect 6 0 8 0; +#X connect 6 0 24 0; +#X connect 7 0 2 0; +#X connect 8 0 2 0; +#X connect 9 0 2 0; +#X connect 10 0 17 0; +#X connect 11 0 2 0; +#X connect 12 0 2 0; +#X connect 13 0 2 0; +#X connect 14 0 2 0; +#X connect 16 0 2 0; +#X connect 17 0 18 0; +#X connect 17 0 19 0; +#X connect 17 1 22 0; +#X connect 18 0 2 0; +#X connect 19 0 2 0; +#X connect 20 0 21 0; +#X connect 21 0 25 0; +#X connect 21 0 26 0; +#X connect 21 1 23 0; +#X connect 22 0 8 0; +#X connect 22 0 7 0; +#X connect 22 1 12 0; +#X connect 22 1 11 0; +#X connect 23 0 14 0; +#X connect 23 0 13 0; +#X connect 23 1 16 0; +#X connect 23 1 15 0; +#X connect 24 0 17 0; +#X connect 24 0 21 0; +#X connect 25 0 2 0; +#X connect 26 0 2 0; diff --git a/abstractions/pdp_phase_hor.pd b/abstractions/pdp_phase_hor.pd new file mode 100644 index 0000000..8dcac9d --- /dev/null +++ b/abstractions/pdp_phase_hor.pd @@ -0,0 +1,41 @@ +#N canvas 304 524 534 291 10; +#X obj 25 21 inlet; +#X obj 25 249 outlet; +#X obj 25 209 pdp_bq; +#X obj 42 144 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 42 44 inlet; +#X msg 89 44 0; +#X obj 89 18 loadbang; +#X msg 42 176 apf \$1 0.15; +#X obj 338 114 moses 0; +#X text 99 235 this uses pdp_bq as an allpass filter to produce a phase +shift effect in the horizontal direction. 2nd inlet sets direction +and amount. range is from -1 to 1; +#X obj 42 93 abs; +#X msg 304 191 lr 0; +#X msg 344 191 rl 1; +#X msg 384 191 lr 1; +#X msg 422 191 rl 0; +#X msg 89 93 ver 0; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 7 0; +#X connect 4 0 10 0; +#X connect 4 0 8 0; +#X connect 5 0 10 0; +#X connect 5 0 8 0; +#X connect 5 0 15 0; +#X connect 6 0 5 0; +#X connect 6 0 11 0; +#X connect 6 0 12 0; +#X connect 7 0 2 0; +#X connect 8 0 12 0; +#X connect 8 0 11 0; +#X connect 8 1 14 0; +#X connect 8 1 13 0; +#X connect 10 0 3 0; +#X connect 11 0 2 0; +#X connect 12 0 2 0; +#X connect 13 0 2 0; +#X connect 14 0 2 0; +#X connect 15 0 2 0; diff --git a/abstractions/pdp_phase_ver.pd b/abstractions/pdp_phase_ver.pd new file mode 100644 index 0000000..7af57df --- /dev/null +++ b/abstractions/pdp_phase_ver.pd @@ -0,0 +1,41 @@ +#N canvas 304 524 518 291 10; +#X obj 25 21 inlet; +#X obj 25 249 outlet; +#X obj 25 209 pdp_bq; +#X obj 42 144 pdp_ut_addscaleclip -1 -0.5 0.05 0.48; +#X obj 42 44 inlet; +#X msg 89 44 0; +#X obj 89 18 loadbang; +#X obj 338 114 moses 0; +#X obj 42 93 abs; +#X msg 42 176 apf \$1 0.15; +#X msg 89 93 hor 0; +#X msg 304 191 tb 1; +#X msg 344 191 bt 0; +#X msg 384 191 tb 0; +#X msg 422 191 bt 1; +#X text 99 235 this uses pdp_bq as an allpass filter to produce a phase +shift effect in the vertical direction. 2nd inlet sets direction and +amount. range is from -1 to 1; +#X connect 0 0 2 0; +#X connect 2 0 1 0; +#X connect 3 0 9 0; +#X connect 4 0 8 0; +#X connect 4 0 7 0; +#X connect 5 0 8 0; +#X connect 5 0 7 0; +#X connect 5 0 10 0; +#X connect 6 0 5 0; +#X connect 6 0 11 0; +#X connect 6 0 12 0; +#X connect 7 0 12 0; +#X connect 7 0 11 0; +#X connect 7 1 14 0; +#X connect 7 1 13 0; +#X connect 8 0 3 0; +#X connect 9 0 2 0; +#X connect 10 0 2 0; +#X connect 11 0 2 0; +#X connect 12 0 2 0; +#X connect 13 0 2 0; +#X connect 14 0 2 0; diff --git a/abstractions/pdp_png_to.pd b/abstractions/pdp_png_to.pd new file mode 100644 index 0000000..b6a9bcb --- /dev/null +++ b/abstractions/pdp_png_to.pd @@ -0,0 +1,21 @@ +#N canvas 0 0 450 300 10; +#X obj 37 50 inlet; +#X obj 102 262 outlet; +#X obj 102 209 pdp_convert \$1; +#X obj 102 180 pdp_reg; +#X text 34 15 load a png file and convert to a packet type specified +by the creation argument. default = bitmap/*/*; +#X obj 102 121 symbol; +#X msg 102 149 load_png \$1 \, bang; +#X obj 37 81 route bang; +#X msg 37 208 bang; +#X obj 102 236 pdp_reg; +#X connect 0 0 7 0; +#X connect 2 0 9 0; +#X connect 3 0 2 0; +#X connect 5 0 6 0; +#X connect 6 0 3 0; +#X connect 7 0 8 0; +#X connect 7 1 5 0; +#X connect 8 0 9 0; +#X connect 9 0 1 0; diff --git a/abstractions/pdp_pps.pd b/abstractions/pdp_pps.pd new file mode 100644 index 0000000..8abb1dc --- /dev/null +++ b/abstractions/pdp_pps.pd @@ -0,0 +1,18 @@ +#N canvas 115 450 614 279 10; +#X obj 41 53 pdp_trigger; +#X obj 113 90 timer; +#X obj 113 187 /; +#X obj 113 125 t b f; +#X msg 113 155 1000; +#X obj 41 21 inlet; +#X obj 113 219 outlet; +#X text 151 36 pdp_pps uses pdp_trigger to measure the number of packets +per second. you can use this as a performance monitor.; +#X connect 0 1 1 1; +#X connect 0 1 1 0; +#X connect 1 0 3 0; +#X connect 2 0 6 0; +#X connect 3 0 4 0; +#X connect 3 1 2 1; +#X connect 4 0 2 0; +#X connect 5 0 0 0; diff --git a/abstractions/pdp_qt_control.pd b/abstractions/pdp_qt_control.pd new file mode 100644 index 0000000..7bb2de8 --- /dev/null +++ b/abstractions/pdp_qt_control.pd @@ -0,0 +1,147 @@ +#N canvas 287 151 577 553 10; +#X obj 390 48 inlet; +#X text 315 10 nb of frames; +#X text 313 23 connect pdp_qt's 3rd outlet here; +#X obj 390 99 s \$0-frames; +#X obj 8 9 inlet; +#X msg 150 186 pp; +#X msg 53 85 set l; +#X msg 104 87 set pp; +#X msg 160 87 set r; +#N canvas 821 623 335 233 randplay 0; +#X obj 82 122 random; +#X obj 111 96 r \$0-frames; +#X msg 73 81 bang; +#X obj 69 39 inlet; +#X obj 82 153 outlet; +#X text 154 24 random frame playback; +#X connect 0 0 4 0; +#X connect 1 0 0 1; +#X connect 2 0 0 0; +#X connect 3 0 2 0; +#X restore 377 288 pd randplay; +#N canvas 418 263 365 227 loopplay 0; +#X obj 63 79 f 0; +#X obj 63 101 + 1; +#X obj 63 147 mod; +#X obj 70 121 r \$0-frames; +#X msg 62 59 bang; +#X obj 62 30 inlet; +#X obj 63 182 outlet; +#X text 166 33 normal looped playback; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 2 0 0 1; +#X connect 2 0 6 0; +#X connect 3 0 2 1; +#X connect 4 0 0 0; +#X connect 5 0 4 0; +#X restore 59 284 pd loopplay; +#X obj 4 35 route bang; +#N canvas 253 244 365 227 rloopplay 0; +#X obj 63 79 f 0; +#X obj 63 147 mod; +#X obj 96 129 r \$0-frames; +#X msg 62 59 bang; +#X obj 62 30 inlet; +#X obj 63 182 outlet; +#X obj 63 101 + 1; +#X obj 133 79 r \$0-frames; +#X obj 132 102 - 1; +#X text 166 33 reverse looped playback; +#X connect 0 0 6 0; +#X connect 1 0 0 1; +#X connect 1 0 5 0; +#X connect 2 0 1 1; +#X connect 3 0 0 0; +#X connect 4 0 3 0; +#X connect 6 0 1 0; +#X connect 7 0 8 0; +#X connect 8 0 6 1; +#X restore 152 284 pd rloopplay; +#X msg 215 87 set rl; +#N canvas 0 0 450 300 addjitter 0; +#X obj 150 65 inlet; +#X obj 177 244 outlet; +#X obj 259 66 inlet; +#X obj 259 90 abs; +#X obj 225 173 r \$0-frames; +#X obj 186 201 mod; +#X obj 259 113 + 1; +#X obj 211 139 random 1; +#X text 32 26 add jitter. sort of. something like the nervous effect. +; +#X obj 160 115 t f b; +#X obj 185 169 +; +#X connect 0 0 9 0; +#X connect 2 0 3 0; +#X connect 3 0 6 0; +#X connect 4 0 5 1; +#X connect 5 0 1 0; +#X connect 6 0 7 1; +#X connect 7 0 10 1; +#X connect 9 0 10 0; +#X connect 9 1 7 0; +#X connect 10 0 5 0; +#X restore 148 395 pd addjitter; +#X obj 150 426 outlet; +#X obj 53 60 route loop pingpong random rloop nervous; +#X obj 95 419 print; +#N canvas 751 514 434 327 pingpongplay 1; +#X obj 117 73 r \$0-frames; +#X msg 62 59 bang; +#X obj 62 30 inlet; +#X obj 56 243 outlet; +#X text 120 13 pingpong (palindrome) looped playback; +#X obj 118 121 * 2; +#X obj 55 191 -; +#X obj 55 213 abs; +#X obj 63 79 f 0; +#X floatatom 113 203 5 0 0 0 - - -; +#X obj 58 108 + 1; +#X obj 62 141 mod; +#X obj 117 98 - 1; +#X connect 0 0 12 0; +#X connect 1 0 8 0; +#X connect 2 0 1 0; +#X connect 5 0 11 1; +#X connect 6 0 7 0; +#X connect 7 0 3 0; +#X connect 7 0 9 0; +#X connect 8 0 10 0; +#X connect 10 0 11 0; +#X connect 11 0 6 0; +#X connect 11 0 8 1; +#X connect 12 0 5 0; +#X connect 12 0 6 1; +#X restore 249 284 pd pingpongplay; +#X obj 150 217 route l rl pp r; +#X text 60 12 left input: metro and control; +#X text 49 465 loop modes: loop (normal) \, rloop (reverse loop) \, +pingpong (palindrome) \, random. send a nervous message to +add some random jitter.; +#X obj 390 75 abs; +#X connect 0 0 22 0; +#X connect 4 0 11 0; +#X connect 5 0 19 0; +#X connect 6 0 5 0; +#X connect 7 0 5 0; +#X connect 8 0 5 0; +#X connect 9 0 14 0; +#X connect 10 0 14 0; +#X connect 11 0 5 0; +#X connect 11 1 16 0; +#X connect 12 0 14 0; +#X connect 13 0 5 0; +#X connect 14 0 15 0; +#X connect 16 0 6 0; +#X connect 16 1 7 0; +#X connect 16 2 8 0; +#X connect 16 3 13 0; +#X connect 16 4 14 1; +#X connect 18 0 14 0; +#X connect 19 0 10 0; +#X connect 19 1 12 0; +#X connect 19 2 18 0; +#X connect 19 3 9 0; +#X connect 22 0 3 0; diff --git a/abstractions/pdp_qtloop2~.pd b/abstractions/pdp_qtloop2~.pd new file mode 100644 index 0000000..237f60c --- /dev/null +++ b/abstractions/pdp_qtloop2~.pd @@ -0,0 +1,190 @@ +#N canvas 526 20 677 778 10; +#X obj 82 83 inlet; +#X obj 255 82 inlet; +#X obj 103 506 pdp_loop; +#X obj 154 702 outlet; +#X obj 18 473 r \$0-loopin; +#X obj 24 145 s \$0-filename; +#X text 60 59 bang or hot frame; +#X text 142 727 packet outlet; +#X msg 132 137 bang; +#X obj 82 111 route open bang; +#X obj 103 554 pdp_convert image/YCrCb/*; +#X obj 294 214 s \$0-playaudioframe; +#X obj 294 237 outlet; +#X obj 132 375 mod; +#X obj 178 345 r \$0-nbframes; +#X obj 418 363 outlet; +#X obj 495 137 outlet~; +#X obj 581 133 outlet~; +#N canvas 98 558 711 881 more_logic 0; +#X obj 215 518 pdp_qt; +#X obj 246 772 symbol \$0-L; +#X obj 340 773 symbol \$0-R; +#X msg 246 797 dump \$1 0; +#X msg 340 797 dump \$1 1; +#X msg 140 473 open \$1; +#X obj 21 367 symbol; +#X obj 216 729 t f b; +#X obj 232 490 r \$0-qtin; +#X obj 340 833 s \$0-qtin; +#X obj 245 318 s \$0-loopin; +#X obj 21 338 r \$0-filename; +#X obj 215 692 s \$0-loopin; +#X text 337 227 new movie loaded \, nb of frames received here; +#X text 268 730 dump audio; +#X text 374 288 set loop size; +#X obj 215 463 until; +#X text 262 465 dump frames; +#X obj 215 258 t f f; +#X msg 245 289 size \$1 \, record; +#X text 374 303 start recording; +#X obj 199 435 f 0; +#X obj 252 551 s \$0-nbframes; +#X obj 215 227 r \$0-nbframes; +#X msg 21 494 DONE; +#X obj 21 671 print pdp_qtloop~; +#X obj 215 661 pdp_convert bitmap/yv12/*; +#X obj 215 348 t f f; +#X obj 233 601 pack 0 0; +#X obj 21 393 t b b b s; +#X msg 233 627 decoding frame \$1 of \$2; +#X obj 233 576 + 1; +#X text 407 661 images are stored in 12bpp; +#X obj 217 173 outlet~; +#X obj 340 172 outlet~; +#X obj 217 106 * 1920; +#X obj 217 41 r \$0-playaudioframe; +#X text 215 18 restart audio playback from frame #; +#X text 277 106 samplerate / framerate; +#X obj 32 32 table \$0-L; +#X obj 32 56 table \$0-R; +#N canvas 367 318 450 300 fracframemodulo 0; +#X obj 93 43 inlet; +#X obj 93 274 outlet; +#X obj 93 97 /; +#X obj 109 67 r \$0-nbframes; +#X obj 123 147 int; +#X obj 93 122 t f f; +#X obj 93 179 -; +#X obj 109 220 r \$0-nbframes; +#X obj 93 248 *; +#X connect 0 0 2 0; +#X connect 2 0 5 0; +#X connect 3 0 2 1; +#X connect 4 0 6 1; +#X connect 5 0 6 0; +#X connect 5 1 4 0; +#X connect 6 0 8 0; +#X connect 7 0 8 1; +#X connect 8 0 1 0; +#X restore 217 68 pd fracframemodulo; +#X obj 216 144 tabreadmix~ \$0-L; +#X obj 340 143 tabreadmix~ \$0-R; +#X obj 518 73 inlet; +#X connect 0 0 26 0; +#X connect 0 1 31 0; +#X connect 0 2 22 0; +#X connect 1 0 3 0; +#X connect 2 0 4 0; +#X connect 3 0 9 0; +#X connect 4 0 9 0; +#X connect 5 0 0 0; +#X connect 6 0 29 0; +#X connect 7 1 1 0; +#X connect 7 1 2 0; +#X connect 8 0 0 0; +#X connect 11 0 6 0; +#X connect 16 0 0 0; +#X connect 18 0 27 0; +#X connect 18 1 19 0; +#X connect 19 0 10 0; +#X connect 21 0 16 0; +#X connect 23 0 18 0; +#X connect 24 0 25 0; +#X connect 26 0 12 0; +#X connect 27 0 21 1; +#X connect 27 0 28 1; +#X connect 28 0 30 0; +#X connect 29 0 24 0; +#X connect 29 1 7 0; +#X connect 29 2 21 0; +#X connect 29 3 5 0; +#X connect 30 0 25 0; +#X connect 31 0 28 0; +#X connect 35 0 42 0; +#X connect 35 0 43 0; +#X connect 36 0 41 0; +#X connect 41 0 35 0; +#X connect 42 0 33 0; +#X connect 43 0 34 0; +#X connect 44 0 43 1; +#X connect 44 0 42 1; +#X restore 495 104 pd more_logic; +#X obj 132 170 f; +#X obj 132 287 t f f; +#X text 240 61 cold frame; +#X obj 162 375 mod; +#X obj 162 319 + 1; +#X obj 118 613 pdp_route; +#X obj 154 661 pdp_mix; +#X text 273 257 frame nb outlet; +#X msg 176 461 0; +#X msg 208 461 1; +#X obj 176 488 f; +#X text 215 408 get current and next frame from pdp_loop; +#X obj 132 219 int; +#X obj 206 267 -; +#X obj 132 196 t f f f; +#X obj 132 249 t f f; +#X text 277 317 crossfade fraction; +#X obj 206 317 s \$0-frac; +#X obj 198 631 r \$0-frac; +#X obj 206 292 * -1; +#X obj 103 408 t f b; +#X obj 162 408 t f b; +#X text 397 385 nb frames outlet; +#X text 249 19 like pdp_qtloop~ but uses tabreadmix~ from creb; +#X obj 497 77 inlet; +#X text 479 57 grain size; +#X connect 0 0 9 0; +#X connect 1 0 19 1; +#X connect 2 0 10 0; +#X connect 4 0 2 0; +#X connect 8 0 19 0; +#X connect 9 0 5 0; +#X connect 9 1 8 0; +#X connect 9 2 19 0; +#X connect 10 0 24 0; +#X connect 13 0 39 0; +#X connect 14 0 13 1; +#X connect 14 0 22 1; +#X connect 14 0 15 0; +#X connect 18 0 16 0; +#X connect 18 1 17 0; +#X connect 19 0 33 0; +#X connect 20 0 13 0; +#X connect 20 1 23 0; +#X connect 22 0 40 0; +#X connect 23 0 22 0; +#X connect 24 0 25 0; +#X connect 24 1 25 1; +#X connect 25 0 3 0; +#X connect 27 0 29 0; +#X connect 28 0 29 0; +#X connect 29 0 24 1; +#X connect 31 0 34 0; +#X connect 32 0 38 0; +#X connect 33 0 31 0; +#X connect 33 1 32 1; +#X connect 33 2 12 0; +#X connect 33 2 11 0; +#X connect 34 0 20 0; +#X connect 34 1 32 0; +#X connect 37 0 25 2; +#X connect 38 0 36 0; +#X connect 39 0 2 0; +#X connect 39 1 27 0; +#X connect 40 0 2 0; +#X connect 40 1 28 0; +#X connect 43 0 18 0; diff --git a/abstractions/pdp_qtloop~.pd b/abstractions/pdp_qtloop~.pd new file mode 100644 index 0000000..bb2074e --- /dev/null +++ b/abstractions/pdp_qtloop~.pd @@ -0,0 +1,183 @@ +#N canvas 526 20 677 778 10; +#X obj 82 83 inlet; +#X obj 255 82 inlet; +#X obj 103 506 pdp_loop; +#X obj 154 702 outlet; +#X obj 18 473 r \$0-loopin; +#X obj 24 145 s \$0-filename; +#X text 60 59 bang or hot frame; +#X text 142 727 packet outlet; +#X msg 132 137 bang; +#X obj 82 111 route open bang; +#X obj 103 554 pdp_convert image/YCrCb/*; +#X obj 294 214 s \$0-playaudioframe; +#X obj 294 237 outlet; +#X obj 132 375 mod; +#X obj 178 345 r \$0-nbframes; +#X obj 418 363 outlet; +#X obj 495 137 outlet~; +#X obj 581 133 outlet~; +#N canvas 98 558 711 881 more_logic 0; +#X obj 215 518 pdp_qt; +#X obj 246 772 symbol \$0-L; +#X obj 340 773 symbol \$0-R; +#X msg 246 797 dump \$1 0; +#X msg 340 797 dump \$1 1; +#X msg 140 473 open \$1; +#X obj 21 367 symbol; +#X obj 216 729 t f b; +#X obj 232 490 r \$0-qtin; +#X obj 340 833 s \$0-qtin; +#X obj 245 318 s \$0-loopin; +#X obj 21 338 r \$0-filename; +#X obj 215 692 s \$0-loopin; +#X text 337 227 new movie loaded \, nb of frames received here; +#X text 268 730 dump audio; +#X text 374 288 set loop size; +#X obj 215 463 until; +#X text 262 465 dump frames; +#X obj 215 258 t f f; +#X msg 245 289 size \$1 \, record; +#X text 374 303 start recording; +#X obj 199 435 f 0; +#X obj 252 551 s \$0-nbframes; +#X obj 215 227 r \$0-nbframes; +#X msg 21 494 DONE; +#X obj 21 671 print pdp_qtloop~; +#X obj 215 661 pdp_convert bitmap/yv12/*; +#X obj 215 348 t f f; +#X obj 233 601 pack 0 0; +#X obj 21 393 t b b b s; +#X msg 233 627 decoding frame \$1 of \$2; +#X obj 233 576 + 1; +#X text 407 661 images are stored in 12bpp; +#X obj 217 173 outlet~; +#X obj 340 172 outlet~; +#X obj 217 106 * 1920; +#X obj 217 41 r \$0-playaudioframe; +#X text 215 18 restart audio playback from frame #; +#X text 277 106 samplerate / framerate; +#X obj 32 32 table \$0-L; +#X obj 32 56 table \$0-R; +#N canvas 367 318 450 300 fracframemodulo 0; +#X obj 93 43 inlet; +#X obj 93 274 outlet; +#X obj 93 97 /; +#X obj 109 67 r \$0-nbframes; +#X obj 123 147 int; +#X obj 93 122 t f f; +#X obj 93 179 -; +#X obj 109 220 r \$0-nbframes; +#X obj 93 248 *; +#X connect 0 0 2 0; +#X connect 2 0 5 0; +#X connect 3 0 2 1; +#X connect 4 0 6 1; +#X connect 5 0 6 0; +#X connect 5 1 4 0; +#X connect 6 0 8 0; +#X connect 7 0 8 1; +#X connect 8 0 1 0; +#X restore 217 68 pd fracframemodulo; +#X obj 216 144 tabplay~ \$0-L; +#X obj 340 143 tabplay~ \$0-R; +#X connect 0 0 26 0; +#X connect 0 1 31 0; +#X connect 0 2 22 0; +#X connect 1 0 3 0; +#X connect 2 0 4 0; +#X connect 3 0 9 0; +#X connect 4 0 9 0; +#X connect 5 0 0 0; +#X connect 6 0 29 0; +#X connect 7 1 1 0; +#X connect 7 1 2 0; +#X connect 8 0 0 0; +#X connect 11 0 6 0; +#X connect 16 0 0 0; +#X connect 18 0 27 0; +#X connect 18 1 19 0; +#X connect 19 0 10 0; +#X connect 21 0 16 0; +#X connect 23 0 18 0; +#X connect 24 0 25 0; +#X connect 26 0 12 0; +#X connect 27 0 21 1; +#X connect 27 0 28 1; +#X connect 28 0 30 0; +#X connect 29 0 24 0; +#X connect 29 1 7 0; +#X connect 29 2 21 0; +#X connect 29 3 5 0; +#X connect 30 0 25 0; +#X connect 31 0 28 0; +#X connect 35 0 42 0; +#X connect 35 0 43 0; +#X connect 36 0 41 0; +#X connect 41 0 35 0; +#X connect 42 0 33 0; +#X connect 43 0 34 0; +#X restore 495 104 pd more_logic; +#X obj 132 170 f; +#X obj 132 287 t f f; +#X text 240 61 cold frame; +#X obj 162 375 mod; +#X obj 162 319 + 1; +#X obj 118 613 pdp_route; +#X obj 154 661 pdp_mix; +#X text 273 257 frame nb outlet; +#X msg 176 461 0; +#X msg 208 461 1; +#X obj 176 488 f; +#X text 215 408 get current and next frame from pdp_loop; +#X obj 132 219 int; +#X obj 206 267 -; +#X obj 132 196 t f f f; +#X obj 132 249 t f f; +#X text 277 317 crossfade fraction; +#X obj 206 317 s \$0-frac; +#X obj 198 631 r \$0-frac; +#X obj 206 292 * -1; +#X obj 103 408 t f b; +#X obj 162 408 t f b; +#X text 397 385 nb frames outlet; +#X connect 0 0 9 0; +#X connect 1 0 19 1; +#X connect 2 0 10 0; +#X connect 4 0 2 0; +#X connect 8 0 19 0; +#X connect 9 0 5 0; +#X connect 9 1 8 0; +#X connect 9 2 19 0; +#X connect 10 0 24 0; +#X connect 13 0 39 0; +#X connect 14 0 13 1; +#X connect 14 0 22 1; +#X connect 14 0 15 0; +#X connect 18 0 16 0; +#X connect 18 1 17 0; +#X connect 19 0 33 0; +#X connect 20 0 13 0; +#X connect 20 1 23 0; +#X connect 22 0 40 0; +#X connect 23 0 22 0; +#X connect 24 0 25 0; +#X connect 24 1 25 1; +#X connect 25 0 3 0; +#X connect 27 0 29 0; +#X connect 28 0 29 0; +#X connect 29 0 24 1; +#X connect 31 0 34 0; +#X connect 32 0 38 0; +#X connect 33 0 31 0; +#X connect 33 1 32 1; +#X connect 33 2 12 0; +#X connect 33 2 11 0; +#X connect 34 0 20 0; +#X connect 34 1 32 0; +#X connect 37 0 25 2; +#X connect 38 0 36 0; +#X connect 39 0 2 0; +#X connect 39 1 27 0; +#X connect 40 0 2 0; +#X connect 40 1 28 0; diff --git a/abstractions/pdp_saturation.pd b/abstractions/pdp_saturation.pd new file mode 100644 index 0000000..44f5a86 --- /dev/null +++ b/abstractions/pdp_saturation.pd @@ -0,0 +1,18 @@ +#N canvas 322 388 509 326 10; +#X obj 39 105 inlet; +#X obj 270 103 inlet; +#X obj 39 255 outlet; +#X obj 85 105 loadbang; +#X text 32 14 adjust colour saturation by applying a gain to the chroma +channels.; +#X text 31 47 this only works for image/YCrCb/* packets and 3 channel +image/multi/* packets containing luma and chroma channels.; +#X obj 39 192 pdp_gain; +#X msg 85 155 chanmask 6 \, gain \$1; +#X obj 85 131 f \$1; +#X connect 0 0 6 0; +#X connect 1 0 6 1; +#X connect 3 0 8 0; +#X connect 6 0 2 0; +#X connect 7 0 6 0; +#X connect 8 0 7 0; diff --git a/abstractions/pdp_save_png_sequence.pd b/abstractions/pdp_save_png_sequence.pd new file mode 100644 index 0000000..786df47 --- /dev/null +++ b/abstractions/pdp_save_png_sequence.pd @@ -0,0 +1,28 @@ +#N canvas 654 482 490 382 10; +#X obj 54 65 inlet; +#X obj 119 362 pdp_reg; +#X obj 119 130 pdp_t b p; +#X obj 119 186 + 1; +#X obj 54 93 route bang; +#X obj 119 251 makefilename /tmp/frame%d.png; +#X obj 119 215 moses \$1; +#X obj 140 279 print; +#X msg 119 305 save_png \$1; +#X msg 54 126 0; +#X text 146 10 save a png sequence in the /tmp directory; +#X text 146 25 creation argument is the number of frames; +#X obj 119 160 f \$1; +#X text 146 40 send a bang to start writing; +#X connect 0 0 4 0; +#X connect 2 0 12 0; +#X connect 2 1 1 0; +#X connect 3 0 6 0; +#X connect 3 0 12 1; +#X connect 4 0 9 0; +#X connect 4 1 2 0; +#X connect 5 0 7 0; +#X connect 5 0 8 0; +#X connect 6 0 5 0; +#X connect 8 0 1 0; +#X connect 9 0 12 1; +#X connect 12 0 3 0; diff --git a/abstractions/pdp_sub.pd b/abstractions/pdp_sub.pd new file mode 100644 index 0000000..b4abe36 --- /dev/null +++ b/abstractions/pdp_sub.pd @@ -0,0 +1,8 @@ +#N canvas 577 543 450 300 10; +#X obj 48 49 inlet; +#X obj 118 47 inlet; +#X obj 47 161 outlet; +#X obj 48 104 pdp_mix2 1 -1; +#X connect 0 0 3 0; +#X connect 1 0 3 1; +#X connect 3 0 2 0; diff --git a/abstractions/pdp_tag.pd b/abstractions/pdp_tag.pd new file mode 100644 index 0000000..d1884f6 --- /dev/null +++ b/abstractions/pdp_tag.pd @@ -0,0 +1,19 @@ +#N canvas 700 231 450 300 10; +#X obj 56 25 inlet; +#X obj 55 191 outlet; +#X msg 162 174 \$1 \$2 \$3 \$4; +#X text 148 31 tag a pdp message (for routing); +#X obj 0 110 symbol \$1; +#X obj 56 68 unpack s s 0; +#X obj 55 139 pack s s s 0; +#X obj 39 91 t b s; +#X obj 55 165 route list; +#X connect 0 0 5 0; +#X connect 4 0 6 0; +#X connect 5 0 7 0; +#X connect 5 1 6 2; +#X connect 5 2 6 3; +#X connect 6 0 8 0; +#X connect 7 0 4 0; +#X connect 7 1 6 1; +#X connect 8 0 1 0; diff --git a/abstractions/pdp_xv_keycursor.pd b/abstractions/pdp_xv_keycursor.pd new file mode 100644 index 0000000..a10a708 --- /dev/null +++ b/abstractions/pdp_xv_keycursor.pd @@ -0,0 +1,77 @@ +#N canvas 135 108 708 682 10; +#X obj 19 103 print; +#X obj 19 67 pdp_xv; +#X obj 111 168 route keypress; +#X obj 367 215 table \$0-x; +#X obj 87 394 tabwrite \$0-x; +#X obj 396 335 tabread \$0-x; +#X obj 486 335 tabread \$0-y; +#X obj 409 383 pack s 0 0; +#X obj 183 392 tabwrite \$0-y; +#X obj 77 260 route motion; +#X obj 88 367 unpack 0 0; +#X obj 444 215 table \$0-y; +#X obj 87 339 spigot; +#X msg 157 311 0; +#X msg 125 312 1; +#X obj 157 288 route keyrelease; +#X msg 385 360 movecursor; +#X msg 409 412 \$1 \$2 \$3; +#X obj 18 468 outlet; +#X obj 17 128 t a a; +#X obj 403 277 t b f f; +#X obj 88 426 outlet; +#X obj 152 423 outlet; +#X obj 267 428 outlet; +#X obj 239 231 t f f; +#X obj 409 438 s \$0-control; +#X obj 19 40 r \$0-control; +#X obj 20 16 inlet; +#X text 182 53 a keyboard/mouse controller using pdp_xv; +#X text 180 76 hold a key while moving the mouse to update the x/y +controller value. hint: turn off keyboard autoropeat using "xset r +off" in a terminal window.; +#X text 252 454 scan code; +#X text 82 450 x coord; +#X text 151 449 y coord; +#X text 9 494 plain events; +#X obj 450 119 inlet; +#X obj 450 143 unpack 0 0 0; +#X obj 382 175 tabwrite \$0-x; +#X obj 480 175 tabwrite \$0-y; +#X connect 1 0 0 0; +#X connect 1 0 19 0; +#X connect 2 0 24 0; +#X connect 2 1 9 0; +#X connect 5 0 7 1; +#X connect 6 0 7 2; +#X connect 7 0 17 0; +#X connect 9 0 12 0; +#X connect 9 1 15 0; +#X connect 10 0 4 0; +#X connect 10 0 21 0; +#X connect 10 1 8 0; +#X connect 10 1 22 0; +#X connect 12 0 10 0; +#X connect 13 0 12 1; +#X connect 14 0 12 1; +#X connect 15 0 13 0; +#X connect 16 0 7 0; +#X connect 17 0 25 0; +#X connect 19 0 18 0; +#X connect 19 1 2 0; +#X connect 20 0 16 0; +#X connect 20 1 5 0; +#X connect 20 2 6 0; +#X connect 24 0 4 1; +#X connect 24 0 8 1; +#X connect 24 0 23 0; +#X connect 24 0 14 0; +#X connect 24 1 20 0; +#X connect 26 0 1 0; +#X connect 27 0 1 0; +#X connect 34 0 35 0; +#X connect 35 0 36 0; +#X connect 35 1 37 0; +#X connect 35 2 37 1; +#X connect 35 2 36 1; diff --git a/abstractions/rgb2ycrcb.pd b/abstractions/rgb2ycrcb.pd new file mode 100644 index 0000000..acb517f --- /dev/null +++ b/abstractions/rgb2ycrcb.pd @@ -0,0 +1,7 @@ +#N canvas 318 162 450 300 10; +#X obj 94 76 inlet; +#X obj 144 76 inlet; +#X obj 195 76 inlet; +#X text 94 53 red; +#X text 143 52 green; +#X text 197 53 blue; diff --git a/bin/pdp-config b/bin/pdp-config new file mode 100644 index 0000000..1e29f99 --- /dev/null +++ b/bin/pdp-config @@ -0,0 +1,39 @@ +#!/bin/sh + +prefix=/usr/local +version=0.12.4 + +usage="\ +Usage: pdp-config [--version] [--cflags] [--libdir]" + +if test $# -eq 0; then + echo "${usage}" 1>&2 + exit 1 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + case $1 in + -n) + NEWLINE="-n" + ;; + --libdir) + echo $NEWLINE $prefix/lib/scaf + ;; + --version) + echo $NEWLINE $version + ;; + --cflags) + echo $NEWLINE -I$prefix/include/pdp + ;; + *) + echo "${usage}" 1>&2 + exit 1 + ;; + esac + shift +done diff --git a/bin/pdp-config.in b/bin/pdp-config.in new file mode 100755 index 0000000..2f3855d --- /dev/null +++ b/bin/pdp-config.in @@ -0,0 +1,39 @@ +#!/bin/sh + +prefix=@prefix@ +version=@PDP_VERSION@ + +usage="\ +Usage: pdp-config [--version] [--cflags] [--libdir]" + +if test $# -eq 0; then + echo "${usage}" 1>&2 + exit 1 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + case $1 in + -n) + NEWLINE="-n" + ;; + --libdir) + echo $NEWLINE $prefix/lib/scaf + ;; + --version) + echo $NEWLINE $version + ;; + --cflags) + echo $NEWLINE -I$prefix/include/pdp + ;; + *) + echo "${usage}" 1>&2 + exit 1 + ;; + esac + shift +done diff --git a/buildall b/buildall new file mode 100755 index 0000000..155633f --- /dev/null +++ b/buildall @@ -0,0 +1,18 @@ +#!/bin/sh + +# a build script to build and configure the entire pdp distro +# might need some editing to work for you + + +# build the stable stuff +autoconf && ./configure --enable-mmx --prefix=/home/tom/pd && make install + +cd scaf +autoconf && ./configure && make install +cd .. + + +# build the experimental stuff + +make -C opengl + diff --git a/configure b/configure new file mode 100755 index 0000000..be2296b --- /dev/null +++ b/configure @@ -0,0 +1,4827 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.57. +# +# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 +# Free Software Foundation, Inc. +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## --------------------- ## +## M4sh Initialization. ## +## --------------------- ## + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' +elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then + set -o posix +fi + +# Support unset when possible. +if (FOO=FOO; unset FOO) >/dev/null 2>&1; then + as_unset=unset +else + as_unset=false +fi + + +# Work around bugs in pre-3.0 UWIN ksh. +$as_unset ENV MAIL MAILPATH +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +for as_var in \ + LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ + LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ + LC_TELEPHONE LC_TIME +do + if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then + eval $as_var=C; export $as_var + else + $as_unset $as_var + fi +done + +# Required to use basename. +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + + +# Name of the executable. +as_me=`$as_basename "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)$' \| \ + . : '\(.\)' 2>/dev/null || +echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } + /^X\/\(\/\/\)$/{ s//\1/; q; } + /^X\/\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + + +# PATH needs CR, and LINENO needs CR and PATH. +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + echo "#! /bin/sh" >conf$$.sh + echo "exit 0" >>conf$$.sh + chmod +x conf$$.sh + if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then + PATH_SEPARATOR=';' + else + PATH_SEPARATOR=: + fi + rm -f conf$$.sh +fi + + + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" || { + # Find who we are. Look in the path if we contain no path at all + # relative or not. + case $0 in + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break +done + + ;; + esac + # We did not find ourselves, most probably we were run as `sh COMMAND' + # in which case we are not to be found in the path. + if test "x$as_myself" = x; then + as_myself=$0 + fi + if test ! -f "$as_myself"; then + { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2 + { (exit 1); exit 1; }; } + fi + case $CONFIG_SHELL in + '') + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for as_base in sh bash ksh sh5; do + case $as_dir in + /*) + if ("$as_dir/$as_base" -c ' + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then + $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } + $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } + CONFIG_SHELL=$as_dir/$as_base + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$0" ${1+"$@"} + fi;; + esac + done +done +;; + esac + + # Create $as_me.lineno as a copy of $as_myself, but with $LINENO + # uniformly replaced by the line number. The first 'sed' inserts a + # line-number line before each line; the second 'sed' does the real + # work. The second script uses 'N' to pair each line-number line + # with the numbered line, and appends trailing '-' during + # substitution so that $LINENO is not a special case at line end. + # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the + # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) + sed '=' <$as_myself | + sed ' + N + s,$,-, + : loop + s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, + t loop + s,-$,, + s,^['$as_cr_digits']*\n,, + ' >$as_me.lineno && + chmod +x $as_me.lineno || + { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 + { (exit 1); exit 1; }; } + + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensible to this). + . ./$as_me.lineno + # Exit status is that of the last command. + exit +} + + +case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in + *c*,-n*) ECHO_N= ECHO_C=' +' ECHO_T=' ' ;; + *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; + *) ECHO_N= ECHO_C='\c' ECHO_T= ;; +esac + +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +rm -f conf$$ conf$$.exe conf$$.file +echo >conf$$.file +if ln -s conf$$.file conf$$ 2>/dev/null; then + # We could just check for DJGPP; but this test a) works b) is more generic + # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). + if test -f conf$$.exe; then + # Don't use ln at all; we don't have any links + as_ln_s='cp -p' + else + as_ln_s='ln -s' + fi +elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.file + +if mkdir -p . 2>/dev/null; then + as_mkdir_p=: +else + as_mkdir_p=false +fi + +as_executable_p="test -f" + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" + + +# IFS +# We need space, tab and new line, in precisely that order. +as_nl=' +' +IFS=" $as_nl" + +# CDPATH. +$as_unset CDPATH + + +# Name of the host. +# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +exec 6>&1 + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_config_libobj_dir=. +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= +SHELL=${CONFIG_SHELL-/bin/sh} + +# Maximum number of lines to put in a shell here document. +# This variable seems obsolete. It should probably be removed, and +# only ac_max_sed_lines should be used. +: ${ac_max_here_lines=38} + +# Identity of this package. +PACKAGE_NAME= +PACKAGE_TARNAME= +PACKAGE_VERSION= +PACKAGE_STRING= +PACKAGE_BUGREPORT= + +ac_unique_file="system/pdp.c" +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#if HAVE_SYS_TYPES_H +# include +#endif +#if HAVE_SYS_STAT_H +# include +#endif +#if STDC_HEADERS +# include +# include +#else +# if HAVE_STDLIB_H +# include +# endif +#endif +#if HAVE_STRING_H +# if !STDC_HEADERS && HAVE_MEMORY_H +# include +# endif +# include +#endif +#if HAVE_STRINGS_H +# include +#endif +#if HAVE_INTTYPES_H +# include +#else +# if HAVE_STDINT_H +# include +# endif +#endif +#if HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CPP EGREP PDP_VERSION PD_CPPFLAGS PD_EXECUTABLE PDP_EXTRA_CPPFLAGS PDP_CFLAGS PDP_EXTRA_CFLAGS PDP_LIBRARY_NAME PDP_TARGET PDP_OPTMOD PDP_X11MOD PDP_PDMOD PDP_OPTTYPES PDP_IMAGE_BASIC PDP_IMAGE_SPECIAL PDP_MATRIX_BASIC LIBOBJS LTLIBOBJS' +ac_subst_files='' + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datadir='${prefix}/share' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +libdir='${exec_prefix}/lib' +includedir='${prefix}/include' +oldincludedir='/usr/include' +infodir='${prefix}/info' +mandir='${prefix}/man' + +ac_prev= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval "$ac_prev=\$ac_option" + ac_prev= + continue + fi + + ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_option in + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad | --data | --dat | --da) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ + | --da=*) + datadir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid feature name: $ac_feature" >&2 + { (exit 1); exit 1; }; } + ac_feature=`echo $ac_feature | sed 's/-/_/g'` + eval "enable_$ac_feature=no" ;; + + -enable-* | --enable-*) + ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid feature name: $ac_feature" >&2 + { (exit 1); exit 1; }; } + ac_feature=`echo $ac_feature | sed 's/-/_/g'` + case $ac_option in + *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; + *) ac_optarg=yes ;; + esac + eval "enable_$ac_feature='$ac_optarg'" ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst \ + | --locals | --local | --loca | --loc | --lo) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* \ + | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid package name: $ac_package" >&2 + { (exit 1); exit 1; }; } + ac_package=`echo $ac_package| sed 's/-/_/g'` + case $ac_option in + *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; + *) ac_optarg=yes ;; + esac + eval "with_$ac_package='$ac_optarg'" ;; + + -without-* | --without-*) + ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid package name: $ac_package" >&2 + { (exit 1); exit 1; }; } + ac_package=`echo $ac_package | sed 's/-/_/g'` + eval "with_$ac_package=no" ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) { echo "$as_me: error: unrecognized option: $ac_option +Try \`$0 --help' for more information." >&2 + { (exit 1); exit 1; }; } + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 + { (exit 1); exit 1; }; } + ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` + eval "$ac_envvar='$ac_optarg'" + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + { echo "$as_me: error: missing argument to $ac_option" >&2 + { (exit 1); exit 1; }; } +fi + +# Be sure to have absolute paths. +for ac_var in exec_prefix prefix +do + eval ac_val=$`echo $ac_var` + case $ac_val in + [\\/$]* | ?:[\\/]* | NONE | '' ) ;; + *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 + { (exit 1); exit 1; }; };; + esac +done + +# Be sure to have absolute paths. +for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ + localstatedir libdir includedir oldincludedir infodir mandir +do + eval ac_val=$`echo $ac_var` + case $ac_val in + [\\/$]* | ?:[\\/]* ) ;; + *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 + { (exit 1); exit 1; }; };; + esac +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. + If a cross compiler is detected then cross compile mode will be used." >&2 + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then its parent. + ac_confdir=`(dirname "$0") 2>/dev/null || +$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$0" : 'X\(//\)[^/]' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$0" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r $srcdir/$ac_unique_file; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r $srcdir/$ac_unique_file; then + if test "$ac_srcdir_defaulted" = yes; then + { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2 + { (exit 1); exit 1; }; } + else + { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 + { (exit 1); exit 1; }; } + fi +fi +(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null || + { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2 + { (exit 1); exit 1; }; } +srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` +ac_env_build_alias_set=${build_alias+set} +ac_env_build_alias_value=$build_alias +ac_cv_env_build_alias_set=${build_alias+set} +ac_cv_env_build_alias_value=$build_alias +ac_env_host_alias_set=${host_alias+set} +ac_env_host_alias_value=$host_alias +ac_cv_env_host_alias_set=${host_alias+set} +ac_cv_env_host_alias_value=$host_alias +ac_env_target_alias_set=${target_alias+set} +ac_env_target_alias_value=$target_alias +ac_cv_env_target_alias_set=${target_alias+set} +ac_cv_env_target_alias_value=$target_alias +ac_env_CC_set=${CC+set} +ac_env_CC_value=$CC +ac_cv_env_CC_set=${CC+set} +ac_cv_env_CC_value=$CC +ac_env_CFLAGS_set=${CFLAGS+set} +ac_env_CFLAGS_value=$CFLAGS +ac_cv_env_CFLAGS_set=${CFLAGS+set} +ac_cv_env_CFLAGS_value=$CFLAGS +ac_env_LDFLAGS_set=${LDFLAGS+set} +ac_env_LDFLAGS_value=$LDFLAGS +ac_cv_env_LDFLAGS_set=${LDFLAGS+set} +ac_cv_env_LDFLAGS_value=$LDFLAGS +ac_env_CPPFLAGS_set=${CPPFLAGS+set} +ac_env_CPPFLAGS_value=$CPPFLAGS +ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set} +ac_cv_env_CPPFLAGS_value=$CPPFLAGS +ac_env_CPP_set=${CPP+set} +ac_env_CPP_value=$CPP +ac_cv_env_CPP_set=${CPP+set} +ac_cv_env_CPP_value=$CPP + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures this package to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +_ACEOF + + cat <<_ACEOF +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --datadir=DIR read-only architecture-independent data [PREFIX/share] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --infodir=DIR info documentation [PREFIX/info] + --mandir=DIR man documentation [PREFIX/man] +_ACEOF + + cat <<\_ACEOF +_ACEOF +fi + +if test -n "$ac_init_help"; then + + cat <<\_ACEOF + +Optional Features: + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-mmx enable MMX support (no) + --enable-quicktime enable libquicktime support (yes) + --enable-v4l enable Video4Linux support (yes) + --enable-pwc force additional Philips WebCam support (auto) + --enable-x enable X11 support (required by XVideo and GLX) (yes) + --enable-xv enable XVideo display support (yes) + --enable-sdl enable SDL display support (yes) + --enable-glx enable GLX display support (yes) + --enable-gsl enable gsl support (for matrix packets) (yes) + --enable-png enable png image load/save support (yes) + --enable-debug enable debugging support (no) + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have + headers in a nonstandard directory + CPP C preprocessor + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +_ACEOF +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + ac_popdir=`pwd` + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d $ac_dir || continue + ac_builddir=. + +if test "$ac_dir" != .; then + ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + # A "../" for each directory in $ac_dir_suffix. + ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` +else + ac_dir_suffix= ac_top_builddir= +fi + +case $srcdir in + .) # No --srcdir option. We are building in place. + ac_srcdir=. + if test -z "$ac_top_builddir"; then + ac_top_srcdir=. + else + ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` + fi ;; + [\\/]* | ?:[\\/]* ) # Absolute path. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir ;; + *) # Relative path. + ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_builddir$srcdir ;; +esac +# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be +# absolute. +ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` +ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` +ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` +ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` + + cd $ac_dir + # Check for guested configure; otherwise get Cygnus style configure. + if test -f $ac_srcdir/configure.gnu; then + echo + $SHELL $ac_srcdir/configure.gnu --help=recursive + elif test -f $ac_srcdir/configure; then + echo + $SHELL $ac_srcdir/configure --help=recursive + elif test -f $ac_srcdir/configure.ac || + test -f $ac_srcdir/configure.in; then + echo + $ac_configure --help + else + echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi + cd $ac_popdir + done +fi + +test -n "$ac_init_help" && exit 0 +if $ac_init_version; then + cat <<\_ACEOF + +Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 +Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit 0 +fi +exec 5>config.log +cat >&5 <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by $as_me, which was +generated by GNU Autoconf 2.57. Invocation command line was + + $ $0 $@ + +_ACEOF +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +hostinfo = `(hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + echo "PATH: $as_dir" +done + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_sep= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) + ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; + 2) + ac_configure_args1="$ac_configure_args1 '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" + # Get rid of the leading space. + ac_sep=" " + ;; + esac + done +done +$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } +$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Be sure not to use single quotes in there, as some shells, +# such as our DU 5.0 friend, will then `close' the trap. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + cat <<\_ASBOX +## ---------------- ## +## Cache variables. ## +## ---------------- ## +_ASBOX + echo + # The following way of writing the cache mishandles newlines in values, +{ + (set) 2>&1 | + case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in + *ac_space=\ *) + sed -n \ + "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" + ;; + *) + sed -n \ + "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" + ;; + esac; +} + echo + + cat <<\_ASBOX +## ----------------- ## +## Output variables. ## +## ----------------- ## +_ASBOX + echo + for ac_var in $ac_subst_vars + do + eval ac_val=$`echo $ac_var` + echo "$ac_var='"'"'$ac_val'"'"'" + done | sort + echo + + if test -n "$ac_subst_files"; then + cat <<\_ASBOX +## ------------- ## +## Output files. ## +## ------------- ## +_ASBOX + echo + for ac_var in $ac_subst_files + do + eval ac_val=$`echo $ac_var` + echo "$ac_var='"'"'$ac_val'"'"'" + done | sort + echo + fi + + if test -s confdefs.h; then + cat <<\_ASBOX +## ----------- ## +## confdefs.h. ## +## ----------- ## +_ASBOX + echo + sed "/^$/d" confdefs.h | sort + echo + fi + test "$ac_signal" != 0 && + echo "$as_me: caught signal $ac_signal" + echo "$as_me: exit $exit_status" + } >&5 + rm -f core core.* *.core && + rm -rf conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status + ' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -rf conftest* confdefs.h +# AIX cpp loses on an empty file, so make sure it contains at least a newline. +echo >confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer explicitly selected file to automatically selected ones. +if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi +fi +for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then + { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 +echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special + # files actually), so we avoid doing that. + if test -f "$cache_file"; then + { echo "$as_me:$LINENO: loading cache $cache_file" >&5 +echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . $cache_file;; + *) . ./$cache_file;; + esac + fi +else + { echo "$as_me:$LINENO: creating cache $cache_file" >&5 +echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in `(set) 2>&1 | + sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val="\$ac_cv_env_${ac_var}_value" + eval ac_new_val="\$ac_env_${ac_var}_value" + case $ac_old_set,$ac_new_set in + set,) + { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 +echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 +echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 +echo "$as_me: former value: $ac_old_val" >&2;} + { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 +echo "$as_me: current value: $ac_new_val" >&2;} + ac_cache_corrupted=: + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) + ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 +echo "$as_me: error: changes in the environment can compromise the build" >&2;} + { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 +echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} + { (exit 1); exit 1; }; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + + + + + + + + + + + + + + + + + + ac_config_headers="$ac_config_headers include/pdp_config.h" + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + CC=$ac_ct_CC +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + CC=$ac_ct_CC +else + CC="$ac_cv_prog_CC" +fi + +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + test -n "$ac_ct_CC" && break +done + + CC=$ac_ct_CC +fi + +fi + + +test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH +See \`config.log' for more details." >&5 +echo "$as_me: error: no acceptable C compiler found in \$PATH +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } + +# Provide some information about the compiler. +echo "$as_me:$LINENO:" \ + "checking for C compiler version" >&5 +ac_compiler=`set X $ac_compile; echo $2` +{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5 + (eval $ac_compiler --version &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } +{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5 + (eval $ac_compiler -v &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } +{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5 + (eval $ac_compiler -V &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +echo "$as_me:$LINENO: checking for C compiler default output" >&5 +echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6 +ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5 + (eval $ac_link_default) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + # Find the output, starting from the most likely. This scheme is +# not robust to junk in `.', hence go to wildcards (a.*) only as a last +# resort. + +# Be careful to initialize this variable, since it used to be cached. +# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile. +ac_cv_exeext= +# b.out is created by i960 compilers. +for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) + ;; + conftest.$ac_ext ) + # This is the source file. + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + # FIXME: I believe we export ac_cv_exeext for Libtool, + # but it would be cool to find out if it's true. Does anybody + # maintain Libtool? --akim. + export ac_cv_exeext + break;; + * ) + break;; + esac +done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { echo "$as_me:$LINENO: error: C compiler cannot create executables +See \`config.log' for more details." >&5 +echo "$as_me: error: C compiler cannot create executables +See \`config.log' for more details." >&2;} + { (exit 77); exit 77; }; } +fi + +ac_exeext=$ac_cv_exeext +echo "$as_me:$LINENO: result: $ac_file" >&5 +echo "${ECHO_T}$ac_file" >&6 + +# Check the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +echo "$as_me:$LINENO: checking whether the C compiler works" >&5 +echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6 +# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 +# If not cross compiling, check that we can run a simple program. +if test "$cross_compiling" != yes; then + if { ac_try='./$ac_file' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { echo "$as_me:$LINENO: error: cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } + fi + fi +fi +echo "$as_me:$LINENO: result: yes" >&5 +echo "${ECHO_T}yes" >&6 + +rm -f a.out a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +# Check the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +echo "$as_me:$LINENO: checking whether we are cross compiling" >&5 +echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6 +echo "$as_me:$LINENO: result: $cross_compiling" >&5 +echo "${ECHO_T}$cross_compiling" >&6 + +echo "$as_me:$LINENO: checking for suffix of executables" >&5 +echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6 +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + export ac_cv_exeext + break;; + * ) break;; + esac +done +else + { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +rm -f conftest$ac_cv_exeext +echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5 +echo "${ECHO_T}$ac_cv_exeext" >&6 + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +echo "$as_me:$LINENO: checking for suffix of object files" >&5 +echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6 +if test "${ac_cv_objext+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute suffix of object files: cannot compile +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_objext" >&5 +echo "${ECHO_T}$ac_cv_objext" >&6 +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5 +echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6 +if test "${ac_cv_c_compiler_gnu+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_compiler_gnu=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_compiler_gnu=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 +echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6 +GCC=`test $ac_compiler_gnu = yes && echo yes` +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +CFLAGS="-g" +echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 +echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6 +if test "${ac_cv_prog_cc_g+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_prog_cc_g=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_prog_cc_g=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 +echo "${ECHO_T}$ac_cv_prog_cc_g" >&6 +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5 +echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6 +if test "${ac_cv_prog_cc_stdc+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_prog_cc_stdc=no +ac_save_CC=$CC +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include +#include +#include +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX 10.20 and later -Ae +# HP-UX older versions -Aa -D_HPUX_SOURCE +# SVR4 -Xc -D__EXTENSIONS__ +for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_prog_cc_stdc=$ac_arg +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.$ac_objext +done +rm -f conftest.$ac_ext conftest.$ac_objext +CC=$ac_save_CC + +fi + +case "x$ac_cv_prog_cc_stdc" in + x|xno) + echo "$as_me:$LINENO: result: none needed" >&5 +echo "${ECHO_T}none needed" >&6 ;; + *) + echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5 +echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6 + CC="$CC $ac_cv_prog_cc_stdc" ;; +esac + +# Some people use a C++ compiler to compile C. Since we use `exit', +# in C++ we need to declare it. In case someone uses the same compiler +# for both compiling C and C++ we need to have the C++ compiler decide +# the declaration of exit, since it's the most demanding environment. +cat >conftest.$ac_ext <<_ACEOF +#ifndef __cplusplus + choke me +#endif +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + for ac_declaration in \ + ''\ + '#include ' \ + 'extern "C" void std::exit (int) throw (); using std::exit;' \ + 'extern "C" void std::exit (int); using std::exit;' \ + 'extern "C" void exit (int) throw ();' \ + 'extern "C" void exit (int);' \ + 'void exit (int);' +do + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +$ac_declaration +int +main () +{ +exit (42); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +continue +fi +rm -f conftest.$ac_objext conftest.$ac_ext + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_declaration +int +main () +{ +exit (42); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.$ac_objext conftest.$ac_ext +done +rm -f conftest* +if test -n "$ac_declaration"; then + echo '#ifdef __cplusplus' >>confdefs.h + echo $ac_declaration >>confdefs.h + echo '#endif' >>confdefs.h +fi + +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.$ac_objext conftest.$ac_ext +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 +echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6 +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if test "${ac_cv_prog_CPP+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.$ac_ext + + # OK, works on sane cases. Now check whether non-existent headers + # can be detected and how. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + # Broken: success on invalid input. +continue +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.err conftest.$ac_ext +if $ac_preproc_ok; then + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +echo "$as_me:$LINENO: result: $CPP" >&5 +echo "${ECHO_T}$CPP" >&6 +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.$ac_ext + + # OK, works on sane cases. Now check whether non-existent headers + # can be detected and how. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + # Broken: success on invalid input. +continue +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.err conftest.$ac_ext +if $ac_preproc_ok; then + : +else + { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details." >&5 +echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +echo "$as_me:$LINENO: checking for egrep" >&5 +echo $ECHO_N "checking for egrep... $ECHO_C" >&6 +if test "${ac_cv_prog_egrep+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if echo a | (grep -E '(a|b)') >/dev/null 2>&1 + then ac_cv_prog_egrep='grep -E' + else ac_cv_prog_egrep='egrep' + fi +fi +echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5 +echo "${ECHO_T}$ac_cv_prog_egrep" >&6 + EGREP=$ac_cv_prog_egrep + + +echo "$as_me:$LINENO: checking for ANSI C header files" >&5 +echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6 +if test "${ac_cv_header_stdc+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_header_stdc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_header_stdc=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then + : +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then + : +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then + : +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + exit(2); + exit (0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + : +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +ac_cv_header_stdc=no +fi +rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 +echo "${ECHO_T}$ac_cv_header_stdc" >&6 +if test $ac_cv_header_stdc = yes; then + +cat >>confdefs.h <<\_ACEOF +#define STDC_HEADERS 1 +_ACEOF + +fi + + + +PDP_VERSION=0.12.4 + + +# Check whether --enable-mmx or --disable-mmx was given. +if test "${enable_mmx+set}" = set; then + enableval="$enable_mmx" + +else + enable_mmx=no +fi; + +# Check whether --enable-quicktime or --disable-quicktime was given. +if test "${enable_quicktime+set}" = set; then + enableval="$enable_quicktime" + +else + enable_quicktime=yes +fi; + +# Check whether --enable-v4l or --disable-v4l was given. +if test "${enable_v4l+set}" = set; then + enableval="$enable_v4l" + +else + enable_v4l=yes +fi; + +# Check whether --enable-pwc or --disable-pwc was given. +if test "${enable_pwc+set}" = set; then + enableval="$enable_pwc" + +else + enable_pwc=auto +fi; + +# Check whether --enable-x or --disable-x was given. +if test "${enable_x+set}" = set; then + enableval="$enable_x" + +else + enable_x=yes +fi; + +# Check whether --enable-xv or --disable-xv was given. +if test "${enable_xv+set}" = set; then + enableval="$enable_xv" + +else + enable_xv=yes +fi; + +# Check whether --enable-sdl or --disable-sdl was given. +if test "${enable_sdl+set}" = set; then + enableval="$enable_sdl" + +else + enable_sdl=yes +fi; + +# Check whether --enable-glx or --disable-glx was given. +if test "${enable_glx+set}" = set; then + enableval="$enable_glx" + +else + enable_glx=yes +fi; + +# Check whether --enable-gsl or --disable-gsl was given. +if test "${enable_gsl+set}" = set; then + enableval="$enable_gsl" + +else + enable_gsl=yes +fi; + +# Check whether --enable-png or --disable-png was given. +if test "${enable_png+set}" = set; then + enableval="$enable_png" + +else + enable_png=yes +fi; + +# Check whether --enable-debug or --disable-debug was given. +if test "${enable_debug+set}" = set; then + enableval="$enable_debug" + +else + enable_debug=no +fi; + + + +PDP_CFLAGS="-DPD -Wall -W -Wstrict-prototypes -Wno-unused -Wno-parentheses -Wno-switch" + + + + +if test $enable_debug == yes +then + +cat >>confdefs.h <<\_ACEOF +#define PDP_DEBUG 1 +_ACEOF + + PDP_CFLAGS="$PDP_CFLAGS -g -Werror -Wshadow" +else + +cat >>confdefs.h <<\_ACEOF +#define PDP_DEBUG 0 +_ACEOF + + PDP_CFLAGS="$PDP_CFLAGS -O2 -funroll-loops -fomit-frame-pointer -ffast-math" +fi + +if test $prefix == NONE; +then + prefix=/usr/local +fi + + +if test $enable_pwc == yes; +then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PWCV4L 1 +_ACEOF + +fi + + +PWD=`pwd` +if test -f $prefix/pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$prefix/pd/src" + +elif test -f $prefix/src/pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$prefix/src/pd/src" +elif test -f $PWD/../pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$PWD/../pd/src" +elif test -f $PWD/../src/m_pd.h; +then + PD_CPPFLAGS="-I$PWD/../src" +fi + + +CPPFLAGS="$CPPFLAGS $PD_CPPFLAGS" +# On IRIX 5.3, sys/types and inttypes.h are conflicting. + + + + + + + + + +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default + +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + eval "$as_ac_Header=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +eval "$as_ac_Header=no" +fi +rm -f conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +if test "${ac_cv_header_m_pd_h+set}" = set; then + echo "$as_me:$LINENO: checking for m_pd.h" >&5 +echo $ECHO_N "checking for m_pd.h... $ECHO_C" >&6 +if test "${ac_cv_header_m_pd_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_m_pd_h" >&5 +echo "${ECHO_T}$ac_cv_header_m_pd_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking m_pd.h usability" >&5 +echo $ECHO_N "checking m_pd.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking m_pd.h presence" >&5 +echo $ECHO_N "checking m_pd.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc in + yes:no ) + { echo "$as_me:$LINENO: WARNING: m_pd.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: m_pd.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: m_pd.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: m_pd.h: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; + no:yes ) + { echo "$as_me:$LINENO: WARNING: m_pd.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: m_pd.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: m_pd.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: m_pd.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: m_pd.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: m_pd.h: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for m_pd.h" >&5 +echo $ECHO_N "checking for m_pd.h... $ECHO_C" >&6 +if test "${ac_cv_header_m_pd_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_m_pd_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_m_pd_h" >&5 +echo "${ECHO_T}$ac_cv_header_m_pd_h" >&6 + +fi +if test $ac_cv_header_m_pd_h = yes; then + : +else + echo "WARNING: m_pd.h not found. Is PD installed?" + echo "WARNING: if you have changed PD_CPPFLAGS in Makefile.config.in you can ignore this warning." +fi + + + + +echo "$as_me:$LINENO: checking for sin in -lm" >&5 +echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6 +if test "${ac_cv_lib_m_sin+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lm $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char sin (); +int +main () +{ +sin (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_m_sin=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_m_sin=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5 +echo "${ECHO_T}$ac_cv_lib_m_sin" >&6 +if test $ac_cv_lib_m_sin = yes; then + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBM 1 +_ACEOF + + LIBS="-lm $LIBS" + +fi + + +ARCH=`uname -s` +if test $ARCH == Linux; +then + PDP_LIBRARY_NAME=pdp.pd_linux + + if test $enable_mmx == yes; + then + PDP_TARGET=linux_mmx + else + PDP_TARGET=linux + fi +elif test $ARCH == Darwin; +then + PDP_LIBRARY_NAME=pdp.pd_darwin + PDP_TARGET=darwin +else + echo WARNING: Architecture `uname -s` not supported. + exit +fi + + + +if test $ARCH == Darwin +then + PD_EXECUTABLE=$prefix/bin/pd + LIBS="$LIBS -L/sw/lib" + CPPFLAGS="$CPPFLAGS -I/sw/include" + PDP_EXTRA_CPPFLAGS="-I/sw/include" + +else + if test "${ac_cv_header_linux_videodev_h+set}" = set; then + echo "$as_me:$LINENO: checking for linux/videodev.h" >&5 +echo $ECHO_N "checking for linux/videodev.h... $ECHO_C" >&6 +if test "${ac_cv_header_linux_videodev_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_linux_videodev_h" >&5 +echo "${ECHO_T}$ac_cv_header_linux_videodev_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking linux/videodev.h usability" >&5 +echo $ECHO_N "checking linux/videodev.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking linux/videodev.h presence" >&5 +echo $ECHO_N "checking linux/videodev.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc in + yes:no ) + { echo "$as_me:$LINENO: WARNING: linux/videodev.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: linux/videodev.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: linux/videodev.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: linux/videodev.h: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; + no:yes ) + { echo "$as_me:$LINENO: WARNING: linux/videodev.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: linux/videodev.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: linux/videodev.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: linux/videodev.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: linux/videodev.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: linux/videodev.h: proceeding with the preprocessor's result" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to bug-autoconf@gnu.org. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for linux/videodev.h" >&5 +echo $ECHO_N "checking for linux/videodev.h... $ECHO_C" >&6 +if test "${ac_cv_header_linux_videodev_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_linux_videodev_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_linux_videodev_h" >&5 +echo "${ECHO_T}$ac_cv_header_linux_videodev_h" >&6 + +fi +if test $ac_cv_header_linux_videodev_h = yes; then + PDP_OPTMOD="$PDP_OPTMOD pdp_v4l.o" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_V4L 1 +_ACEOF + +else + echo " linux/videodev.h not found: not building pdp_v4l" +fi + + + + +fi + +if test $enable_gsl == yes; +then + +echo "$as_me:$LINENO: checking for main in -lgslcblas" >&5 +echo $ECHO_N "checking for main in -lgslcblas... $ECHO_C" >&6 +if test "${ac_cv_lib_gslcblas_main+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lgslcblas $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + + +int +main () +{ +main (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_gslcblas_main=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_gslcblas_main=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_gslcblas_main" >&5 +echo "${ECHO_T}$ac_cv_lib_gslcblas_main" >&6 +if test $ac_cv_lib_gslcblas_main = yes; then + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBGSLCBLAS 1 +_ACEOF + + LIBS="-lgslcblas $LIBS" + +fi + + echo "$as_me:$LINENO: checking for main in -lgsl" >&5 +echo $ECHO_N "checking for main in -lgsl... $ECHO_C" >&6 +if test "${ac_cv_lib_gsl_main+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lgsl $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + + +int +main () +{ +main (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_gsl_main=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_gsl_main=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_gsl_main" >&5 +echo "${ECHO_T}$ac_cv_lib_gsl_main" >&6 +if test $ac_cv_lib_gsl_main = yes; then + PDP_OPTTYPES="$PDP_OPTTYPES pdp_matrix.o" + PDP_MATRIX_BASIC="$PDP_MATRIX_BASIC pdp_mat_mul.o pdp_mat_lu.o pdp_mat_vec.o" + PDP_IMAGE_BASIC="$PDP_IMAGE_BASIC pdp_cheby.o" + PDP_IMAGE_SPECIAL="$PDP_IMAGE_SPECIAL pdp_histo.o" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_GSL 1 +_ACEOF + + LIBS="$LIBS -lgslcblas -lgsl" +else + echo " libgsl not found: not building matrix type support" +fi + + + +fi + + +if test $enable_png == yes +then + echo "$as_me:$LINENO: checking for png_read_image in -lpng" >&5 +echo $ECHO_N "checking for png_read_image in -lpng... $ECHO_C" >&6 +if test "${ac_cv_lib_png_png_read_image+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lpng $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char png_read_image (); +int +main () +{ +png_read_image (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_png_png_read_image=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_png_png_read_image=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_png_png_read_image" >&5 +echo "${ECHO_T}$ac_cv_lib_png_png_read_image" >&6 +if test $ac_cv_lib_png_png_read_image = yes; then + LIBS="$LIBS -lz -lpng" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_PNG 1 +_ACEOF + +else + echo " libpng not found: not building png support" +fi + +fi + + +if test $enable_x == yes; +then + echo "$as_me:$LINENO: checking for XOpenDisplay in -lX11" >&5 +echo $ECHO_N "checking for XOpenDisplay in -lX11... $ECHO_C" >&6 +if test "${ac_cv_lib_X11_XOpenDisplay+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lX11 -L/usr/X11R6/lib $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char XOpenDisplay (); +int +main () +{ +XOpenDisplay (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_X11_XOpenDisplay=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_X11_XOpenDisplay=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_X11_XOpenDisplay" >&5 +echo "${ECHO_T}$ac_cv_lib_X11_XOpenDisplay" >&6 +if test $ac_cv_lib_X11_XOpenDisplay = yes; then + PDP_X11MOD="$PDP_X11MOD pdp_xwindow.o" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_X 1 +_ACEOF + + LIBS="$LIBS -L/usr/X11R6/lib -lX11" +else + echo " libX11 not found: not building X11 support" +fi + + +else + enable_xv=no + enable_glx=no + +fi + +if test $enable_xv == yes; +then + echo "$as_me:$LINENO: checking for XvPutImage in -lXv" >&5 +echo $ECHO_N "checking for XvPutImage in -lXv... $ECHO_C" >&6 +if test "${ac_cv_lib_Xv_XvPutImage+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lXv -L/usr/X11R6/lib -lX11 -lXext $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char XvPutImage (); +int +main () +{ +XvPutImage (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_Xv_XvPutImage=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_Xv_XvPutImage=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_Xv_XvPutImage" >&5 +echo "${ECHO_T}$ac_cv_lib_Xv_XvPutImage" >&6 +if test $ac_cv_lib_Xv_XvPutImage = yes; then + PDP_X11MOD="$PDP_X11MOD pdp_xvideo.o" + PDP_OPTMOD="$PDP_OPTMOD pdp_xv.o" + LIBS="$LIBS -lXv -lXext" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_XV 1 +_ACEOF + +else + echo " libXv not found: not building pdp_xv" +fi + +fi + +if test $enable_quicktime == yes; +then + echo "$as_me:$LINENO: checking for lqt_decode_video in -lquicktime" >&5 +echo $ECHO_N "checking for lqt_decode_video in -lquicktime... $ECHO_C" >&6 +if test "${ac_cv_lib_quicktime_lqt_decode_video+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lquicktime $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lqt_decode_video (); +int +main () +{ +lqt_decode_video (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_quicktime_lqt_decode_video=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_quicktime_lqt_decode_video=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_quicktime_lqt_decode_video" >&5 +echo "${ECHO_T}$ac_cv_lib_quicktime_lqt_decode_video" >&6 +if test $ac_cv_lib_quicktime_lqt_decode_video = yes; then + PDP_OPTMOD="$PDP_OPTMOD pdp_qt.o" + LIBS="$LIBS -lquicktime" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_QT 1 +_ACEOF + +else + echo " libquicktime not found: not building pdp_qt" +fi + +fi + + +if test $enable_glx == yes +then + echo "$as_me:$LINENO: checking for glXSwapBuffers in -lGL" >&5 +echo $ECHO_N "checking for glXSwapBuffers in -lGL... $ECHO_C" >&6 +if test "${ac_cv_lib_GL_glXSwapBuffers+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lGL -L/usr/X11R6/lib -lGLU $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char glXSwapBuffers (); +int +main () +{ +glXSwapBuffers (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_GL_glXSwapBuffers=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_GL_glXSwapBuffers=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_GL_glXSwapBuffers" >&5 +echo "${ECHO_T}$ac_cv_lib_GL_glXSwapBuffers" >&6 +if test $ac_cv_lib_GL_glXSwapBuffers = yes; then + PDP_OPTMOD="$PDP_OPTMOD pdp_glx.o" + LIBS="$LIBS -lGL -lGLU" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_GLX 1 +_ACEOF + +else + echo " libGL not found: not building pdp_glx" +fi + +fi + + +if test $enable_sdl == yes +then + echo "$as_me:$LINENO: checking for SDL_Init in -lSDL" >&5 +echo $ECHO_N "checking for SDL_Init in -lSDL... $ECHO_C" >&6 +if test "${ac_cv_lib_SDL_SDL_Init+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lSDL $LIBS" +cat >conftest.$ac_ext <<_ACEOF +#line $LINENO "configure" +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char SDL_Init (); +int +main () +{ +SDL_Init (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_SDL_SDL_Init=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_SDL_SDL_Init=no +fi +rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_SDL_SDL_Init" >&5 +echo "${ECHO_T}$ac_cv_lib_SDL_SDL_Init" >&6 +if test $ac_cv_lib_SDL_SDL_Init = yes; then + PDP_OPTMOD="$PDP_OPTMOD pdp_sdl.o" + LIBS="$LIBS -lSDL" + +cat >>confdefs.h <<\_ACEOF +#define HAVE_PDP_SDL 1 +_ACEOF + +else + echo " libSDL not found: not building pdp_sdl" +fi + +fi + + +echo target is $PDP_TARGET + +echo "used configure options:" +echo " --enable-mmx=$enable_mmx" +echo " --enable-quicktime=$enable_quicktime" +echo " --enable-v4l=$enable_v4l" +echo " --enable-pwc=$enable_pwc" +echo " --enable-sdl=$enable_sdl" +echo " --enable-x=$enable_x" +echo " --enable-xv=$enable_xv" +echo " --enable-glx=$enable_glx" +echo " --enable-gsl=$enable_gsl" +echo " --enable-png=$enable_png" +echo " --enable-debug=$enable_debug" + + + + + + + + + + + + + + + + + + + + + ac_config_files="$ac_config_files Makefile.config" + + ac_config_files="$ac_config_files bin/pdp-config" + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, don't put newlines in cache variables' values. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +{ + (set) 2>&1 | + case `(ac_space=' '; set | grep ac_space) 2>&1` in + *ac_space=\ *) + # `set' does not quote correctly, so add quotes (double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \). + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n \ + "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" + ;; + esac; +} | + sed ' + t clear + : clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + : end' >>confcache +if diff $cache_file confcache >/dev/null 2>&1; then :; else + if test -w $cache_file; then + test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" + cat confcache >$cache_file + else + echo "not updating unwritable cache $cache_file" + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +# VPATH may cause trouble with some makes, so we remove $(srcdir), +# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=/{ +s/:*\$(srcdir):*/:/; +s/:*\${srcdir}:*/:/; +s/:*@srcdir@:*/:/; +s/^\([^=]*=[ ]*\):*/\1/; +s/:*$//; +s/^[^=]*=[ ]*$//; +}' +fi + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_i=`echo "$ac_i" | + sed 's/\$U\././;s/\.o$//;s/\.obj$//'` + # 2. Add them. + ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext" + ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + + +: ${CONFIG_STATUS=./config.status} +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 +echo "$as_me: creating $CONFIG_STATUS" >&6;} +cat >$CONFIG_STATUS <<_ACEOF +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false +SHELL=\${CONFIG_SHELL-$SHELL} +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF +## --------------------- ## +## M4sh Initialization. ## +## --------------------- ## + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' +elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then + set -o posix +fi + +# Support unset when possible. +if (FOO=FOO; unset FOO) >/dev/null 2>&1; then + as_unset=unset +else + as_unset=false +fi + + +# Work around bugs in pre-3.0 UWIN ksh. +$as_unset ENV MAIL MAILPATH +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +for as_var in \ + LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ + LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ + LC_TELEPHONE LC_TIME +do + if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then + eval $as_var=C; export $as_var + else + $as_unset $as_var + fi +done + +# Required to use basename. +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + + +# Name of the executable. +as_me=`$as_basename "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)$' \| \ + . : '\(.\)' 2>/dev/null || +echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } + /^X\/\(\/\/\)$/{ s//\1/; q; } + /^X\/\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + + +# PATH needs CR, and LINENO needs CR and PATH. +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + echo "#! /bin/sh" >conf$$.sh + echo "exit 0" >>conf$$.sh + chmod +x conf$$.sh + if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then + PATH_SEPARATOR=';' + else + PATH_SEPARATOR=: + fi + rm -f conf$$.sh +fi + + + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" || { + # Find who we are. Look in the path if we contain no path at all + # relative or not. + case $0 in + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break +done + + ;; + esac + # We did not find ourselves, most probably we were run as `sh COMMAND' + # in which case we are not to be found in the path. + if test "x$as_myself" = x; then + as_myself=$0 + fi + if test ! -f "$as_myself"; then + { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5 +echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;} + { (exit 1); exit 1; }; } + fi + case $CONFIG_SHELL in + '') + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for as_base in sh bash ksh sh5; do + case $as_dir in + /*) + if ("$as_dir/$as_base" -c ' + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then + $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } + $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } + CONFIG_SHELL=$as_dir/$as_base + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$0" ${1+"$@"} + fi;; + esac + done +done +;; + esac + + # Create $as_me.lineno as a copy of $as_myself, but with $LINENO + # uniformly replaced by the line number. The first 'sed' inserts a + # line-number line before each line; the second 'sed' does the real + # work. The second script uses 'N' to pair each line-number line + # with the numbered line, and appends trailing '-' during + # substitution so that $LINENO is not a special case at line end. + # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the + # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) + sed '=' <$as_myself | + sed ' + N + s,$,-, + : loop + s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, + t loop + s,-$,, + s,^['$as_cr_digits']*\n,, + ' >$as_me.lineno && + chmod +x $as_me.lineno || + { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5 +echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;} + { (exit 1); exit 1; }; } + + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensible to this). + . ./$as_me.lineno + # Exit status is that of the last command. + exit +} + + +case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in + *c*,-n*) ECHO_N= ECHO_C=' +' ECHO_T=' ' ;; + *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; + *) ECHO_N= ECHO_C='\c' ECHO_T= ;; +esac + +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +rm -f conf$$ conf$$.exe conf$$.file +echo >conf$$.file +if ln -s conf$$.file conf$$ 2>/dev/null; then + # We could just check for DJGPP; but this test a) works b) is more generic + # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). + if test -f conf$$.exe; then + # Don't use ln at all; we don't have any links + as_ln_s='cp -p' + else + as_ln_s='ln -s' + fi +elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.file + +if mkdir -p . 2>/dev/null; then + as_mkdir_p=: +else + as_mkdir_p=false +fi + +as_executable_p="test -f" + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" + + +# IFS +# We need space, tab and new line, in precisely that order. +as_nl=' +' +IFS=" $as_nl" + +# CDPATH. +$as_unset CDPATH + +exec 6>&1 + +# Open the log real soon, to keep \$[0] and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. Logging --version etc. is OK. +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX +} >&5 +cat >&5 <<_CSEOF + +This file was extended by $as_me, which was +generated by GNU Autoconf 2.57. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +_CSEOF +echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5 +echo >&5 +_ACEOF + +# Files that config.status was made for. +if test -n "$ac_config_files"; then + echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_headers"; then + echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_links"; then + echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_commands"; then + echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS +fi + +cat >>$CONFIG_STATUS <<\_ACEOF + +ac_cs_usage="\ +\`$as_me' instantiates files from templates according to the +current configuration. + +Usage: $0 [OPTIONS] [FILE]... + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Report bugs to ." +_ACEOF + +cat >>$CONFIG_STATUS <<_ACEOF +ac_cs_version="\\ +config.status +configured by $0, generated by GNU Autoconf 2.57, + with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" + +Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 +Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." +srcdir=$srcdir +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF +# If no file are specified by the user, then we need to provide default +# value. By we need to know if files were specified by the user. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=*) + ac_option=`expr "x$1" : 'x\([^=]*\)='` + ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` + ac_shift=: + ;; + -*) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + *) # This is not an option, so the user has probably given explicit + # arguments. + ac_option=$1 + ac_need_defaults=false;; + esac + + case $ac_option in + # Handling of the options. +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --vers* | -V ) + echo "$ac_cs_version"; exit 0 ;; + --he | --h) + # Conflict between --help and --header + { { echo "$as_me:$LINENO: error: ambiguous option: $1 +Try \`$0 --help' for more information." >&5 +echo "$as_me: error: ambiguous option: $1 +Try \`$0 --help' for more information." >&2;} + { (exit 1); exit 1; }; };; + --help | --hel | -h ) + echo "$ac_cs_usage"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + CONFIG_FILES="$CONFIG_FILES $ac_optarg" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" + ac_need_defaults=false;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1 +Try \`$0 --help' for more information." >&5 +echo "$as_me: error: unrecognized option: $1 +Try \`$0 --help' for more information." >&2;} + { (exit 1); exit 1; }; } ;; + + *) ac_config_targets="$ac_config_targets $1" ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF +if \$ac_cs_recheck; then + echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 + exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion +fi + +_ACEOF + + + + + +cat >>$CONFIG_STATUS <<\_ACEOF +for ac_config_target in $ac_config_targets +do + case "$ac_config_target" in + # Handling of arguments. + "Makefile.config" ) CONFIG_FILES="$CONFIG_FILES Makefile.config" ;; + "bin/pdp-config" ) CONFIG_FILES="$CONFIG_FILES bin/pdp-config" ;; + "include/pdp_config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS include/pdp_config.h" ;; + *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 +echo "$as_me: error: invalid argument: $ac_config_target" >&2;} + { (exit 1); exit 1; }; };; + esac +done + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason to put it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Create a temporary directory, and hook for its removal unless debugging. +$debug || +{ + trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 + trap '{ (exit 1); exit 1; }' 1 2 13 15 +} + +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` && + test -n "$tmp" && test -d "$tmp" +} || +{ + tmp=./confstat$$-$RANDOM + (umask 077 && mkdir $tmp) +} || +{ + echo "$me: cannot create a temporary directory in ." >&2 + { (exit 1); exit 1; } +} + +_ACEOF + +cat >>$CONFIG_STATUS <<_ACEOF + +# +# CONFIG_FILES section. +# + +# No need to generate the scripts if there are no CONFIG_FILES. +# This happens for instance when ./config.status config.h +if test -n "\$CONFIG_FILES"; then + # Protect against being on the right side of a sed subst in config.status. + sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g; + s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF +s,@SHELL@,$SHELL,;t t +s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t +s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t +s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t +s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t +s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t +s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t +s,@exec_prefix@,$exec_prefix,;t t +s,@prefix@,$prefix,;t t +s,@program_transform_name@,$program_transform_name,;t t +s,@bindir@,$bindir,;t t +s,@sbindir@,$sbindir,;t t +s,@libexecdir@,$libexecdir,;t t +s,@datadir@,$datadir,;t t +s,@sysconfdir@,$sysconfdir,;t t +s,@sharedstatedir@,$sharedstatedir,;t t +s,@localstatedir@,$localstatedir,;t t +s,@libdir@,$libdir,;t t +s,@includedir@,$includedir,;t t +s,@oldincludedir@,$oldincludedir,;t t +s,@infodir@,$infodir,;t t +s,@mandir@,$mandir,;t t +s,@build_alias@,$build_alias,;t t +s,@host_alias@,$host_alias,;t t +s,@target_alias@,$target_alias,;t t +s,@DEFS@,$DEFS,;t t +s,@ECHO_C@,$ECHO_C,;t t +s,@ECHO_N@,$ECHO_N,;t t +s,@ECHO_T@,$ECHO_T,;t t +s,@LIBS@,$LIBS,;t t +s,@CC@,$CC,;t t +s,@CFLAGS@,$CFLAGS,;t t +s,@LDFLAGS@,$LDFLAGS,;t t +s,@CPPFLAGS@,$CPPFLAGS,;t t +s,@ac_ct_CC@,$ac_ct_CC,;t t +s,@EXEEXT@,$EXEEXT,;t t +s,@OBJEXT@,$OBJEXT,;t t +s,@CPP@,$CPP,;t t +s,@EGREP@,$EGREP,;t t +s,@PDP_VERSION@,$PDP_VERSION,;t t +s,@PD_CPPFLAGS@,$PD_CPPFLAGS,;t t +s,@PD_EXECUTABLE@,$PD_EXECUTABLE,;t t +s,@PDP_EXTRA_CPPFLAGS@,$PDP_EXTRA_CPPFLAGS,;t t +s,@PDP_CFLAGS@,$PDP_CFLAGS,;t t +s,@PDP_EXTRA_CFLAGS@,$PDP_EXTRA_CFLAGS,;t t +s,@PDP_LIBRARY_NAME@,$PDP_LIBRARY_NAME,;t t +s,@PDP_TARGET@,$PDP_TARGET,;t t +s,@PDP_OPTMOD@,$PDP_OPTMOD,;t t +s,@PDP_X11MOD@,$PDP_X11MOD,;t t +s,@PDP_PDMOD@,$PDP_PDMOD,;t t +s,@PDP_OPTTYPES@,$PDP_OPTTYPES,;t t +s,@PDP_IMAGE_BASIC@,$PDP_IMAGE_BASIC,;t t +s,@PDP_IMAGE_SPECIAL@,$PDP_IMAGE_SPECIAL,;t t +s,@PDP_MATRIX_BASIC@,$PDP_MATRIX_BASIC,;t t +s,@LIBOBJS@,$LIBOBJS,;t t +s,@LTLIBOBJS@,$LTLIBOBJS,;t t +CEOF + +_ACEOF + + cat >>$CONFIG_STATUS <<\_ACEOF + # Split the substitutions into bite-sized pieces for seds with + # small command number limits, like on Digital OSF/1 and HP-UX. + ac_max_sed_lines=48 + ac_sed_frag=1 # Number of current file. + ac_beg=1 # First line for current file. + ac_end=$ac_max_sed_lines # Line after last line for current file. + ac_more_lines=: + ac_sed_cmds= + while $ac_more_lines; do + if test $ac_beg -gt 1; then + sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag + else + sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag + fi + if test ! -s $tmp/subs.frag; then + ac_more_lines=false + else + # The purpose of the label and of the branching condition is to + # speed up the sed processing (if there are no `@' at all, there + # is no need to browse any of the substitutions). + # These are the two extra sed commands mentioned above. + (echo ':t + /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed + if test -z "$ac_sed_cmds"; then + ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" + else + ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" + fi + ac_sed_frag=`expr $ac_sed_frag + 1` + ac_beg=$ac_end + ac_end=`expr $ac_end + $ac_max_sed_lines` + fi + done + if test -z "$ac_sed_cmds"; then + ac_sed_cmds=cat + fi +fi # test -n "$CONFIG_FILES" + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF +for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case $ac_file in + - | *:- | *:-:* ) # input from stdin + cat >$tmp/stdin + ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + * ) ac_file_in=$ac_file.in ;; + esac + + # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. + ac_dir=`(dirname "$ac_file") 2>/dev/null || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + { if $as_mkdir_p; then + mkdir -p "$ac_dir" + else + as_dir="$ac_dir" + as_dirs= + while test ! -d "$as_dir"; do + as_dirs="$as_dir $as_dirs" + as_dir=`(dirname "$as_dir") 2>/dev/null || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + done + test ! -n "$as_dirs" || mkdir $as_dirs + fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 +echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} + { (exit 1); exit 1; }; }; } + + ac_builddir=. + +if test "$ac_dir" != .; then + ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + # A "../" for each directory in $ac_dir_suffix. + ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` +else + ac_dir_suffix= ac_top_builddir= +fi + +case $srcdir in + .) # No --srcdir option. We are building in place. + ac_srcdir=. + if test -z "$ac_top_builddir"; then + ac_top_srcdir=. + else + ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` + fi ;; + [\\/]* | ?:[\\/]* ) # Absolute path. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir ;; + *) # Relative path. + ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_builddir$srcdir ;; +esac +# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be +# absolute. +ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` +ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` +ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` +ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` + + + + if test x"$ac_file" != x-; then + { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + rm -f "$ac_file" + fi + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + if test x"$ac_file" = x-; then + configure_input= + else + configure_input="$ac_file. " + fi + configure_input=$configure_input"Generated from `echo $ac_file_in | + sed 's,.*/,,'` by configure." + + # First look for the input files in the build tree, otherwise in the + # src tree. + ac_file_inputs=`IFS=: + for f in $ac_file_in; do + case $f in + -) echo $tmp/stdin ;; + [\\/$]*) + # Absolute (can't be DOS-style, as IFS=:) + test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + echo $f;; + *) # Relative + if test -f "$f"; then + # Build tree + echo $f + elif test -f "$srcdir/$f"; then + # Source tree + echo $srcdir/$f + else + # /dev/null tree + { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + fi;; + esac + done` || { (exit 1); exit 1; } +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF + sed "$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s,@configure_input@,$configure_input,;t t +s,@srcdir@,$ac_srcdir,;t t +s,@abs_srcdir@,$ac_abs_srcdir,;t t +s,@top_srcdir@,$ac_top_srcdir,;t t +s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t +s,@builddir@,$ac_builddir,;t t +s,@abs_builddir@,$ac_abs_builddir,;t t +s,@top_builddir@,$ac_top_builddir,;t t +s,@abs_top_builddir@,$ac_abs_top_builddir,;t t +" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out + rm -f $tmp/stdin + if test x"$ac_file" != x-; then + mv $tmp/out $ac_file + else + cat $tmp/out + rm -f $tmp/out + fi + +done +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF + +# +# CONFIG_HEADER section. +# + +# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where +# NAME is the cpp macro being defined and VALUE is the value it is being given. +# +# ac_d sets the value in "#define NAME VALUE" lines. +ac_dA='s,^\([ ]*\)#\([ ]*define[ ][ ]*\)' +ac_dB='[ ].*$,\1#\2' +ac_dC=' ' +ac_dD=',;t' +# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE". +ac_uA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_uB='$,\1#\2define\3' +ac_uC=' ' +ac_uD=',;t' + +for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case $ac_file in + - | *:- | *:-:* ) # input from stdin + cat >$tmp/stdin + ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + * ) ac_file_in=$ac_file.in ;; + esac + + test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + + # First look for the input files in the build tree, otherwise in the + # src tree. + ac_file_inputs=`IFS=: + for f in $ac_file_in; do + case $f in + -) echo $tmp/stdin ;; + [\\/$]*) + # Absolute (can't be DOS-style, as IFS=:) + test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + echo $f;; + *) # Relative + if test -f "$f"; then + # Build tree + echo $f + elif test -f "$srcdir/$f"; then + # Source tree + echo $srcdir/$f + else + # /dev/null tree + { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + fi;; + esac + done` || { (exit 1); exit 1; } + # Remove the trailing spaces. + sed 's/[ ]*$//' $ac_file_inputs >$tmp/in + +_ACEOF + +# Transform confdefs.h into two sed scripts, `conftest.defines' and +# `conftest.undefs', that substitutes the proper values into +# config.h.in to produce config.h. The first handles `#define' +# templates, and the second `#undef' templates. +# And first: Protect against being on the right side of a sed subst in +# config.status. Protect against being in an unquoted here document +# in config.status. +rm -f conftest.defines conftest.undefs +# Using a here document instead of a string reduces the quoting nightmare. +# Putting comments in sed scripts is not portable. +# +# `end' is used to avoid that the second main sed command (meant for +# 0-ary CPP macros) applies to n-ary macro definitions. +# See the Autoconf documentation for `clear'. +cat >confdef2sed.sed <<\_ACEOF +s/[\\&,]/\\&/g +s,[\\$`],\\&,g +t clear +: clear +s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*\)\(([^)]*)\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp +t end +s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp +: end +_ACEOF +# If some macros were called several times there might be several times +# the same #defines, which is useless. Nevertheless, we may not want to +# sort them, since we want the *last* AC-DEFINE to be honored. +uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines +sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs +rm -f confdef2sed.sed + +# This sed command replaces #undef with comments. This is necessary, for +# example, in the case of _POSIX_SOURCE, which is predefined and required +# on some systems where configure will not decide to define it. +cat >>conftest.undefs <<\_ACEOF +s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, +_ACEOF + +# Break up conftest.defines because some shells have a limit on the size +# of here documents, and old seds have small limits too (100 cmds). +echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS +echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS +echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS +echo ' :' >>$CONFIG_STATUS +rm -f conftest.tail +while grep . conftest.defines >/dev/null +do + # Write a limited-size here document to $tmp/defines.sed. + echo ' cat >$tmp/defines.sed <>$CONFIG_STATUS + # Speed up: don't consider the non `#define' lines. + echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS + # Work around the forget-to-reset-the-flag bug. + echo 't clr' >>$CONFIG_STATUS + echo ': clr' >>$CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS + echo 'CEOF + sed -f $tmp/defines.sed $tmp/in >$tmp/out + rm -f $tmp/in + mv $tmp/out $tmp/in +' >>$CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail + rm -f conftest.defines + mv conftest.tail conftest.defines +done +rm -f conftest.defines +echo ' fi # grep' >>$CONFIG_STATUS +echo >>$CONFIG_STATUS + +# Break up conftest.undefs because some shells have a limit on the size +# of here documents, and old seds have small limits too (100 cmds). +echo ' # Handle all the #undef templates' >>$CONFIG_STATUS +rm -f conftest.tail +while grep . conftest.undefs >/dev/null +do + # Write a limited-size here document to $tmp/undefs.sed. + echo ' cat >$tmp/undefs.sed <>$CONFIG_STATUS + # Speed up: don't consider the non `#undef' + echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS + # Work around the forget-to-reset-the-flag bug. + echo 't clr' >>$CONFIG_STATUS + echo ': clr' >>$CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS + echo 'CEOF + sed -f $tmp/undefs.sed $tmp/in >$tmp/out + rm -f $tmp/in + mv $tmp/out $tmp/in +' >>$CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail + rm -f conftest.undefs + mv conftest.tail conftest.undefs +done +rm -f conftest.undefs + +cat >>$CONFIG_STATUS <<\_ACEOF + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + if test x"$ac_file" = x-; then + echo "/* Generated by configure. */" >$tmp/config.h + else + echo "/* $ac_file. Generated by configure. */" >$tmp/config.h + fi + cat $tmp/in >>$tmp/config.h + rm -f $tmp/in + if test x"$ac_file" != x-; then + if diff $ac_file $tmp/config.h >/dev/null 2>&1; then + { echo "$as_me:$LINENO: $ac_file is unchanged" >&5 +echo "$as_me: $ac_file is unchanged" >&6;} + else + ac_dir=`(dirname "$ac_file") 2>/dev/null || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + { if $as_mkdir_p; then + mkdir -p "$ac_dir" + else + as_dir="$ac_dir" + as_dirs= + while test ! -d "$as_dir"; do + as_dirs="$as_dir $as_dirs" + as_dir=`(dirname "$as_dir") 2>/dev/null || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + done + test ! -n "$as_dirs" || mkdir $as_dirs + fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 +echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} + { (exit 1); exit 1; }; }; } + + rm -f $ac_file + mv $tmp/config.h $ac_file + fi + else + cat $tmp/config.h + rm -f $tmp/config.h + fi +done +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF + +{ (exit 0); exit 0; } +_ACEOF +chmod +x $CONFIG_STATUS +ac_clean_files=$ac_clean_files_save + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || { (exit 1); exit 1; } +fi + + + + diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..39467a2 --- /dev/null +++ b/configure.ac @@ -0,0 +1,272 @@ +AC_INIT(system/pdp.c) +AC_CONFIG_HEADER(include/pdp_config.h) +AC_PROG_CC +AC_HEADER_STDC + +dnl TAG CVS WHEN RELEASE VERSION CHANGES !!! + +PDP_VERSION=0.12.4 +AC_SUBST(PDP_VERSION) + +AC_ARG_ENABLE(mmx, + [ --enable-mmx enable MMX support (no)], , enable_mmx=no) + +AC_ARG_ENABLE(quicktime, + [ --enable-quicktime enable libquicktime support (yes)], , enable_quicktime=yes) + +AC_ARG_ENABLE(v4l, + [ --enable-v4l enable Video4Linux support (yes)], , enable_v4l=yes) + +AC_ARG_ENABLE(pwc, + [ --enable-pwc force additional Philips WebCam support (auto)],,enable_pwc=auto) + +AC_ARG_ENABLE(x, + [ --enable-x enable X11 support (required by XVideo and GLX) (yes)], , enable_x=yes) + +AC_ARG_ENABLE(xv, + [ --enable-xv enable XVideo display support (yes)], , enable_xv=yes) + +AC_ARG_ENABLE(sdl, + [ --enable-sdl enable SDL display support (yes)], , enable_sdl=yes) + +AC_ARG_ENABLE(glx, + [ --enable-glx enable GLX display support (yes)], , enable_glx=yes) + +AC_ARG_ENABLE(gsl, + [ --enable-gsl enable gsl support (for matrix packets) (yes)], , enable_gsl=yes) + +AC_ARG_ENABLE(png, + [ --enable-png enable png image load/save support (yes)], , enable_png=yes) + +AC_ARG_ENABLE(debug, + [ --enable-debug enable debugging support (no)], , enable_debug=no) + + + +PDP_CFLAGS="-DPD -Wall -W -Wstrict-prototypes -Wno-unused -Wno-parentheses -Wno-switch" +dnl -Werror -Wshadow + + + + +dnl setup debugging +if test $enable_debug == yes +then + AC_DEFINE(PDP_DEBUG, 1, "enable debugging support") + PDP_CFLAGS="$PDP_CFLAGS -g -Werror -Wshadow" +else + AC_DEFINE(PDP_DEBUG, 0, "disable debugging support") + PDP_CFLAGS="$PDP_CFLAGS -O2 -funroll-loops -fomit-frame-pointer -ffast-math" +fi + +if test $prefix == NONE; +then + prefix=/usr/local +fi + + +dnl setup forced pwc support +if test $enable_pwc == yes; +then + AC_DEFINE(HAVE_PWCV4L, 1,enable forced pwc v4l support) +fi + + +dnl try to locate the pd header in case the setup is nonstandard +dnl check in $prefix/pd/src then ../pd/src +dnl if this fails we trust it is in the standard include path +PWD=`pwd` +if test -f $prefix/pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$prefix/pd/src" + +elif test -f $prefix/src/pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$prefix/src/pd/src" +elif test -f $PWD/../pd/src/m_pd.h; +then + PD_CPPFLAGS="-I$PWD/../pd/src" +elif test -f $PWD/../src/m_pd.h; +then + PD_CPPFLAGS="-I$PWD/../src" +fi + + +CPPFLAGS="$CPPFLAGS $PD_CPPFLAGS" +AC_CHECK_HEADER(m_pd.h,, + echo "WARNING: m_pd.h not found. Is PD installed?" + echo "WARNING: if you have changed PD_CPPFLAGS in Makefile.config.in you can ignore this warning." ) + +AC_CHECK_LIB(m,sin) + +ARCH=`uname -s` +if test $ARCH == Linux; +then + PDP_LIBRARY_NAME=pdp.pd_linux + + if test $enable_mmx == yes; + then + PDP_TARGET=linux_mmx + else + PDP_TARGET=linux + fi +elif test $ARCH == Darwin; +then + PDP_LIBRARY_NAME=pdp.pd_darwin + PDP_TARGET=darwin +else + echo WARNING: Architecture `uname -s` not supported. + exit +fi + + + +dnl Darwin specific stuff: this is still pretty experimental +dnl How to test if frameworks are present ???? +if test $ARCH == Darwin +then + PD_EXECUTABLE=$prefix/bin/pd + LIBS="$LIBS -L/sw/lib" + CPPFLAGS="$CPPFLAGS -I/sw/include" + PDP_EXTRA_CPPFLAGS="-I/sw/include" + +dnl if not darwin, assume target is linux +else + AC_CHECK_HEADER(linux/videodev.h, + PDP_OPTMOD="$PDP_OPTMOD pdp_v4l.o" + AC_DEFINE(HAVE_PDP_V4L, 1, build pdp_v4l), + echo " linux/videodev.h not found: not building pdp_v4l") + + +fi + +dnl optional gsl support +if test $enable_gsl == yes; +then + AC_CHECK_LIB(gslcblas,main) + AC_CHECK_LIB(gsl,main, + PDP_OPTTYPES="$PDP_OPTTYPES pdp_matrix.o" + PDP_MATRIX_BASIC="$PDP_MATRIX_BASIC pdp_mat_mul.o pdp_mat_lu.o pdp_mat_vec.o" + PDP_IMAGE_BASIC="$PDP_IMAGE_BASIC pdp_cheby.o" + PDP_IMAGE_SPECIAL="$PDP_IMAGE_SPECIAL pdp_histo.o" + AC_DEFINE(HAVE_PDP_GSL, 1, gsl support) + LIBS="$LIBS -lgslcblas -lgsl", + echo " libgsl not found: not building matrix type support") + + +fi + + +dnl optional png support +if test $enable_png == yes +then + AC_CHECK_LIB(png, png_read_image, + LIBS="$LIBS -lz -lpng" + AC_DEFINE(HAVE_PDP_PNG, 1, build png support), + echo " libpng not found: not building png support") +fi + + +dnl optional xwindow support +if test $enable_x == yes; +then + AC_CHECK_LIB(X11, XOpenDisplay, + PDP_X11MOD="$PDP_X11MOD pdp_xwindow.o" + AC_DEFINE(HAVE_PDP_X, 1, build X11 support) + LIBS="$LIBS -L/usr/X11R6/lib -lX11", + echo " libX11 not found: not building X11 support", + -L/usr/X11R6/lib) + +else + dnl no x support -> no xv and glx support + enable_xv=no + enable_glx=no + +fi + +dnl optional xvideo support +if test $enable_xv == yes; +then + AC_CHECK_LIB(Xv, XvPutImage, + PDP_X11MOD="$PDP_X11MOD pdp_xvideo.o" + PDP_OPTMOD="$PDP_OPTMOD pdp_xv.o" + LIBS="$LIBS -lXv -lXext" + AC_DEFINE(HAVE_PDP_XV, 1, build pdp_xv), + echo " libXv not found: not building pdp_xv", + -L/usr/X11R6/lib -lX11 -lXext) +fi + +dnl optional libquicktime support +if test $enable_quicktime == yes; +then + AC_CHECK_LIB(quicktime, lqt_decode_video, + PDP_OPTMOD="$PDP_OPTMOD pdp_qt.o" + LIBS="$LIBS -lquicktime" + AC_DEFINE(HAVE_PDP_QT, 1, build pdp_qt), + echo " libquicktime not found: not building pdp_qt") +fi + + +dnl optional glx support +if test $enable_glx == yes +then + AC_CHECK_LIB(GL, glXSwapBuffers, + PDP_OPTMOD="$PDP_OPTMOD pdp_glx.o" + LIBS="$LIBS -lGL -lGLU" + AC_DEFINE(HAVE_PDP_GLX, 1, build pdp_glx), + echo " libGL not found: not building pdp_glx", + -L/usr/X11R6/lib -lGLU) +fi + + +dnl optional sdl support +if test $enable_sdl == yes +then + AC_CHECK_LIB(SDL, SDL_Init, + PDP_OPTMOD="$PDP_OPTMOD pdp_sdl.o" + LIBS="$LIBS -lSDL" + AC_DEFINE(HAVE_PDP_SDL, 1, build pdp_sdl), + echo " libSDL not found: not building pdp_sdl") +fi + + +echo target is $PDP_TARGET + +echo "used configure options:" +echo " --enable-mmx=$enable_mmx" +echo " --enable-quicktime=$enable_quicktime" +echo " --enable-v4l=$enable_v4l" +echo " --enable-pwc=$enable_pwc" +echo " --enable-sdl=$enable_sdl" +echo " --enable-x=$enable_x" +echo " --enable-xv=$enable_xv" +echo " --enable-glx=$enable_glx" +echo " --enable-gsl=$enable_gsl" +echo " --enable-png=$enable_png" +echo " --enable-debug=$enable_debug" + + +AC_SUBST(PD_CPPFLAGS) +AC_SUBST(PD_EXECUTABLE) +AC_SUBST(PDP_EXTRA_CPPFLAGS) +AC_SUBST(PDP_CFLAGS) +AC_SUBST(PDP_EXTRA_CFLAGS) +AC_SUBST(PDP_LIBRARY_NAME) +AC_SUBST(PDP_TARGET) + +AC_SUBST(PDP_OPTMOD) +AC_SUBST(PDP_X11MOD) +AC_SUBST(PDP_PDMOD) +AC_SUBST(PDP_OPTTYPES) + +AC_SUBST(PDP_IMAGE_BASIC) +AC_SUBST(PDP_IMAGE_SPECIAL) +AC_SUBST(PDP_MATRIX_BASIC) + + +AC_CONFIG_FILES(Makefile.config) +AC_CONFIG_FILES(bin/pdp-config) +AC_OUTPUT + + + diff --git a/debug/c++test.cc b/debug/c++test.cc new file mode 100644 index 0000000..4183e8c --- /dev/null +++ b/debug/c++test.cc @@ -0,0 +1,4 @@ +#include "pdp.h" +int main(void) +{ +} diff --git a/debug/quicktime_crashtest.pd b/debug/quicktime_crashtest.pd new file mode 100644 index 0000000..b4bb088 --- /dev/null +++ b/debug/quicktime_crashtest.pd @@ -0,0 +1,164 @@ +#N canvas 190 294 862 660 10; +#X obj 122 506 pdp_xv; +#X msg 135 81 bang; +#X floatatom 54 78 5 0 0; +#X msg 222 90 open /home/ben/MOV/test1.mov; +#X msg 418 369 open /home/ben/MOV/eye.mov; +#X obj 126 26 i 0; +#X obj 182 37 + 1; +#X obj 217 47 metro 40; +#X obj 262 17 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1 +-1; +#X msg 25 47 0; +#X msg 64 49 9999; +#X msg 25 149 loop \$1; +#X obj 21 123 tgl 15 0 empty empty empty 20 8 0 8 -262144 -1 -1 0 1 +; +#X floatatom 264 231 5 0 0; +#X floatatom 538 184 5 0 0; +#X msg 370 44 open \$1; +#X obj 369 20 openpanel; +#X obj 354 3 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1 +-1; +#X floatatom 192 459 5 0 0; +#X floatatom 309 9 5 0 0; +#X msg 298 135 open /home/ben/MOV/nogeseenfilmke.mov; +#X obj 346 406 table tab1; +#X msg 56 23 close; +#X obj 250 542 dac~; +#X msg 315 390 0; +#X obj 316 427 tabplay~ tab1; +#X msg 332 325 importaudio tab1; +#X obj 26 185 tgl 15 0 empty empty empty 20 8 0 8 -262144 -1 -1 0 1 +; +#X floatatom 180 83 5 0 0; +#X msg 215 7 stop; +#X obj 478 213 i; +#X obj 490 276 mod; +#X obj 494 244 + 1; +#X floatatom 558 226 5 0 0; +#X msg 30 211 autoplay \$1; +#X floatatom 501 321 5 0 0; +#X obj 119 331 pdp_del 10; +#X floatatom 194 289 5 0 0; +#X obj 384 221 *; +#X obj 288 159 hsl 300 15 0 1 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X obj 305 44 hsl 300 15 0 1000 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X msg 329 254 loop \$1; +#X obj 325 228 tgl 15 0 empty empty empty 20 8 0 8 -262144 -1 -1 0 +1; +#X obj 236 258 pdp_trigger; +#X obj 117 421 pdp_mix; +#X floatatom 182 390 5 0 0; +#X obj 278 349 hsl 300 15 0 1 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X msg 434 394 open /home/ben/MOV/nogeseenfilmke.mov; +#X obj 241 175 tgl 15 0 empty empty empty 20 8 0 8 -262144 -1 -1 0 +1; +#X msg 245 201 autoplay \$1; +#X obj 408 254 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 65 281 close; +#X obj 352 484 vol~; +#X obj 221 497 vol~; +#X floatatom 252 470 5 0 0; +#X floatatom 382 460 5 0 0; +#X msg 418 281 close; +#X msg 121 145 play; +#X msg 347 229 play; +#X msg 447 13 bang; +#X msg 564 13 stop; +#X msg 540 97 \; pd dsp 1; +#X msg 616 98 \; pd dsp 0; +#X floatatom 608 13 5 0 0; +#X msg 732 104 close; +#X msg 778 105 close; +#X obj 470 66 route 0 1 2 3 4 5 6 7; +#X msg 675 13 140; +#X obj 489 42 random 6; +#X obj 483 12 metro 140; +#X obj 715 46 loadbang; +#X msg 750 76 \; pd dsp 1; +#X obj 133 205 pdp_qt~; +#X obj 322 283 pdp_qt~; +#X obj 207 71 random 250; +#X connect 1 0 72 0; +#X connect 2 0 72 0; +#X connect 3 0 72 0; +#X connect 4 0 73 0; +#X connect 5 0 6 0; +#X connect 5 0 1 0; +#X connect 6 0 5 1; +#X connect 7 0 74 0; +#X connect 8 0 7 0; +#X connect 9 0 2 0; +#X connect 10 0 2 0; +#X connect 11 0 72 0; +#X connect 12 0 11 0; +#X connect 14 0 31 1; +#X connect 14 0 38 1; +#X connect 15 0 72 0; +#X connect 16 0 15 0; +#X connect 17 0 16 0; +#X connect 18 0 0 1; +#X connect 19 0 7 1; +#X connect 20 0 72 0; +#X connect 22 0 72 0; +#X connect 24 0 25 0; +#X connect 26 0 72 0; +#X connect 27 0 34 0; +#X connect 28 0 72 1; +#X connect 29 0 7 0; +#X connect 30 0 32 0; +#X connect 31 0 35 0; +#X connect 32 0 31 0; +#X connect 33 0 32 1; +#X connect 34 0 72 0; +#X connect 36 0 44 0; +#X connect 37 0 36 1; +#X connect 38 0 28 0; +#X connect 39 0 38 0; +#X connect 40 0 19 0; +#X connect 41 0 73 0; +#X connect 42 0 41 0; +#X connect 44 0 0 0; +#X connect 45 0 44 2; +#X connect 46 0 45 0; +#X connect 47 0 73 0; +#X connect 48 0 49 0; +#X connect 49 0 73 0; +#X connect 50 0 73 0; +#X connect 51 0 72 0; +#X connect 56 0 73 0; +#X connect 57 0 72 0; +#X connect 58 0 73 0; +#X connect 59 0 69 0; +#X connect 59 0 58 0; +#X connect 59 0 57 0; +#X connect 60 0 69 0; +#X connect 63 0 69 1; +#X connect 64 0 72 0; +#X connect 65 0 73 0; +#X connect 66 0 3 0; +#X connect 66 1 20 0; +#X connect 66 2 4 0; +#X connect 66 3 47 0; +#X connect 66 6 64 0; +#X connect 66 7 65 0; +#X connect 67 0 63 0; +#X connect 68 0 66 0; +#X connect 69 0 68 0; +#X connect 70 0 59 0; +#X connect 70 0 71 0; +#X connect 72 0 43 0; +#X connect 72 0 36 0; +#X connect 72 1 13 0; +#X connect 72 2 14 0; +#X connect 72 3 23 1; +#X connect 72 4 23 0; +#X connect 73 0 44 1; +#X connect 73 3 23 0; +#X connect 73 4 23 1; +#X connect 74 0 28 0; diff --git a/debug/teststuff.c b/debug/teststuff.c new file mode 100644 index 0000000..1718e57 --- /dev/null +++ b/debug/teststuff.c @@ -0,0 +1,29 @@ +/* some test stuff */ + +#if 0 + + { + t_pdp_list *l = pdp_list_from_cstring("(een 2 3. (1 1 1 1 1))", 0); + t_pdp_list *s = pdp_list_from_cstring("(symbol int float (int int ...))", 0); + //PDP_ASSERT(0); + pdp_list_print(l); + pdp_list_print(s);` + post("%d", pdp_tree_check_syntax(l, s)); + exit(1); + } +#endif + +#if 0 + + { + char *c = "(test 1 2 (23 4)) ( 1 [asdflkj; las;dlfkj;a sdf]) (een (zes (ze)ven ())) ["; + while (*c){ + t_pdp_list *l = pdp_list_from_cstring(c, &c); + if (l) pdp_list_print(l); + else{ + post("parse error: remaining input: %s", c); break; + } + } + exit(1); + } +#endif diff --git a/doc/misc/devdoc.html b/doc/misc/devdoc.html new file mode 100644 index 0000000..5ce1f83 --- /dev/null +++ b/doc/misc/devdoc.html @@ -0,0 +1,167 @@ + + + + PDP Developer Documentation + + + +

PDP Developer Documentation

+ +

Introduction

+ +

There is not yet much developer information, partly because pdp is not that big and since the goals are + not completely clear yet, a lot will probably change on the inside in the future. I believe it is + not too hard to figure out how it works, once you get started somewhere. This document is a minimalistic + attempt to provide that starting point. For full prototypes see the header files. I suggest you have a look at the pdp_base base class, and some simple + modules: pdp_add, pdp_noise and pdp_gain for examples. + +

PDP architecture

+

Architecture is a big word, but pdp is organized as modules. A packet pool module (a reuse pool memory manager), + a packet class, a processing queue module, a high level type conversion module, an image packet class, and some + low level modules for image type conversion, image resampling and all sorts of other image processing. Besides that + there are 2 extension libraries: pdp_scaf, a cellular automata extension and pdp_opengl, a 3d rendering extension. + These are separate because of portability issues. The different pdp_* externs in the main pdp library use the + core modules' functionality to minimize code duplication. I'm relatively happy with how it fits together, + but some things need to change for future plans. Most objects are written in the object oriented c style of pd. + To prevent namespace conflicts, (almost) all routines start with the pdp_ prefix. The second name is the name of the + object or module they belong to. The first argument is always a pointer to an object or an integer (for packets). + + +

PD ties

+

PDP is written as an extension for PD. One of the goals of pdp is to evolve to a separate library that can + be reused in other software. The architecture will be split into two parts. A pd-independent part (the packet classes, + the packet pool, the type conversion system and the forth system) and a part with pd specific stuff (the process queue and interfaces to the + pd system like the base classes and the pd communication protocol). In order to do this the packet class will probably + evolve to a proper object model, supporting run time attribute binding (inspired by the python object model). + +

There are some things that put a stamp on the current pdp design. Most importantly pd's processor object model and + communication protocol. (i.e. the fact that pd only supports unidirectional messaging creates the awkward concept + of a "passing packet" to eliminate excessive data copying.) + +

In pd, the pdp messaging protocol is implemented as pd messages. The protocol is however 3 phase. + With a read only register phase, a read/write register phase and a process phase. This functionality + is part of the base class or the forth processor object. The dpd protocol is entirely different, + and is used in the opengl library. It is + not based on parallel dataflow but serial context passing. + +

Packets

+

PDP introduces a new atom: the data packet. This can contain all kinds of data. Images (16bit/8bit), cellular + automata (1bit), matrices (real/complex float/double), opengl textures and 3d rendering contexts. Packets + are stored in a pool to ensure fast reuse, and to enable sharing. The paradigm is centered around a + combination of an object oriented approach and a dataflow approach. +

The methods operating on packets + (pdp_packet_*) are mainly for administrative purposes: memory management (construction, registering, copying) + and getting or setting info. +

All processing is done in the pd modules. Processors can be defined using + the forth scripting language, but this is still experimental. The forth system can be accessed + from the guile library. +

There is a central mechanism for packet type conversion. This is to facilitate the combination of different + media types. Whenever a packet class is constructed (i.e. in an extension library), a number of conversion + routines should be defined to convert the added type to one or some of the main pdp types. + + + + + + +

PDP API Overview

+ + The pdp public api contains only a single class: the packet. (The internal api has more classes, that can be used + too if necessary, but i won't document them.) A packet is a class in pdp. The table below lists the supported methods. + The first argument of a call is a packet id. + + +
pdp_packet_* +
new construct a raw packet (depreciated) +
new_* construct packet of specific type/subtype/... +
mark_unused release +
mark_passing conditional release (release on first copy ro/rw) +
copy_ro readonly (shared) copy +
copy_rw private copy +
clone_rw private copy (copies only meta data, not the content) +
header get the raw header (t_pdp *) +
data get the raw data (void *) +
pass_if_valid send a packet to pd outlet, if it is valid, and mark unused +
replace_if_valid delete packet and replace with new one, if new is valid +
copy_ro_or_drop copy readonly, or don't copy if dest slot is full + send drop notify +
copy_rw_or_drop same, but private copy +
get_description retrieve type info +
convert_ro same as copy_ro, but with an automatic conversion matching a type template +
convert_rw same as convert_ro, but producing a private copy +
+ + +

The pool object methods. All the packets are stored in a central packet pool. + + +
pdp_pool_* +
collect_garbage manually free all unused resources in packet pool +
+ +

The process queue object methods. PDP supports a separate processing thread. + + +
pdp_queue_* +
add add a process method + callback +
finish wait until a specific task is done +
wait wait until processing queue is done +
+ +

The control methods. General pdp control messages. + + +
pdp_control_* +
notify_drop notify that a packet has been dropped +
+ +

The type mediator methods. + +
pdp_type_* +
description_match check if two type templates match +
register_conversion register a type conversion program + + +
+ + +

NOTE: it is advised to derive your module from the pdp base class defined in pdp_base.h + instead of communicating directly with the pdp core + + + +

pdp_base class

+ If you want to write a pdp extern, you can derive it from the pdp_base class, instead of t_object. + This class abstracts a lot of the hassle of writing ordinary (inplace) packet processors. The base + allows you to register process callbacks. There are 3 kinds of callbacks: preproc, process and postproc. + The preproc method is called inside the pd thread. This can be used to setup some things that can only + be done inside the pd thread. The process method should do most of the work, and is called from the + pdp processing thread if it is enabled, after the preproc method is finished. You can't use most + of pd's calls in this method. The postproc method is called + from the pd thread after the process method is finished, and can be used to send data to pd outlets. Simple + packet processors only need the process method (packet input/output is handled by the pdp_base class). + +

pdp_imageproc_* modules

+ Most of the image processing code is organized as planar 16 bit signed processors. + This is crude and oversimplified, but it helps to keep the code size small and fast + at the same time (platform dependent assembly code is reduced to a bare minimum). These + routines can be used to build higher level image processing objects that are more (cache) + efficient than an abstraction using separate pdp modules. If you plan to write your own image + processing routines, you can use the pdp_imageproc_dispatch_ routine to support all 16bit image + types at once (greyscale, subsampled YCrCb, multichannel planar). This requires you write the + image processing routine as a planar (greyscale) processor using the pdp_imageproc_ + interface. (see pdp_imageproc.h) + +

pdp_llconv call

+ Low level image conversion routines. (operating on raw data buffers). You probably won't need this, + since the high level type conversion (pdp_packet_convert_ro/rw) covers most of its functionality. + + + +
+
Tom Schouten
+ + +Last modified: Fri Sep 19 04:52:12 CEST 2003 + + + diff --git a/doc/misc/layers.txt b/doc/misc/layers.txt new file mode 100644 index 0000000..a02e481 --- /dev/null +++ b/doc/misc/layers.txt @@ -0,0 +1,222 @@ +pdp 0.13 design layers + components +----------------------------------- + +from version 0.13 onwards, pdp is no longer just a pd plugin but a +standalone unix library (libpdp). this documents is an attempt to +describe the design layers. + +A. PD INTERFACE +--------------- + +on the top level, libpdp is interfaced to pd using a glue layer which +consists of + +1. pdp/dpd protocols for pd +2. process queue +3. base classes for pdp/dpd +4. some small utility pd objects +5. pd specific interfaces to part of pdp core +6. pdp_console +7. pd object interface to packet forth (pdp object) + + +1. is the same as previous versions to ensure backwards compatibility in +pd with previous pdp modules and extensions that are written as pd +externs or external libs. this includes parts of pdp that are not yet +migrated to libpdp (some of them are very pd specific and will not be +moved to libpdp), and pidip. if you intend to write new modules, it is +encouraged to use the new forth based api, so your code can be part of +libpdp to use it in other image processing applications. + +2. is considered a pd part. it implements multithreading of pdp inside +pd. multithreading is considered a host interface part, since it usually +requires special code. + +3. the base classes (pd objects) for pdp image processing remain part of +the pd<->pdp layer. the reason is the same as 1. a lot of the original +pd style pdp is written as subclasses of the pdp_base, pdp_image_base, +dpd_base and pdp_3dp_base classes. if you need to write pd specific +code, it is still encouraged to use these apis, since they eliminate a +lot of red tape involving the pdp protocol. a disadvantage is that this +api is badly documented, and the basic api (1.) is a lot simpler to +learn and documented. 3dp is supposed to merge to the new forth api, +along with the image/video processing code. + +4. is small enough to be ignored here + +5. includes interfaces to thread system and type conversion system + +some pd specific stuff using 1. or 3. + +6. the console interface to the pdp core, basicly a console for a +forth like language called packet forth which is pdp's main scripting +language. it's inteded for develloping and testing pdp but it can be +used to write controllers for pd/pdp/... too. this is based on 1. + +7. is the main link between the new libpdp and pd. it is used to +instantiate pdp processors in pd which are written in the packet forth. +i.e. to create a mixer, you instantiate a [pdp mix] object, which would +be the same as the previous [pdp_mix] object. each [pdp] object creates +a forth environment, which is initialized by calling a forth init +method. [pdp mix] would call the forth word init_mix to create the local +environment for the mix object. wrappers will be included for backward +compatibility when the image processing code is moved to libpdp. + + +B. PDP SYSTEM CODE +------------------ + +1. basic building blocks: symbol, list, memory manager +2. packet implementation (packet class and reuse queue) +3. packet type conversion system +4. os interface (X11, net, png, ...) +5. packet forth +6. additional libraries + + +1. pdp makes intensive use of symbols and lists (trees, stacks, queues). +pdp's namespace is built on the symbol implementation. a lot of other +code uses the list + +2. the pdp packet model is very simple. basicly nothing more than +constructors (new, copy, clone), destructors (mark_unused (for reuse +later), delete). there is no real object model for processors. this is a +conscious decision. processor objects are implemented as packet forth +processes with object state stored in process data space. this is enough +to interface the functionality present in packet forth code to any +arbitrary object oriented language or system. + +3. each packet type can register conversion methods to other types. the +type conversion system does the casting. this is not completely finished +yet (no automatic multistage casting yet) but most of it is in place and +usable. no types without casts. + +4. os specific modules for input/output. not much fun here.. + +5. All of pdp is glued together with a scripting language called packet +forth. This is a "high level" forth dialect that can operate on floats, +ints, symbols, lists, trees and packets. It is a "fool proof" forth, +which is polymorphic and relatively robust to user errors (read: it +should not crash or cause memory leaks when experimenting). It is +intended to serve as a packet level glue language, so it is not very +efficient for scalar code. This is usually not a problem, since packet +operations (esp. image processing) are much more expensive than a this +thin layer of glue connecting them. + +All packet operations can be accessed in the forth. If you've ever +worked with HP's RPN calculators, you can use packet forth. The basic +idea is to write objects in packet forth that can be used in pd or in +other image processing applications. For more information on packet +forth, see the code (pdp_forth.h, pdp_forth.c and words.def) + +6. opengl lib, based on dpd (3.) which will be moved to packet forth +words and the cellular automata lib, which will be moved to +vector/slice forth later. + + +C. LOW LEVEL CODE +----------------- + +All the packet processing code is (will be) exported as packet forth +words. This section is about how the code exported by those words is +structured. + +C.1 IMAGE PROESSING: VECTOR FORTH + +Eventually, image operations need to be implemented, and in order +to do this efficiently, both codewize (good modularity) as execution speed +wize, i've opted for another forth. DSP and forth seem to mix well, once +you get the risc pipeline issues out of the way. And, as a less rational +explanation, forth has this magic kind of feel, something like art.. +well, whatever :) + +As opposed to the packet forth, this is a "real" lowlevel forth +optimized for performance. Its reason of being is the solution of 3 +problems: image processing code factoring, quasi optimal processor +pipeline & instruction usage, and locality of reference for maximum +cache performance. Expect crashes when you start experimenting with +this. It's really nothing more than a fancy macro assembler. It has no +safety belts. Chuck Moore doctrine.. + +The distinction between the two forths is at first sight not a good +example of minimizing glue layers. I.e. both systems (packet script +forth and low level slice forth) are forths in essence, requiring +(partial) design duplication. Both implementations are however +significantly different which justified this design duplication. + +Apart from the implementation differences, the purpose of both languages +is not the same. This requires the designs of both languages to be +different in some respect. So, with the rule of "do everything right +once" in mind, this small remark tries to justify the fact that forth != +forth. + +The only place where apparent design correspondence (the language model) +is actually used is in the interface between the packet forth and the +slice forth. + +The base forth is an ordinary minimal 32bit (or machine word +lenght) subroutine threaded forth, with a native code kernel for +i386/mmx, a portable c code kernel and room for more native code kernels +(i.e i386/sse/sse2/3dnow, altivec, dsp, ...) Besides support for native +machine words bit ints and pointers, no floats, since they clash with +mmx, are not needed for the fixed point image type, and can be +implemented using other vector instructions when needed), support for +slices and a separate "vector stack". + +Vectors are the native machine vectors, i.e. 64bit for mmx/3dnow, +128bit for sse/sse2, or anything else. The architecture is supposed to +be open. (I've been thinking to add a block forth, operating on 256bit +blocks to eliminate pipeline issues). Blocks are just blocks of vectors +which are used as a basic loop unrolling data size grain for solving +pipeline operations in slice processing words. + +Slices are just arrays of blocks. In the mmx forth kernel, they can +represent 4 scanlines or a 4 colour component scanline, depending on how +they are fed from packet data. Slices can be anything, but right now, +they're just scanlines. The forth kernel has a very simple and efficient +(branchless) reference count based memory allocator for slices. This +slice allocator is also stack based which ensures locality of reference: +a new allocated slice is the last deallocated slice. + +The reason for this obsession with slices is that a lot of video +effects can be chained on the slice level (scanline or bunch of +scanlines), which improves speed through more locality of reference. In +concreto intermediates are not flushed to slower memory. The same +principles can be used to do audio dsp, but that's for later. + +The mmx forth kernel is further factored down following another +virtual machine paradigm. After doing some profiling, i came to the +conclusion that the only, single paradigm way of writing efficient +vector code on today's machines is multiple accumulators to avoid +pipeline stalls. The nice thing about image processing is that it +parallellizes easily. Hence the slice/block thing. This leads to the +1-operand virtual machine concept for the mmx slice operations. The +basic data size is one 4x4 pixel block (16bit pixels), which is +implemented as asm macros in mmx-sliceops-macro.s and used in +mmx-sliceops-code.s to build slice operations. The slice operations are +built out of macro instructions for this 256bit or 512bit, 2 or 1 +register virtual machine which has practically no pipeline delays +between its instructions. + +Since the base of sliceforth is just another forth, it could be that +(part of) 3dp will be implemented in this lowlevel forth too, if +performance dictates it. It's probably simpler to do it in the lowlevel +forth than the packet forth anyway, in the form of cwords. + +C.2: MATRIX PROCESSING: LIBGSL + +All matrix processing packet forth words are (will be) basicly wrappers +around gsl library calls. Very straightforward. + +C.3: OPENGL STUFF + +The same goes for opengl. The difference here is that it uses the dpd +protocol in pdp, which is more like the Gem way of doing things. The +reason for this is that, although i've tried hard to avoid it, opengl +seems to dictate a drawing context based, instead of an object based way +of working. So processing is context (accumulator) based. Packet forth +will probably get some object oriented, or context oriented feel when +this is implemented. + + + + diff --git a/doc/misc/overview.html b/doc/misc/overview.html new file mode 100644 index 0000000..6eb0e70 --- /dev/null +++ b/doc/misc/overview.html @@ -0,0 +1,102 @@ + +Pure Data Packet + + +

Pure Data Packet

+ + +

Introduction

+ +

Pure Data Packet (PDP) is an extension library for the computer music +program Pure Data (PD), by Miller Puckette and +others. Its goal is to provide a way to use arbitrary data types (data +packets) as messages that can be passed around inside PD, along side the +standard PD numbers and symbol types. In short it puts any data object on +the same level as a float or a symbol. + +

PDP runs on Linux and OSX. The OSX version depends on Fink, which is not in the "point & +click" stage yet, so setting it up will require some efford. There is no +windows version. The reason for this is simple: i don't use windows myself. +Porting would require writing code for input/output and getting the +libraries PDP depends on to work. If anyone is willing to do this, just let +me know. PDP can run without X Window, using SDL. + +

Currently, PDP's focus is on images and video, but there is no reason it +should stay like that. There is limited support for matrix processing +included in the main library (like Jitter or Gridflow). There is an +extension library for 1D and 2D binary cellular automata, opengl rendering +(like Gem). Some plans include audio buffers (like Vasp), ascii packets, +text buffers, ... Finally there's a library that enables you to connect a +scheme interpreter (guile) to PD/PDP. For more image processing objects, +have a look at Yves Degoyon's PiDiP library. + +

Getting Started

+ +If you're used to working with PD, the the documentation and example +patches should be enough to get you started. Have a look at the README file +in the distribution to find out how to compile and setup. The file +doc/reference.txt contains a list of objects. If you have installed PDP +properly, you can just press the right mouse button on an object and select +help to get a help patch. If this doesn't work, look in the directory +doc/objects for a collection of help patches. The directory doc/examples +contains some more demos. The directory doc/objects contains two +abstractions that are used to setup the input and output in the help +patches. You might want to cut and connect some wires to use the +input/output setup that works for you. + +

Packets and Types

+ +

PDP is centered around the concept of packets and operations on +packets. There are several types of packets. The default type for most +objects is image/YCrCb/320x240. This is a single video +frame, encoded in the internal 16bit YUV format, measuring 320 by 240 +pixels. Another image type is the grayscale image +image/grey/320x240. Important notes: All image processing objects that +combine two or more packets need to be fed with the same packet types, i.e. +encoding (YCrCb/grey) and dimensions need to be the same. Image dimensions need to be a +multiple of 8x8. + +

The +bitmap/*/* type is another image representation type +supporting several encodings. I.e. bitmap/rgb/*, +bitmap/rgba/*, bitmap/yv12/*, ... + +This type cannot be processed directly by most of the image processing +objects, but it can be used to store in delay lines, or to send over the +network. It's main use is to support all kinds of input/output devices, and +opengl textures, without introducing too many conversions, but it can serve +as a space and bandwidth saver too (especially +bitmap/yv12/*). + +

One of the interesting +features in PD is the possibility of connecting everything with everything. +If you want to generalize this to all kinds of media objects, the complexity +of managing the different types starts to grow quite fast. Therefore PDP has +a type conversion system that can take care of most of the conversions +using the [pdp_convert] object. You can manually convert +packets to a certain type by specifying a type template as a creation +argument. I.e. [pdp_convert image/grey/*] will convert +any packet to a greyscale image. Most of the conversion will become +automatic later on. + +

An example: You can use the basic PDP library together with the +cellular automata library and the opengl rendering library to use a cellular +automaton as an input to a video processing chain. You can convert the +processed image to a texture that can be applied to a 3d object, which then +can be drawn to the screen, captured as a texture, converted back to an +image, which can then be converted to a sound, processed and converted back +to an image, etc... You get the point. The possibilities are endless. + + + +

+
Tom Schouten
+ + +Last modified: Thu Sep 25 20:51:44 CEST 2003 + + + diff --git a/doc/misc/todo.jme b/doc/misc/todo.jme new file mode 100644 index 0000000..2ce317d --- /dev/null +++ b/doc/misc/todo.jme @@ -0,0 +1,4 @@ +todo list of jme@off.net +------------------------ +- a packet to trigger packet generator instead of bang + o the created packet has the same format as the incoming packet diff --git a/doc/reference.txt b/doc/reference.txt new file mode 100644 index 0000000..d9b7d92 --- /dev/null +++ b/doc/reference.txt @@ -0,0 +1,156 @@ +This is a list of all pdp objects and abstractions with a minimal description. +Take a look at the patches in the doc/ directory for more info. +(Messy doc & test patches can be found in the test/ directory.) + +general purpose pdp modules: + +pdp_del a packet delay line +pdp_reg a packet register +pdp_snap takes a snapshot of a packet stream +pdp_trigger similar to pd's trigger object +pdp_route routes a packet to a specific outlet +pdp_loop a packet loop sampler (packet array) +pdp_description output a symbol describing the packet type +pdp_convert convert between packet types + +image inputs/outputs: + +pdp_xv displays images using the xvideo extension +pdp_glx displays images using opengl +pdp_v4l reads images from a video4linux device +pdp_qt reads quicktime movies + +image processors: + +pdp_abs absolute value +pdp_add adds two images +pdp_and bitwize and +pdp_bitdepth set bit depth +pdp_bitmask apply a bit mask +pdp_bq spatial biquad filter +pdp_bqt temporal biquad filter +pdp_cog gaussian blob estimator +pdp_constant fills an image with a constant +pdp_conv horizontal/vertical seperable convolution filter +pdp_cheby chebyshev color shaper +pdp_chrot rotates the chroma components +pdp_flip_lr flip left <-> right +pdp_flip_tb flip top <-> bottom +pdp_grey converts an image to greyscale +pdp_grey2mask converts a greyscale image to an image mask +pdp_hthresh hard thresholding +pdp_mul multiplies two images +pdp_mix crossfade between 2 images +pdp_mix2 mixes 2 images after applying a gain to each of them +pdp_noise a noise generator +pdp_not bitwize not +pdp_or bitwize or +pdp_plasma plasma generator +pdp_pointcloud convert an image to a point cloud +pdp_positive sign function that creates a bitmask +pdp_randmix crossfades 2 images by taking random pixels +pdp_rotate tiled rotate +pdp_scale rescale an image +pdp_sign sign function +pdp_sthresh soft thresholding +pdp_zoom tiled zoom +pdp_zrot tiled zoom + rotate +pdp_zthresh zero threshold (x<0 -> 0) +pdp_xor bitwize xor + +dsp objects + +pdp_scope~ a very simple oscilloscope +pdp_scan~ phase input scanned synthesis oscillator +pdp_scanxy~ x,y coordinate input scanned synthesis oscillator + + +utility abstractions + +pdp_pps computes the packet rate in packets/sec + +image abstractions + +pdp_affine scale (gain) + offset +pdp_agc automatic gain control (intensity maximizer) +pdp_alledge an all edge detector +pdp_blur blurs an image +pdp_blur_hor horizontal blur +pdp_blur_ver vertical blur +pdp_contrast contrast enhancement +pdp_conv_alledge edge detector +pdp_conv_emboss emboss effect +pdp_conv_smooth smoothing +pdp_conv_sobel_hor horizontal sobel edge detector +pdp_conv_sobel_ver vertical sobel edge detector +pdp_conv_sobel_edge sum of squares of hor and ver edge detector +pdp_dither a dither effect +pdp_gain3 independent channel gains +pdp_gradient grayscale to colour gradient conversion +pdp_grey convert image to greyscale +pdp_invert invert video +pdp_motion_blur blurs motion +pdp_motion_fade motion triggered fade out +pdp_motion_phase phase shifts motion +pdp_offset add an offset to an image +pdp_phase applies an allpass filter to an image +pdp_phase_hor horizontal allpass +pdp_phase_ver vertical allpass +pdp_png_to convert a png file (on disk) to a certain packet type +pdp_qt_control movie file controller (different play modes) +pdp_qtloop~ varispeed (interpolated) looper +pdp_qtloop2~ same, but depends on tabreadmix~ from creb +pdp_saturation change colour saturation +pdp_save_png_sequence save png sequence in /tmp dir +pdp_sub subtract 2 images +pdp_invert inverse video +pdp_tag tag a packet (to use it with route) +pdp_xv_keycursor a keyboard/mouse controller using pdp_xv + + +matrix processors + +pdp_m_mv matrix vector multiply +pdp_m_mm matrix matrix multiply +pdp_m_+=mm matrix matrix multiply add +pdp_m_LU compute LU decomposition +pdp_m_LU_inverse compute matrix inverse from LU decomp +pdp_m_LU_solve solve a linear system using LU decomp + +matrix abstractions + +pdp_m_inverse compute matrix inverse + + + + +SEPARATE LIBRARIES: + +cellular automata +(pdp_scaf) + +pdp_ca computes a cellular automaton (as a generator or a filter) +pdp_ca2image convert a CA packet to a greyscale image (obsolete: use pdp_convert) +pdp_image2ca convert an image to a CA packet (black and white) (obsolete: use pdp_convert) + + +3d drawing objects +(pdp_opengl) + +3dp_windowcontext a drawable window +3dp_draw draw objects (cube, sphere, ...) +3dp_view viewing transforms (rotate, translate, ...) +3dp_light light source +3dp_push push a matrix (modelview, texture, ...) +3dp_dlist compile a display list +3dp_snap copies the drawing buffer to a texture packet +3dp_mode set the current matrix mode +3dp_toggle set some opengl state variables + + +3d drawing abstractions (pdp_opengl) + +3dp_mouserotate connect to 3dp_windowcontext to rotate the scene +3dp_blend turn on accumulative blending mode + + -- cgit v1.2.1