initial checkin

Original commit message from CVS:
initial checkin

AUTHORS

@@ -0,0 +1 @@
+Erik Walthinsen <omega@cse.ogi.edu>

COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  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 COPYING, 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
+
+	    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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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) year  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.
+
+  <signature of Ty Coon>, 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.

COPYING.LIB

@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 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.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, 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 library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, 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 companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, 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 library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete 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 distribute a copy of this License along with the
+Library.
+
+  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 Library or any portion
+of it, thus forming a work based on the Library, 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) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+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 Library, 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 Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you 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.
+
+  If distribution of 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 satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  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.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library 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.
+
+  9. 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 Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+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.
+
+  11. 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 Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library 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 Library.
+
+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.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library 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.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library 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 Library
+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 Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+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
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. 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 LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), 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 Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  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.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

INSTALL

@@ -0,0 +1,182 @@
+Basic Installation
+==================
+
+   These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, a file
+`config.cache' that saves the results of its tests to speed up
+reconfiguring, and a file `config.log' containing compiler output
+(useful mainly for debugging `configure').
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If at some point `config.cache'
+contains results you don't want to keep, you may remove or edit it.
+
+   The file `configure.in' is used to create `configure' by a program
+called `autoconf'.  You only need `configure.in' if you want to change
+it or regenerate `configure' using a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes awhile.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  You can give `configure'
+initial values for variables by setting them in the environment.  Using
+a Bourne-compatible shell, you can do that on the command line like
+this:
+     CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
+
+Or on systems that have the `env' program, you can do it like this:
+     env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not supports the `VPATH'
+variable, you have to compile the package for one architecture at a time
+in the source code directory.  After you have installed the package for
+one architecture, use `make distclean' before reconfiguring for another
+architecture.
+
+Installation Names
+==================
+
+   By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=PATH' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' can not figure out
+automatically, but needs to determine by the type of host the package
+will run on.  Usually `configure' can figure that out, but if it prints
+a message saying it can not guess the host type, give it the
+`--host=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name with three fields:
+     CPU-COMPANY-SYSTEM
+
+See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the host type.
+
+   If you are building compiler tools for cross-compiling, you can also
+use the `--target=TYPE' option to select the type of system they will
+produce code for and the `--build=TYPE' option to select the type of
+system on which you are compiling the package.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Operation Controls
+==================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--cache-file=FILE'
+     Use and save the results of the tests in FILE instead of
+     `./config.cache'.  Set FILE to `/dev/null' to disable caching, for
+     debugging `configure'.
+
+`--help'
+     Print a summary of the options to `configure', and exit.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--version'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`configure' also accepts some other, not widely useful, options.

Makefile.am

@@ -0,0 +1 @@
+SUBDIRS = gst plugins test editor tools docs

README

@@ -0,0 +1,7 @@
+This is gnome-streamer, a framework for streaming media in GNOME.  The
+fundamental design comes from the video pipeline at Oregon Graduate
+Institute, as well as some ideas from DirectX.  It's based on plug-ins
+that will provide the various codec and other functionality.  The
+interface hopefully is generic enough for various companies (ahem, Apple)
+to release binary codecs for Linux, until such time as they get a clue and
+release the source.

acconfig.h

@@ -0,0 +1,11 @@
+#undef PLUGINS_DIR
+#undef PLUGINS_SRCDIR
+#undef PLUGINS_USE_SRCDIR
+
+#undef HAVE_LIBGHTTP
+#undef HAVE_LIBXML
+#undef HAVE_LIBMMX
+
+#undef HAVE_ATOMIC_H
+
+#undef DEBUG_ENABLED

autogen.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+# Run this to generate all the initial makefiles, etc.
+
+DIE=0
+package=gstreamer
+srcfile=gst/gstobject.h
+
+(autoconf --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	echo "You must have autoconf installed to compile $package."
+	echo "Download the appropriate package for your distribution,"
+	echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
+	DIE=1
+}
+
+(libtool --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	echo "You must have libtool installed to compile $package."
+	echo "Get ftp://alpha.gnu.org/gnu/libtool-1.2.tar.gz"
+	echo "(or a newer version if it is available)"
+	DIE=1
+}
+
+(automake --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	echo "You must have automake installed to compile $package."
+	echo "Get ftp://ftp.cygnus.com/pub/home/tromey/automake-1.2d.tar.gz"
+	echo "(or a newer version if it is available)"
+	DIE=1
+}
+
+if test "$DIE" -eq 1; then
+	exit 1
+fi
+
+test -f $srcfile || {
+	echo "You must run this script in the top-level $package directory"
+	exit 1
+}
+
+if test -z "$*"; then
+	echo "I am going to run ./configure with no arguments - if you wish "
+        echo "to pass any to it, please specify them on the $0 command line."
+fi
+
+libtoolize --copy --force
+aclocal $ACLOCAL_FLAGS
+automake --add-missing
+autoconf
+autoheader
+
+if [ "x$1" = "x--autogen-recurse" ];then
+  exit	# the rest will happen later
+fi
+
+for dir in `find * -name autogen.sh -print | grep -v '^autogen.sh$' | \
+            sed 's/autogen.sh$//'`;do
+  echo "Recursively running autogen.sh in $dir"
+  pushd $dir > /dev/null
+  ./autogen.sh --autogen-recurse "$@"
+  popd > /dev/null
+done
+
+./configure --enable-maintainer-mode "$@"
+
+echo 
+echo "Now type 'make' to compile $package."

config.h.in

@@ -0,0 +1,29 @@
+/* config.h.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Define if you need to in order for stat and other things to work.  */
+#undef _POSIX_SOURCE
+
+/* Define if you have the ANSI C header files.  */
+#undef STDC_HEADERS
+
+#undef PLUGINS_DIR
+#undef PLUGINS_SRCDIR
+#undef PLUGINS_USE_SRCDIR
+
+#undef HAVE_LIBGHTTP
+#undef HAVE_LIBXML
+#undef HAVE_LIBMMX
+
+#undef HAVE_ATOMIC_H
+
+#undef DEBUG_ENABLED
+
+/* Define if you have the <asm/atomic.h> header file.  */
+#undef HAVE_ASM_ATOMIC_H
+
+/* Name of package */
+#undef PACKAGE
+
+/* Version number of package */
+#undef VERSION
+

configure.in

@@ -0,0 +1,145 @@
+AC_INIT(gst/gstobject.h)
+
+AM_CONFIG_HEADER(config.h)
+
+STREAMER_MAJOR_VERSION=0
+STREAMER_MINOR_VERSION=0
+STREAMER_MICRO_VERSION=9.2
+STREAMER_VERSION=$STREAMER_MAJOR_VERSION.$STREAMER_MINOR_VERSION.$STREAMER_MICRO_VERSION
+
+dnl libtool
+STREAMER_CURRENT=0
+STREAMER_REVISION=0
+STREAMER_AGE=0
+
+AM_INIT_AUTOMAKE(gstreamer, $STREAMER_VERSION)
+
+AC_SUBST(STREAMER_MAJOR_VERSION)
+AC_SUBST(STREAMER_MINOR_VERSION)
+AC_SUBST(STREAMER_MICRO_VERSION)
+AC_SUBST(STREAMER_VERSION)
+
+AC_SUBST(STREAMER_CURRENT)
+AC_SUBST(STREAMER_REVISION)
+AC_SUBST(STREAMER_AGE)
+
+
+AM_MAINTAINER_MODE
+
+AC_ISC_POSIX
+AC_PROG_CC
+AC_STDC_HEADERS
+AC_ARG_PROGRAM
+
+AM_DISABLE_STATIC
+AC_LIBTOOL_DLOPEN
+AM_PROG_LIBTOOL
+
+AM_PATH_GLIB(1.2.0,
+            [LIBS="$LIBS $GLIB_LIBS" CFLAGS="$CFLAGS $GLIB_CFLAGS"],
+            AC_MSG_ERROR(Cannot find glib: Is glib-config in path?),
+            glib gmodule gthread)
+AM_PATH_GTK(1.2.0)
+
+dnl Check for libghttp
+AC_CHECK_LIB(ghttp,ghttp_request_new,
+             [LIBS="$LIBS -lghttp" HAVE_LIBGHTTP="yes"],
+             AC_MSG_WARN(Cannot find libghttp: can't build gsthttpsrc),
+             $LIBS)
+AC_DEFINE(HAVE_LIBGHTTP)
+AM_CONDITIONAL(HAVE_LIBGHTTP, test "x$HAVE_LIBGHTTP" = "xyes")
+
+
+AC_CHECK_HEADERS(asm/atomic.h, AC_DEFINE(HAVE_ATOMIC_H))
+
+
+AC_PATH_PROG(XML_CONFIG,xml-config,no)
+if test x$XML_CONFIG = xno;then
+  AC_MSG_ERROR(Couldn't find xml-config)
+fi
+XML_LIBS=`xml-config --libs`
+XML_CFLAGS=`xml-config --cflags`
+AC_SUBST(XML_LIBS)
+AC_SUBST(XML_CFLAGS)
+AC_DEFINE(HAVE_LIBXML)
+AM_CONDITIONAL(HAVE_LIBXML, test "x$HAVE_LIBXML" = "xyes")
+
+
+AC_CHECK_HEADER(mmx.h,[HAVE_LIBMMX=yes],)
+AC_DEFINE(HAVE_LIBMMX)
+AM_CONDITIONAL(HAVE_LIBMMX, test "x$HAVE_LIBMMX" = "xyes")
+
+
+PLUGINS_DIR=${libdir}/plugins
+AC_DEFINE_UNQUOTED(PLUGINS_DIR,"$PLUGINS_DIR")
+AC_SUBST(PLUGINS_DIR)
+
+PLUGINS_SRCDIR=`pwd`/$srcdir
+AC_DEFINE_UNQUOTED(PLUGINS_SRCDIR,"$PLUGINS_SRCDIR")
+AC_SUBST(PLUGINS_SRCDIR)
+
+AC_ARG_ENABLE(plugin-srcdir,
+[  --enable-plugin-srcdir	allow tests/demos to use non-installed plugins ],
+[AC_DEFINE(PLUGINS_USE_SRCDIR)])
+
+AC_DEFINE(PLUGINS_USE_SRCDIR)
+
+AC_ARG_ENABLE(debug,
+[  --enable-debug		spews lots of useless info at runtime],
+[AC_DEFINE(DEBUG_ENABLED)])
+
+AC_ARG_ENABLE(profiling,
+[  --enable-profiling		adds -pg to compiler commandline, for profiling],
+[CFLAGS="$CFLAGS -pg"])
+
+
+AC_SUBST(CFLAGS)
+AC_SUBST(CPPFLAGS)
+AC_SUBST(LDFLAGS)
+
+AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
+AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
+
+
+AC_CONFIG_SUBDIRS(gist)
+AC_CONFIG_SUBDIRS(plugins/mp3decode/xing/libxing)
+
+AC_OUTPUT([Makefile
+gst/Makefile
+gst/types/Makefile
+gst/meta/Makefile
+gst/elements/Makefile
+gst/xml/Makefile
+plugins/Makefile
+plugins/au/Makefile
+plugins/wav/Makefile
+plugins/mp3decode/Makefile
+plugins/mp3decode/xa/Makefile
+plugins/mp3decode/xing/Makefile
+plugins/mp3decode/mpg123/Makefile
+plugins/mp3decode/parse/Makefile
+plugins/mpeg2/Makefile
+plugins/mpeg2/parse/Makefile
+plugins/mpeg2/ac3parse/Makefile
+plugins/mpeg2/ac3dec/Makefile
+plugins/mpeg1/Makefile
+plugins/mpeg1/parse/Makefile
+plugins/effects/Makefile
+plugins/effects/stereo/Makefile
+plugins/effects/volume/Makefile
+plugins/visualization/Makefile
+plugins/visualization/spectrum/Makefile
+plugins/visualization/vumeter/Makefile
+plugins/visualization/synaesthesia/Makefile
+plugins/visualization/smoothwave/Makefile
+plugins/dvdsrc/Makefile
+plugins/vcdsrc/Makefile
+plugins/cobin/Makefile
+test/Makefile
+test/xml/Makefile
+test/bindings/Makefile
+test/cothreads/Makefile
+editor/Makefile
+tools/Makefile
+docs/Makefile
+stamp.h])

gst/Makefile.am

@@ -0,0 +1,61 @@
+# cheap trick to build . first...
+SUBDIRS = . types meta elements xml
+
+lib_LTLIBRARIES = libgst.la
+
+GSTOBJECT_SRCS =	\
+	gstobject.c
+GSTOBJECT_INCLUDES =	\
+	gstobject.h
+
+libgst_la_SOURCES =	\
+	gst.c		\
+	$(GSTOBJECT_SRCS)	\
+	gstpad.c	\
+	gstbuffer.c	\
+	gstelement.c	\
+	gstelementfactory.c	\
+	gstbin.c	\
+	gstpipeline.c	\
+	gstthread.c	\
+	gstsrc.c	\
+	gstfilter.c	\
+	gstsink.c	\
+	gstconnection.c	\
+	gsttype.c	\
+	gstplugin.c	\
+	gstutils.c	\
+	gsttrace.c	\
+	gstmeta.c	\
+	gsttee.c	\
+	gstxml.c	\
+	cothreads.c
+
+libgstincludedir = $(includedir)/gst
+libgstinclude_HEADERS =	\
+	gst.h		\
+	gstlog.h	\
+	$(GSTOBJECT_INCLUDES)	\
+	gstpad.h	\
+	gstbuffer.h	\
+	gstelement.h	\
+	gstbin.h	\
+	gstpipeline.h	\
+	gstthread.h	\
+	gstsrc.h	\
+	gstfilter.h	\
+	gstsink.h	\
+	gstconnection.h	\
+	gsttype.h	\
+	gstplugin.h	\
+	gstutils.h	\
+	gsttrace.h	\
+	gstmeta.h	\
+	gsttee.h	\
+	gstxml.h	\
+	cothreads.h
+
+libgst_la_LIBADD = $(GLIB_LIBS) $(GTK_LIBS) $(XML_LIBS)
+libgst_la_LDFLAGS = -version-info $(STREAMER_CURRENT):$(STREAMER_REVISION):$(STREAMER_AGE)
+
+EXTRA_DIST = ROADMAP

gst/cothreads.c

@@ -0,0 +1,143 @@
+#include <sys/time.h>
+#include <linux/linkage.h>
+#include <stdio.h>   
+#include <stdlib.h>
+#include <signal.h>   
+#include <setjmp.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "cothreads.h"
+
+pthread_key_t _cothread_key = -1;
+
+cothread_state *cothread_create(cothread_context *ctx) {
+  cothread_state *s;
+
+  if (pthread_self() == 0) {
+    s = (cothread_state *)malloc(sizeof(int) * COTHREAD_STACKSIZE);
+  } else {
+    char *sp = CURRENT_STACK_FRAME;
+    unsigned long *stack_end = (unsigned long *)((unsigned long)sp &
+      ~(STACK_SIZE - 1));
+    s = (cothread_state *)(stack_end + ((ctx->nthreads - 1) *
+                           COTHREAD_STACKSIZE));
+    if (mmap((char *)s,COTHREAD_STACKSIZE*(sizeof(int)),
+             PROT_READ|PROT_WRITE|PROT_EXEC,MAP_PRIVATE|MAP_ANONYMOUS,
+             -1,0) < 0) {
+      perror("mmap'ing cothread stack space");
+      return NULL;
+    }
+  }
+
+  s->ctx = ctx;
+  s->threadnum = ctx->nthreads;
+  s->flags = 0;
+  s->sp = (int *)(s + COTHREAD_STACKSIZE);
+
+  ctx->threads[ctx->nthreads++] = s;
+
+//  printf("created cothread at %p\n",s);
+
+  return s;
+}
+
+void cothread_setfunc(cothread_state *thread,cothread_func func,int argc,char **argv) {
+  thread->func = func;
+  thread->argc = argc;
+  thread->argv = argv;
+  thread->pc = (int *)func;
+}
+
+cothread_context *cothread_init() {
+  cothread_context *ctx = (cothread_context *)malloc(sizeof(cothread_context));
+
+  if (_cothread_key == -1) {
+    if (pthread_key_create(&_cothread_key,NULL) != 0) {
+      perror("pthread_key_create");
+      return;
+    }
+  }
+  pthread_setspecific(_cothread_key,ctx);
+
+  memset(ctx->threads,0,sizeof(ctx->threads));
+
+  ctx->threads[0] = (cothread_state *)malloc(sizeof(cothread_state));
+  ctx->threads[0]->ctx = ctx;
+  ctx->threads[0]->threadnum = 0;
+  ctx->threads[0]->func = NULL;
+  ctx->threads[0]->argc = 0;
+  ctx->threads[0]->argv = NULL;
+  ctx->threads[0]->flags = COTHREAD_STARTED;
+  ctx->threads[0]->sp = CURRENT_STACK_FRAME;
+  ctx->threads[0]->pc = 0;
+
+//  fprintf(stderr,"0th thread is at %p\n",ctx->threads[0]);
+
+  // we consider the initiating process to be cothread 0
+  ctx->nthreads = 1;
+  ctx->current = 0;
+
+  return ctx;
+}
+
+cothread_state *cothread_main(cothread_context *ctx) {
+//  fprintf(stderr,"returning %p, the 0th cothread\n",ctx->threads[0]);
+  return ctx->threads[0];
+}
+
+void cothread_stub() {
+  cothread_context *ctx = pthread_getspecific(_cothread_key);
+  register cothread_state *thread = ctx->threads[ctx->current];
+
+  thread->flags |= COTHREAD_STARTED;
+  thread->func(thread->argc,thread->argv);
+  thread->flags &= ~COTHREAD_STARTED;
+  thread->pc = 0;
+//  printf("uh, yeah, we shouldn't be here, but we should deal anyway\n");
+}
+
+void cothread_switch(cothread_state *thread) {
+  cothread_context *ctx;
+  cothread_state *current;
+  int enter = 0;
+//  int i;
+
+  if (thread == NULL)
+    return;
+
+  ctx = thread->ctx;
+
+  current = ctx->threads[ctx->current];
+  if (current == NULL) {
+    fprintf(stderr,"there's no current thread, help!\n");
+    exit(2);
+  }
+
+  if (current == thread) {
+    fprintf(stderr,"trying to switch to same thread, legal but not necessary\n");
+    return;
+  }
+
+  // find the number of the thread to switch to
+  ctx->current = thread->threadnum;
+//  fprintf(stderr,"about to switch to thread #%d\n",ctx->current);
+
+  /* save the current stack pointer, frame pointer, and pc */
+  __asm__("movl %%esp, %0" : "=m"(current->sp) : : "esp", "ebp");
+  enter = setjmp(current->jmp);
+  if (enter != 0)
+    return;
+  enter = 1;
+
+  /* restore stack pointer and other stuff of new cothread */
+  __asm__("movl %0, %%esp\n" : "=m"(thread->sp));
+  if (thread->flags & COTHREAD_STARTED) {
+    // switch to it
+    longjmp(thread->jmp,1);
+  } else {
+    // start it
+    __asm__("jmp " SYMBOL_NAME_STR(cothread_stub));
+  }
+}

gst/cothreads.h

@@ -0,0 +1,48 @@
+#ifndef __COTHREADS_H__
+#define __COTHREADS_H__
+
+#include <setjmp.h>
+#include <pthread.h>
+
+#define COTHREAD_STACKSIZE 8192
+#define COTHREAD_MAXTHREADS 16
+#define STACK_SIZE 0x200000
+
+#ifndef CURRENT_STACK_FRAME
+#define CURRENT_STACK_FRAME  ({ char __csf; &__csf; })
+#endif /* CURRENT_STACK_FRAME */
+
+typedef struct _cothread_state cothread_state;
+typedef struct _cothread_context cothread_context;
+
+typedef int (*cothread_func)(int argc,char **argv);
+
+#define COTHREAD_STARTED	0x01
+
+struct _cothread_state {
+  cothread_context *ctx;
+  int threadnum;
+
+  cothread_func func;
+  int argc;
+  char **argv;
+
+  int flags;
+  int *sp;
+  int *pc;
+  jmp_buf jmp;
+};
+
+struct _cothread_context {
+  cothread_state *threads[COTHREAD_MAXTHREADS];
+  int nthreads;
+  int current;
+};
+
+cothread_context *cothread_init();
+cothread_state *cothread_create(cothread_context *ctx);
+void cothread_setfunc(cothread_state *thread,cothread_func func,int argc,char **argv);
+void cothread_switch(cothread_state *thread);
+cothread_state *cothread_main(cothread_context *ctx);
+
+#endif /* __COTHREAD_H__ */

gst/elements/Makefile.am

@@ -0,0 +1,35 @@
+lib_LTLIBRARIES = libgstelements.la
+
+libgstelements_la_DEPENDENCIES = ../libgst.la
+libgstelements_la_SOURCES =	\
+	gstelements.c		\
+	gstfakesrc.c		\
+	gstidentity.c		\
+	gstfakesink.c		\
+	gstdisksrc.c		\
+	gstasyncdisksrc.c	\
+	gstfdsrc.c		\
+	gsthttpsrc.c		\
+	gstaudiosink.c		\
+	gstaudiosrc.c		\
+	gstfdsink.c		\
+	gstqueue.c		\
+	gstsinesrc.c
+
+noinst_HEADERS =		\
+	gstfakesrc.h		\
+	gstidentity.h		\
+	gstfakesink.h		\
+	gstdisksrc.h		\
+	gstasyncdisksrc.h	\
+	gstfdsrc.h		\
+	gsthttpsrc.h		\
+	gstaudiosink.h		\
+	gstaudiosrc.h		\
+	gstfdsink.h		\
+	gstqueue.h		\
+	gstsinesrc.h
+
+libgstelements_la_LIBADD = $(GLIB_LIBS) $(GTK_LIBS) \
+			   $(top_srcdir)/gst/libgst.la
+libgstelements_la_LDFLAGS = -version-info $(STREAMER_CURRENT):$(STREAMER_REVISION):$(STREAMER_AGE)

gst/elements/gstasyncdisksrc.c

@@ -0,0 +1,346 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <gstasyncdisksrc.h>
+
+
+GstElementDetails gst_asyncdisksrc_details = {
+  "Asynchronous Disk Source",
+  "Source/File",
+  "Read from arbitrary point in a file",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* AsyncDiskSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_LENGTH,
+  ARG_OFFSET,
+};
+
+
+static void gst_asyncdisksrc_class_init(GstAsyncDiskSrcClass *klass);
+static void gst_asyncdisksrc_init(GstAsyncDiskSrc *asyncdisksrc);
+static void gst_asyncdisksrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_asyncdisksrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+static void gst_asyncdisksrc_push(GstSrc *src);
+static void gst_asyncdisksrc_push_region(GstSrc *src,gulong offset,
+                                         gulong size);
+static gboolean gst_asyncdisksrc_change_state(GstElement *element,
+                                              GstElementState state);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_asyncdisksrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_asyncdisksrc_get_type(void) {
+  static GtkType asyncdisksrc_type = 0;
+
+  if (!asyncdisksrc_type) {
+    static const GtkTypeInfo asyncdisksrc_info = {
+      "GstAsyncDiskSrc",
+      sizeof(GstAsyncDiskSrc),
+      sizeof(GstAsyncDiskSrcClass),
+      (GtkClassInitFunc)gst_asyncdisksrc_class_init,
+      (GtkObjectInitFunc)gst_asyncdisksrc_init,
+      (GtkArgSetFunc)gst_asyncdisksrc_set_arg,
+      (GtkArgGetFunc)gst_asyncdisksrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    asyncdisksrc_type = gtk_type_unique(GST_TYPE_SRC,&asyncdisksrc_info);
+  }
+  return asyncdisksrc_type;
+}
+
+static void
+gst_asyncdisksrc_class_init(GstAsyncDiskSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstAsyncDiskSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_READWRITE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::bytesperread", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::length", GTK_TYPE_LONG,
+                          GTK_ARG_READABLE, ARG_LENGTH);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::offset", GTK_TYPE_LONG,
+                          GTK_ARG_READWRITE, ARG_OFFSET);
+
+  gtkobject_class->set_arg = gst_asyncdisksrc_set_arg;
+  gtkobject_class->get_arg = gst_asyncdisksrc_get_arg;
+
+  gstelement_class->change_state = gst_asyncdisksrc_change_state;
+
+  gstsrc_class->push = gst_asyncdisksrc_push;
+  gstsrc_class->push_region = gst_asyncdisksrc_push_region;
+}
+
+static void gst_asyncdisksrc_init(GstAsyncDiskSrc *asyncdisksrc) {
+  GST_SRC_SET_FLAGS(asyncdisksrc,GST_SRC_ASYNC);
+
+  asyncdisksrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(asyncdisksrc),asyncdisksrc->srcpad);
+
+  asyncdisksrc->filename = NULL;
+  asyncdisksrc->fd = 0;
+  asyncdisksrc->size = 0;
+  asyncdisksrc->map = NULL;
+  asyncdisksrc->curoffset = 0;
+  asyncdisksrc->bytes_per_read = 4096;
+  asyncdisksrc->seq = 0;
+}
+
+
+static void gst_asyncdisksrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAsyncDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(object));
+  src = GST_ASYNCDISKSRC(object);
+
+  switch(id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->filename) g_free(src->filename);
+      /* clear the filename if we get a NULL (is that possible?) */
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->filename = NULL;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      /* otherwise set the new filename */
+      } else {
+        src->filename = g_strdup(GTK_VALUE_STRING(*arg));
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_OFFSET:
+      src->curoffset = GTK_VALUE_LONG(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_asyncdisksrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAsyncDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(object));
+  src = GST_ASYNCDISKSRC(object);
+
+  switch (id) {
+    case ARG_LOCATION:
+      GTK_VALUE_STRING(*arg) = src->filename;
+      break;
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = src->bytes_per_read;
+      break;
+    case ARG_LENGTH:
+      GTK_VALUE_LONG(*arg) = src->size;
+      break;
+    case ARG_OFFSET:
+      GTK_VALUE_LONG(*arg) = src->curoffset;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+/**
+ * gst_asyncdisksrc_push:
+ * @src: #GstSrc to push a buffer from
+ *
+ * Push a new buffer from the asyncdisksrc at the current offset.
+ */
+void gst_asyncdisksrc_push(GstSrc *src) {
+  GstAsyncDiskSrc *asyncdisksrc;
+  GstBuffer *buf;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(src));
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+  asyncdisksrc = GST_ASYNCDISKSRC(src);
+
+  /* deal with EOF state */
+  if (asyncdisksrc->curoffset >= asyncdisksrc->size) {
+    gst_src_signal_eos(GST_SRC(asyncdisksrc));
+    return;
+  }
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = GST_BUFFER(gst_buffer_new());
+  g_return_if_fail(buf != NULL);
+
+  /* simply set the buffer to point to the correct region of the file */
+  GST_BUFFER_DATA(buf) = asyncdisksrc->map + asyncdisksrc->curoffset;
+  GST_BUFFER_OFFSET(buf) = asyncdisksrc->curoffset;
+
+  if ((asyncdisksrc->curoffset + asyncdisksrc->bytes_per_read) >
+      asyncdisksrc->size) {
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->size - asyncdisksrc->curoffset;
+    // FIXME: set the buffer's EOF bit here
+  } else
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->bytes_per_read;
+  asyncdisksrc->curoffset += GST_BUFFER_SIZE(buf);
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(asyncdisksrc->srcpad,buf);
+}
+
+/**
+ * gst_asyncdisksrc_push_region:
+ * @src: #GstSrc to push a buffer from
+ * @offset: offset in file
+ * @size: number of bytes
+ *
+ * Push a new buffer from the asyncdisksrc of given size at given offset.
+ */
+void gst_asyncdisksrc_push_region(GstSrc *src,gulong offset,gulong size) {
+  GstAsyncDiskSrc *asyncdisksrc;
+  GstBuffer *buf;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(src));
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+  asyncdisksrc = GST_ASYNCDISKSRC(src);
+
+  /* deal with EOF state */
+  if (offset >= asyncdisksrc->size) {
+    gst_src_signal_eos(GST_SRC(asyncdisksrc));
+    return;
+  }
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+
+  /* simply set the buffer to point to the correct region of the file */
+  GST_BUFFER_DATA(buf) = asyncdisksrc->map + offset;
+  GST_BUFFER_OFFSET(buf) = asyncdisksrc->curoffset;
+
+  if ((offset + size) > asyncdisksrc->size) {
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->size - offset;
+    // FIXME: set the buffer's EOF bit here
+  } else
+    GST_BUFFER_SIZE(buf) = size;
+  asyncdisksrc->curoffset += GST_BUFFER_SIZE(buf);
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(asyncdisksrc->srcpad,buf);
+}
+
+
+/* open the file and mmap it, necessary to go to RUNNING state */
+static gboolean gst_asyncdisksrc_open_file(GstAsyncDiskSrc *src) {
+  g_return_if_fail(!GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+
+  /* open the file */
+  src->fd = open(src->filename,O_RDONLY);
+  if (src->fd < 0) {
+    gst_element_error(GST_ELEMENT(src),"opening file");
+    return FALSE;
+  } else {
+    /* find the file length */
+    src->size = lseek(src->fd,0,SEEK_END);
+    lseek(src->fd,0,SEEK_SET);
+    /* map the file into memory */
+    src->map = mmap(NULL,src->size,PROT_READ,MAP_SHARED,src->fd,0);
+    /* collapse state if that failed */
+    if (src->map == NULL) {
+      close(src->fd);
+      gst_element_error(GST_ELEMENT(src),"mmapping file");
+      return FALSE;
+    }
+    GST_FLAG_SET(src,GST_ASYNCDISKSRC_OPEN);
+  }
+  return TRUE;
+}
+
+/* unmap and close the file */
+static void gst_asyncdisksrc_close_file(GstAsyncDiskSrc *src) {
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+
+  /* unmap the file from memory */
+  munmap(src->map,src->size);
+  /* close the file */
+  close(src->fd);
+
+  /* zero out a lot of our state */
+  src->fd = 0;
+  src->size = 0;
+  src->map = NULL;
+  src->curoffset = 0;
+  src->seq = 0;
+
+  GST_FLAG_UNSET(src,GST_ASYNCDISKSRC_OPEN);
+}
+
+
+static gboolean gst_asyncdisksrc_change_state(GstElement *element,
+                                              GstElementState state) {
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_asyncdisksrc_open_file(GST_ASYNCDISKSRC(element)))
+        return FALSE;
+      break;
+    case ~GST_STATE_RUNNING:
+      gst_asyncdisksrc_close_file(GST_ASYNCDISKSRC(element));
+      break;
+    default:
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}

gst/elements/gstasyncdisksrc.h

@@ -0,0 +1,88 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_ASYNCDISKSRC_H__
+#define __GST_ASYNCDISKSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_asyncdisksrc_details;
+
+
+#define GST_TYPE_ASYNCDISKSRC \
+  (gst_asyncdisksrc_get_type())
+#define GST_ASYNCDISKSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
+#define GST_ASYNCDISKSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
+#define GST_IS_ASYNCDISKSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
+#define GST_IS_ASYNCDISKSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC)))
+
+// NOTE: per-element flags start with 16 for now
+typedef enum {
+  GST_ASYNCDISKSRC_OPEN	= (1 << 16),
+} GstAsyncDiskSrcFlags;
+
+typedef struct _GstAsyncDiskSrc GstAsyncDiskSrc;
+typedef struct _GstAsyncDiskSrcClass GstAsyncDiskSrcClass;
+
+struct _GstAsyncDiskSrc {
+  GstSrc src;
+  /* pads */
+  GstPad *srcpad;
+
+  /* filename */
+  gchar *filename;
+  /* fd */
+  gint fd;
+
+  /* mapping parameters */
+  gulong size;				/* how long is the file? */
+  guchar *map;				/* where the file is mapped to */
+
+  /* details for fallback synchronous read */
+  gulong curoffset;			/* current offset in file */
+  gulong bytes_per_read;		/* bytes per read */
+
+  gulong seq;				/* buffer sequence number */
+};
+
+struct _GstAsyncDiskSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_asyncdisksrc_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_ASYNCDISKSRC_H__ */

gst/elements/gstaudiosink.c

@@ -0,0 +1,291 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+
+#include <gstaudiosink.h>
+#include <gst/meta/audioraw.h>
+
+
+GstElementDetails gst_audiosink_details = {  
+  "Audio Sink (OSS)",
+  "Sink/Audio",
+  "Output to a sound card via OSS",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+static gboolean gst_audiosink_open_audio(GstAudioSink *sink);
+static void gst_audiosink_close_audio(GstAudioSink *sink);
+static gboolean gst_audiosink_start(GstElement *element,
+                                    GstElementState state);
+static gboolean gst_audiosink_stop(GstElement *element);
+static gboolean gst_audiosink_change_state(GstElement *element,
+                                           GstElementState state);
+
+
+/* AudioSink signals and args */
+enum {
+  HANDOFF,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_audiosink_class_init(GstAudioSinkClass *klass);
+static void gst_audiosink_init(GstAudioSink *audiosink);
+
+
+static GstFilterClass *parent_class = NULL;
+static guint gst_audiosink_signals[LAST_SIGNAL] = { 0 };
+
+static guint16 gst_audiosink_type_audio = 0;
+
+GtkType
+gst_audiosink_get_type(void) {
+  static GtkType audiosink_type = 0;
+
+  if (!audiosink_type) {
+    static const GtkTypeInfo audiosink_info = {
+      "GstAudioSink",
+      sizeof(GstAudioSink),
+      sizeof(GstAudioSinkClass),
+      (GtkClassInitFunc)gst_audiosink_class_init,
+      (GtkObjectInitFunc)gst_audiosink_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    audiosink_type = gtk_type_unique(GST_TYPE_FILTER,&audiosink_info);
+  }
+
+  if (!gst_audiosink_type_audio)
+    gst_audiosink_type_audio = gst_type_find_by_mime("audio/raw");
+
+  return audiosink_type;
+}
+
+static void
+gst_audiosink_class_init(GstAudioSinkClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_FILTER);
+
+  gst_audiosink_signals[HANDOFF] =
+    gtk_signal_new("handoff",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstAudioSinkClass,handoff),
+                   gtk_marshal_NONE__POINTER_POINTER,GTK_TYPE_NONE,2,
+                   GTK_TYPE_POINTER,GTK_TYPE_POINTER);
+  gtk_object_class_add_signals(gtkobject_class,gst_audiosink_signals,
+                               LAST_SIGNAL);
+
+  gstelement_class->start = gst_audiosink_start;
+  gstelement_class->stop = gst_audiosink_stop;
+  gstelement_class->change_state = gst_audiosink_change_state;
+}
+
+static void gst_audiosink_init(GstAudioSink *audiosink) {
+  audiosink->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(audiosink),audiosink->sinkpad);
+  if (!gst_audiosink_type_audio)
+    gst_audiosink_type_audio = gst_type_find_by_mime("audio/raw");
+  gst_pad_set_type_id(audiosink->sinkpad,gst_audiosink_type_audio);
+  gst_pad_set_chain_function(audiosink->sinkpad,gst_audiosink_chain);
+
+  audiosink->fd = -1;
+
+  gst_element_set_state(GST_ELEMENT(audiosink),GST_STATE_COMPLETE);
+}
+
+void gst_audiosink_sync_parms(GstAudioSink *audiosink) {
+  audio_buf_info ospace;
+
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+  g_return_if_fail(audiosink->fd > 0);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_RESET,0);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_SETFMT,&audiosink->format);
+  ioctl(audiosink->fd,SNDCTL_DSP_CHANNELS,&audiosink->channels);
+  ioctl(audiosink->fd,SNDCTL_DSP_SPEED,&audiosink->frequency);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_GETOSPACE,&ospace);
+
+  g_print("setting sound card to %dKHz %d bit %s (%d bytes buffer)\n",
+          audiosink->frequency,audiosink->format,
+          (audiosink->channels == 2) ? "stereo" : "mono",ospace.bytes);
+}
+
+GstElement *gst_audiosink_new(gchar *name) {
+  GstElement *audiosink = GST_ELEMENT(gtk_type_new(GST_TYPE_AUDIOSINK));
+  gst_element_set_name(GST_ELEMENT(audiosink),name);
+  return audiosink;
+}
+
+void gst_audiosink_chain(GstPad *pad,GstBuffer *buf) {
+  GstAudioSink *audiosink;
+  MetaAudioRaw *meta;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  /* this has to be an audio buffer */
+//  g_return_if_fail(((GstMeta *)buf->meta)->type !=
+//gst_audiosink_type_audio);
+  audiosink = GST_AUDIOSINK(pad->parent);
+//  g_return_if_fail(GST_FLAG_IS_SET(audiosink,GST_STATE_RUNNING));
+
+  meta = (MetaAudioRaw *)gst_buffer_get_first_meta(buf);
+  if (meta != NULL) {
+    if ((meta->format != audiosink->format) ||
+        (meta->channels != audiosink->channels) ||
+        (meta->frequency != audiosink->frequency)) {
+      audiosink->format = meta->format;
+      audiosink->channels = meta->channels;
+      audiosink->frequency = meta->frequency;
+      gst_audiosink_sync_parms(audiosink);
+      g_print("sound device set to format %d, %d channels, %dHz\n",
+              audiosink->format,audiosink->channels,audiosink->frequency);
+    }
+  }
+
+  gtk_signal_emit(GTK_OBJECT(audiosink),gst_audiosink_signals[HANDOFF],
+                  audiosink);
+  if (GST_BUFFER_DATA(buf) != NULL) {
+    gst_trace_add_entry(NULL,0,buf,"audiosink: writing to soundcard");
+    if (audiosink->fd > 2)
+      write(audiosink->fd,GST_BUFFER_DATA(buf),GST_BUFFER_SIZE(buf));
+  }
+
+  gst_buffer_unref(buf);
+//  g_print("a");
+}
+
+void gst_audiosink_set_format(GstAudioSink *audiosink,gint format) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->format = format;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+void gst_audiosink_set_channels(GstAudioSink *audiosink,gint channels) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->channels = channels;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+void gst_audiosink_set_frequency(GstAudioSink *audiosink,gint frequency) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->frequency = frequency;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+static gboolean gst_audiosink_open_audio(GstAudioSink *sink) {
+  g_return_if_fail(sink->fd == -1);
+
+  g_print("attempting to open sound device\n");
+
+  /* first try to open the sound card */
+  sink->fd = open("/dev/dsp",O_RDWR);
+
+  /* if we have it, set the default parameters and go have fun */
+  if (sink->fd > 0) {
+    /* set card state */
+    sink->format = AFMT_S16_LE;
+    sink->channels = 2; /* stereo */
+    sink->frequency = 44100;
+    gst_audiosink_sync_parms(sink);
+    g_print("opened audio\n");
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+static void gst_audiosink_close_audio(GstAudioSink *sink) {
+  if (sink->fd < 0) return;
+
+  close(sink->fd);
+  sink->fd = -1;
+  g_print("closed sound device\n");
+}
+
+static gboolean gst_audiosink_start(GstElement *element,
+                                    GstElementState state) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+
+  if (gst_audiosink_open_audio(GST_AUDIOSINK(element)) == TRUE) {
+    gst_element_set_state(element,GST_STATE_RUNNING | state);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static gboolean gst_audiosink_stop(GstElement *element) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+
+  gst_audiosink_close_audio(GST_AUDIOSINK(element));
+  gst_element_set_state(element,~GST_STATE_RUNNING);
+  return TRUE;
+}
+
+static gboolean gst_audiosink_change_state(GstElement *element,
+                                           GstElementState state) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+      
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_audiosink_open_audio(GST_AUDIOSINK(element)))
+        return FALSE;
+      break;  
+    case ~GST_STATE_RUNNING:
+      gst_audiosink_close_audio(GST_AUDIOSINK(element));
+      break;
+    default:
+      break;
+  }     
+      
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}

gst/elements/gstaudiosink.h

@@ -0,0 +1,85 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_AUDIOSINK_H__
+#define __GST_AUDIOSINK_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_audiosink_details;
+
+
+#define GST_TYPE_AUDIOSINK \
+  (gst_audiosink_get_type())
+#define GST_AUDIOSINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSINK,GstAudioSink))
+#define GST_AUDIOSINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSINK,GstAudioSinkClass))
+#define GST_IS_AUDIOSINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSINK))
+#define GST_IS_AUDIOSINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSINK)))
+
+typedef struct _GstAudioSink GstAudioSink;
+typedef struct _GstAudioSinkClass GstAudioSinkClass;
+
+struct _GstAudioSink {
+  GstFilter filter;
+
+  GstPad *sinkpad;
+
+  /* soundcard state */
+  int fd;
+  gint format;
+  gint channels;
+  gint frequency;
+};
+
+struct _GstAudioSinkClass {
+  GstFilterClass parent_class;
+
+  /* signals */
+  void (*handoff) (GstElement *element,GstPad *pad);
+};
+
+GtkType gst_audiosink_get_type(void);
+GstElement *gst_audiosink_new(gchar *name);
+void gst_audiosink_chain(GstPad *pad,GstBuffer *buf);
+
+void gst_audiosink_sync_parms(GstAudioSink *audiosink);
+
+void gst_audiosink_set_format(GstAudioSink *audiosink,gint format);
+void gst_audiosink_set_channels(GstAudioSink *audiosink,gint channels);
+void gst_audiosink_set_frequency(GstAudioSink *audiosink,gint frequency);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_AUDIOSINK_H__ */

gst/elements/gstaudiosrc.c

@@ -0,0 +1,319 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+
+#include <gstaudiosrc.h>
+
+
+GstElementDetails gst_audiosrc_details = {
+  "Audio (OSS) Source",
+  "Source/Audio",
+  "Read from the sound card",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* AudioSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_CUROFFSET,
+  ARG_FORMAT,
+  ARG_CHANNELS,
+  ARG_FREQUENCY,
+};
+
+
+static void gst_audiosrc_class_init(GstAudioSrcClass *klass);
+static void gst_audiosrc_init(GstAudioSrc *audiosrc);
+static void gst_audiosrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_audiosrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+static gboolean gst_audiosrc_change_state(GstElement *element,
+                                          GstElementState state);
+static void gst_audiosrc_close_audio(GstAudioSrc *src);
+static gboolean gst_audiosrc_open_audio(GstAudioSrc *src);
+void gst_audiosrc_sync_parms(GstAudioSrc *audiosrc);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_audiosrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_audiosrc_get_type(void) {
+  static GtkType audiosrc_type = 0;
+
+  if (!audiosrc_type) {
+    static const GtkTypeInfo audiosrc_info = {
+      "GstAudioSrc",
+      sizeof(GstAudioSrc),
+      sizeof(GstAudioSrcClass),
+      (GtkClassInitFunc)gst_audiosrc_class_init,
+      (GtkObjectInitFunc)gst_audiosrc_init,
+      (GtkArgSetFunc)gst_audiosrc_set_arg,
+      (GtkArgGetFunc)gst_audiosrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    audiosrc_type = gtk_type_unique(GST_TYPE_SRC,&audiosrc_info);
+  }
+  return audiosrc_type;
+}
+
+static void
+gst_audiosrc_class_init(GstAudioSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstAudioSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_READWRITE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstAudioSrc::bytes_per_read", GTK_TYPE_ULONG,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+  gtk_object_add_arg_type("GstAudioSrc::curoffset", GTK_TYPE_ULONG,
+                          GTK_ARG_READABLE, ARG_CUROFFSET);
+  gtk_object_add_arg_type("GstAudioSrc::format", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FORMAT);
+  gtk_object_add_arg_type("GstAudioSrc::channels", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_CHANNELS);
+  gtk_object_add_arg_type("GstAudioSrc::frequency", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FREQUENCY);
+
+  gtkobject_class->set_arg = gst_audiosrc_set_arg;
+  gtkobject_class->get_arg = gst_audiosrc_get_arg;
+
+  gstelement_class->change_state = gst_audiosrc_change_state;
+
+  gstsrc_class->push = gst_audiosrc_push;
+}
+
+static void gst_audiosrc_init(GstAudioSrc *audiosrc) {
+  audiosrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(audiosrc),audiosrc->srcpad);
+
+  audiosrc->filename = g_strdup("/dev/dsp");
+  audiosrc->fd = -1;
+
+//  audiosrc->meta = (MetaAudioRaw *)gst_meta_new();
+//  audiosrc->meta->format = AFMT_S16_LE;
+//  audiosrc->meta->channels = 2;
+//  audiosrc->meta->frequency = 44100;
+//  audiosrc->meta->bps = 4;
+
+  audiosrc->bytes_per_read = 4096;
+  audiosrc->curoffset = 0;
+  audiosrc->seq = 0;
+}
+
+GstElement *gst_audiosrc_new(gchar *name) {
+  GstElement *audiosrc = GST_ELEMENT(gtk_type_new(GST_TYPE_AUDIOSRC));
+  gst_element_set_name(GST_ELEMENT(audiosrc),name);
+  return audiosrc;
+}
+
+GstElement *gst_audiosrc_new_with_fd(gchar *name,gchar *filename) {
+  GstElement *audiosrc = gst_audiosrc_new(name);
+  gtk_object_set(GTK_OBJECT(audiosrc),"location",filename,NULL);
+  return audiosrc;
+}
+
+void gst_audiosrc_push(GstSrc *src) {
+  GstAudioSrc *audiosrc;
+  GstBuffer *buf;
+  glong readbytes;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_AUDIOSRC(src));
+  audiosrc = GST_AUDIOSRC(src);
+
+//  g_print("attempting to read something from soundcard\n");
+
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+  GST_BUFFER_DATA(buf) = (gpointer)g_malloc(audiosrc->bytes_per_read);
+  readbytes = read(audiosrc->fd,GST_BUFFER_DATA(buf),
+                   audiosrc->bytes_per_read);
+  if (readbytes == 0) {
+    gst_src_signal_eos(GST_SRC(audiosrc));
+    return;
+  }
+
+  GST_BUFFER_SIZE(buf) = readbytes;
+  GST_BUFFER_OFFSET(buf) = audiosrc->curoffset;
+  audiosrc->curoffset += readbytes;
+
+//  gst_buffer_add_meta(buf,GST_META(newmeta));
+
+  gst_pad_push(audiosrc->srcpad,buf);
+//  g_print("pushed buffer from soundcard of %d bytes\n",readbytes);
+}
+
+static void gst_audiosrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAudioSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_AUDIOSRC(object));
+  src = GST_AUDIOSRC(object);
+
+  switch (id) {
+    case ARG_LOCATION:
+      if (src->filename) g_free(src->filename);
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->filename = NULL;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      } else {
+        src->filename = g_strdup(GTK_VALUE_STRING(*arg));
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_FORMAT:
+      src->format = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_CHANNELS:
+      src->channels = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_FREQUENCY:
+      src->frequency = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_audiosrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAudioSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_AUDIOSRC(object));
+  src = GST_AUDIOSRC(object);
+
+  switch (id) {
+    case ARG_LOCATION:
+      GTK_VALUE_STRING(*arg) = g_strdup(src->filename);
+      break;
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = src->bytes_per_read;
+      break;
+    case ARG_FORMAT:
+      GTK_VALUE_INT(*arg) = src->format;
+      break;
+    case ARG_CHANNELS:
+      GTK_VALUE_INT(*arg) = src->channels;
+      break;
+    case ARG_FREQUENCY:
+      GTK_VALUE_INT(*arg) = src->frequency;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+static gboolean gst_audiosrc_change_state(GstElement *element,
+                                          GstElementState state) {
+  g_return_if_fail(GST_IS_AUDIOSRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_audiosrc_open_audio(GST_AUDIOSRC(element)))
+        return FALSE;
+      break;
+    case ~GST_STATE_RUNNING:
+      gst_audiosrc_close_audio(GST_AUDIOSRC(element));
+      break;
+    default:
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+
+static gboolean gst_audiosrc_open_audio(GstAudioSrc *src) {
+  g_return_if_fail(src->fd == -1);
+
+  /* first try to open the sound card */
+  src->fd = open("/dev/dsp",O_RDONLY);
+
+  /* if we have it, set the default parameters and go have fun */ 
+  if (src->fd > 0) {
+    int arg = 0x7fff0006;
+
+    if (ioctl(src->fd, SNDCTL_DSP_SETFRAGMENT, &arg)) perror("uh");
+
+    /* set card state */
+    gst_audiosrc_sync_parms(src);
+    DEBUG("opened audio\n");
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+static void gst_audiosrc_close_audio(GstAudioSrc *src) {
+  g_return_if_fail(src->fd >= 0);
+
+  close(src->fd);
+  src->fd = -1;
+}
+
+void gst_audiosrc_sync_parms(GstAudioSrc *audiosrc) {
+  audio_buf_info ospace;
+  
+  g_return_if_fail(audiosrc != NULL);
+  g_return_if_fail(GST_IS_AUDIOSRC(audiosrc));
+  g_return_if_fail(audiosrc->fd > 0);
+ 
+  ioctl(audiosrc->fd,SNDCTL_DSP_RESET,0);
+ 
+  ioctl(audiosrc->fd,SNDCTL_DSP_SETFMT,&audiosrc->format);
+  ioctl(audiosrc->fd,SNDCTL_DSP_CHANNELS,&audiosrc->channels);
+  ioctl(audiosrc->fd,SNDCTL_DSP_SPEED,&audiosrc->frequency);
+  
+  ioctl(audiosrc->fd,SNDCTL_DSP_GETOSPACE,&ospace);
+ 
+  g_print("setting sound card to %dKHz %d bit %s (%d bytes buffer)\n",
+          audiosrc->frequency,audiosrc->format,
+          (audiosrc->channels == 2) ? "stereo" : "mono",ospace.bytes);
+
+//  audiosrc->meta.format = audiosrc->format;
+//  audiosrc->meta.channels = audiosrc->channels;
+//  audiosrc->meta.frequency = audiosrc->frequency;
+//  audiosrc->sentmeta = FALSE;
+}

gst/elements/gstaudiosrc.h

@@ -0,0 +1,90 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_AUDIOSRC_H__
+#define __GST_AUDIOSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+#include <gst/meta/audioraw.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_audiosrc_details;
+
+
+#define GST_TYPE_AUDIOSRC \
+  (gst_audiosrc_get_type())
+#define GST_AUDIOSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSRC,GstAudioSrc))
+#define GST_AUDIOSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSRC,GstAudioSrcClass))
+#define GST_IS_AUDIOSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSRC))
+#define GST_IS_AUDIOSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSRC)))
+
+typedef struct _GstAudioSrc GstAudioSrc;
+typedef struct _GstAudioSrcClass GstAudioSrcClass;
+
+struct _GstAudioSrc {
+  GstSrc src;
+
+  /* pads */
+  GstPad *srcpad;
+
+  /* sound card */
+  gchar *filename;
+  gint fd;
+
+  /* audio parameters */
+  gint format;
+  gint channels;
+  gint frequency;
+
+  /* blocking */
+  gulong curoffset;
+  gulong bytes_per_read;
+
+  gulong seq;
+
+  MetaAudioRaw *meta;
+};
+
+struct _GstAudioSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_audiosrc_get_type(void);
+GstElement *gst_audiosrc_new(gchar *name);
+
+void gst_audiosrc_push(GstSrc *src);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_AUDIOSRC_H__ */

gst/elements/gstdisksrc.c

@@ -0,0 +1,267 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <gstdisksrc.h>
+
+
+GstElementDetails gst_disksrc_details = {
+  "Disk Source",
+  "Source/File",
+  "Synchronous read from a file",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* DiskSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_OFFSET,
+};
+
+
+static void gst_disksrc_class_init(GstDiskSrcClass *klass);
+static void gst_disksrc_init(GstDiskSrc *disksrc);
+static void gst_disksrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_disksrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+static void gst_disksrc_push(GstSrc *src);
+static void gst_disksrc_push_region(GstSrc *src,gulong offset,gulong size);
+static gboolean gst_disksrc_change_state(GstElement *element,
+                                         GstElementState state);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_disksrc_get_type(void) {
+  static GtkType disksrc_type = 0;
+
+  if (!disksrc_type) {
+    static const GtkTypeInfo disksrc_info = {
+      "GstDiskSrc",
+      sizeof(GstDiskSrc),
+      sizeof(GstDiskSrcClass),
+      (GtkClassInitFunc)gst_disksrc_class_init,
+      (GtkObjectInitFunc)gst_disksrc_init,
+      (GtkArgSetFunc)gst_disksrc_set_arg,
+      (GtkArgGetFunc)gst_disksrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    disksrc_type = gtk_type_unique(GST_TYPE_SRC,&disksrc_info);
+  }
+  return disksrc_type;
+}
+
+static void
+gst_disksrc_class_init(GstDiskSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstDiskSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_READWRITE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstDiskSrc::bytesperread", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+  gtk_object_add_arg_type("GstDiskSrc::offset", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_OFFSET);
+
+  gtkobject_class->set_arg = gst_disksrc_set_arg;
+  gtkobject_class->get_arg = gst_disksrc_get_arg;
+
+  gstelement_class->change_state = gst_disksrc_change_state;
+
+  gstsrc_class->push = gst_disksrc_push;
+  /* we nominally can't (won't) do async */
+  gstsrc_class->push_region = NULL;
+}
+
+static void gst_disksrc_init(GstDiskSrc *disksrc) {
+  disksrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(disksrc),disksrc->srcpad);
+
+  disksrc->filename = NULL;
+  disksrc->fd = 0;
+  disksrc->curoffset = 0;
+  disksrc->bytes_per_read = 4096;
+  disksrc->seq = 0;
+}
+
+
+static void gst_disksrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_DISKSRC(object));
+  src = GST_DISKSRC(object);
+
+  switch(id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+//      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->filename) g_free(src->filename);
+      /* clear the filename if we get a NULL (is that possible?) */
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->filename = NULL;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      /* otherwise set the new filename */
+      } else {
+        src->filename = g_strdup(GTK_VALUE_STRING(*arg));  
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_disksrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_DISKSRC(object));
+  src = GST_DISKSRC(object);
+
+  switch (id) {
+    case ARG_LOCATION:
+      GTK_VALUE_STRING(*arg) = src->filename;
+      break;
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = src->bytes_per_read;
+      break;
+    case ARG_OFFSET:
+      GTK_VALUE_INT(*arg) = src->curoffset;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+void gst_disksrc_push(GstSrc *src) {
+  GstDiskSrc *disksrc;
+  GstBuffer *buf;
+  glong readbytes;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_DISKSRC(src));
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_DISKSRC_OPEN));
+  disksrc = GST_DISKSRC(src);
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+
+  /* allocate the space for the buffer data */
+  GST_BUFFER_DATA(buf) = g_malloc(disksrc->bytes_per_read);
+  g_return_if_fail(GST_BUFFER_DATA(buf) != NULL);
+
+  /* read it in from the file */
+  readbytes = read(disksrc->fd,GST_BUFFER_DATA(buf),disksrc->bytes_per_read);
+  if (readbytes == 0) {
+    gst_src_signal_eos(GST_SRC(disksrc));
+    return;
+  }
+
+  /* if we didn't get as many bytes as we asked for, we're at EOF */
+  if (readbytes < disksrc->bytes_per_read)
+    GST_BUFFER_FLAG_SET(buf,GST_BUFFER_EOS);
+  GST_BUFFER_OFFSET(buf) = disksrc->curoffset;
+  GST_BUFFER_SIZE(buf) = readbytes;
+  disksrc->curoffset += readbytes;
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(disksrc->srcpad,buf);
+}
+
+
+/* open the file, necessary to go to RUNNING state */
+static gboolean gst_disksrc_open_file(GstDiskSrc *src) {
+  g_return_if_fail(!GST_FLAG_IS_SET(src,GST_DISKSRC_OPEN));
+
+  /* open the file */
+  src->fd = open(src->filename,O_RDONLY);
+  if (src->fd < 0) {
+    perror("open()");
+    gst_element_error(GST_ELEMENT(src),"opening file");
+    return FALSE;
+  }
+  GST_FLAG_SET(src,GST_DISKSRC_OPEN);
+  return TRUE;
+}
+
+/* close the file */
+static void gst_disksrc_close_file(GstDiskSrc *src) {
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_DISKSRC_OPEN));
+
+  /* close the file */
+  close(src->fd);
+
+  /* zero out a lot of our state */
+  src->fd = 0;
+  src->curoffset = 0;
+  src->seq = 0;
+
+  GST_FLAG_UNSET(src,GST_DISKSRC_OPEN);
+}
+
+static gboolean gst_disksrc_change_state(GstElement *element,
+                                         GstElementState state) {
+  g_return_if_fail(GST_IS_DISKSRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_disksrc_open_file(GST_DISKSRC(element)))
+        return FALSE;
+      break;  
+    case ~GST_STATE_RUNNING:
+      gst_disksrc_close_file(GST_DISKSRC(element));
+      break;
+    default:
+      break;
+  }     
+      
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}

gst/elements/gstdisksrc.h

@@ -0,0 +1,83 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_DISKSRC_H__
+#define __GST_DISKSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_disksrc_details;
+
+
+#define GST_TYPE_DISKSRC \
+  (gst_disksrc_get_type())
+#define GST_DISKSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_DISKSRC,GstDiskSrc))
+#define GST_DISKSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_DISKSRC,GstDiskSrcClass))
+#define GST_IS_DISKSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_DISKSRC))
+#define GST_IS_DISKSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_DISKSRC)))
+
+// NOTE: per-element flags start with 16 for now
+typedef enum {
+  GST_DISKSRC_OPEN		= (1 << 16),
+} GstDiskSrcFlags;
+
+typedef struct _GstDiskSrc GstDiskSrc;
+typedef struct _GstDiskSrcClass GstDiskSrcClass;
+
+struct _GstDiskSrc {
+  GstSrc src;
+  /* pads */
+  GstPad *srcpad;
+
+  /* filename */
+  gchar *filename;
+  /* fd */
+  gint fd;
+
+  gulong curoffset;			/* current offset in file */
+  gulong bytes_per_read;		/* bytes per read */
+
+  gulong seq;				/* buffer sequence number */
+};
+
+struct _GstDiskSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_disksrc_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_DISKSRC_H__ */

gst/elements/gstelements.c

@@ -0,0 +1,85 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gst.h>
+
+#include <gstasyncdisksrc.h>
+#include <gstaudiosink.h>
+#include <gstaudiosrc.h>
+#include <gstdisksrc.h>
+#include <gstidentity.h>
+#include <gstfakesink.h>
+#include <gstfakesrc.h>
+#include <gstfdsink.h>
+#include <gstfdsrc.h>
+#include <gsthttpsrc.h>
+#include <gstqueue.h>
+#include <gstsinesrc.h>
+
+
+struct _elements_entry {
+  gchar *name;
+  GtkType (*type) (void);
+  GstElementDetails *details;
+};
+
+struct _elements_entry _elements[] = {
+  { "asyncdisksrc", gst_asyncdisksrc_get_type, &gst_asyncdisksrc_details },
+  { "audiosink", gst_audiosink_get_type, &gst_audiosink_details },
+  { "audiosrc", gst_audiosrc_get_type, &gst_audiosrc_details },
+  { "disksrc", gst_disksrc_get_type, &gst_disksrc_details },
+  { "identity", gst_identity_get_type, &gst_identity_details },
+  { "fakesink", gst_fakesink_get_type, &gst_fakesink_details },
+  { "fakesrc", gst_fakesrc_get_type, &gst_fakesrc_details },
+  { "fdsink", gst_fdsink_get_type, &gst_fdsink_details },
+  { "fdsrc", gst_fdsrc_get_type, &gst_fdsrc_details },
+  { "httpsrc", gst_httpsrc_get_type, &gst_httpsrc_details },
+  { "queue", gst_queue_get_type, &gst_queue_details },
+  { "sinesrc", gst_sinesrc_get_type, &gst_sinesrc_details },
+  { NULL, 0 },
+};
+
+GstPlugin *plugin_init(GModule *module) {
+  GstPlugin *plugin;
+  GstElementFactory *factory;
+  int i = 0;
+
+  if (gst_plugin_find("gstelements") != NULL) return NULL;
+
+  plugin = gst_plugin_new("gstelements");
+  g_return_val_if_fail(plugin != NULL,NULL);
+
+  gst_plugin_set_longname(plugin,"Standard GST Elements");
+
+  while (_elements[i].name) {
+    factory = gst_elementfactory_new(_elements[i].name,
+                                     (_elements[i].type)(),
+                                     _elements[i].details);
+    if (factory != NULL) {
+      gst_plugin_add_factory(plugin,factory);
+//      DEBUG("added factory '%s'\n",_elements[i].name);
+    }
+    i++;
+  }
+
+  gst_info("gstelements: loaded %d standard elements\n",i);
+
+  return plugin;
+}

gst/elements/gstesdsink.h

@@ -0,0 +1,81 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_ESDSINK_H__
+#define __GST_ESDSINK_H__
+
+
+#include <gst/gstfilter.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_ESDSINK \
+  (gst_esdsink_get_type())
+#define GST_ESDSINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_ESDSINK,GstEsdSink))
+#define GST_ESDSINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ESDSINK,GstEsdSinkClass))
+#define GST_IS_ESDSINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_ESDSINK))
+#define GST_IS_ESDSINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ESDSINK)))
+
+typedef struct _GstEsdSink GstEsdSink;
+typedef struct _GstEsdSinkClass GstEsdSinkClass;
+
+struct _GstEsdSink {
+  GstFilter filter;
+
+  GstPad *sinkpad;
+
+  /* soundcard state */
+  
+  int fd;
+  gint format;
+  gint channels;
+  gint frequency;
+};
+
+struct _GstEsdSinkClass {
+  GstFilterClass parent_class;
+
+  /* signals */
+  void (*handoff) (GstElement *element,GstPad *pad);
+};
+
+GtkType gst_esdsink_get_type(void);
+GstElement *gst_esdsink_new(gchar *name);
+void gst_esdsink_chain(GstPad *pad,GstBuffer *buf);
+
+void gst_esdsink_sync_parms(GstEsdSink *esdsink);
+
+void gst_esdsink_set_format(GstEsdSink *esdsink,gint format);
+void gst_esdsink_set_channels(GstEsdSink *esdsink,gint channels);
+void gst_esdsink_set_frequency(GstEsdSink *esdsink,gint frequency);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_ESDSINK_H__ */

gst/elements/gstfakesink.c

@@ -0,0 +1,109 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstfakesink.h>
+
+
+GstElementDetails gst_fakesink_details = {
+  "Fake Sink",
+  "Sink",
+  "Black hole for data",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* FakeSink signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_fakesink_class_init(GstFakeSinkClass *klass);
+static void gst_fakesink_init(GstFakeSink *fakesink);
+
+
+static GstSinkClass *parent_class = NULL;
+static guint gst_fakesink_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_fakesink_get_type(void) {
+  static GtkType fakesink_type = 0;
+
+  if (!fakesink_type) {
+    static const GtkTypeInfo fakesink_info = {
+      "GstFakeSink",
+      sizeof(GstFakeSink),
+      sizeof(GstFakeSinkClass),
+      (GtkClassInitFunc)gst_fakesink_class_init,
+      (GtkObjectInitFunc)gst_fakesink_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    fakesink_type = gtk_type_unique(GST_TYPE_SINK,&fakesink_info);
+  }
+  return fakesink_type;
+}
+
+static void
+gst_fakesink_class_init(GstFakeSinkClass *klass) {
+  GstSinkClass *gstsink_class;
+
+  gstsink_class = (GstSinkClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SINK);
+}
+
+static void gst_fakesink_init(GstFakeSink *fakesink) {
+  fakesink->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(fakesink),fakesink->sinkpad);
+  gst_pad_set_chain_function(fakesink->sinkpad,gst_fakesink_chain);
+
+  // we're already complete, since we don't have any args...
+  gst_element_set_state(GST_ELEMENT(fakesink),GST_STATE_COMPLETE);
+}
+
+GstElement *gst_fakesink_new(gchar *name) {
+  GstElement *fakesink = GST_ELEMENT(gtk_type_new(GST_TYPE_FAKESINK));
+  gst_element_set_name(GST_ELEMENT(fakesink),name);
+  return fakesink;
+}
+
+void gst_fakesink_chain(GstPad *pad,GstBuffer *buf) {
+  GstFakeSink *fakesink;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  fakesink = GST_FAKESINK(pad->parent);
+//  g_print("gst_fakesink_chain: got buffer of %d bytes in '%s'\n",
+//          buf->datasize,gst_element_get_name(GST_ELEMENT(fakesink)));
+  g_print("<");
+  gst_buffer_unref(buf);
+}

gst/elements/gstfakesink.h

@@ -0,0 +1,71 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_FAKESINK_H__
+#define __GST_FAKESINK_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_fakesink_details;
+
+
+#define GST_TYPE_FAKESINK \
+  (gst_fakesink_get_type())
+#define GST_FAKESINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_FAKESINK,GstFakeSink))
+#define GST_FAKESINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESINK,GstFakeSinkClass))
+#define GST_IS_FAKESINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESINK))
+#define GST_IS_FAKESINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESINK)))
+
+typedef struct _GstFakeSink GstFakeSink;
+typedef struct _GstFakeSinkClass GstFakeSinkClass;
+
+struct _GstFakeSink {
+  GstSink sink;
+
+  GstPad *sinkpad;
+};
+
+struct _GstFakeSinkClass {
+  GstSinkClass parent_class;
+};
+
+GtkType gst_fakesink_get_type(void);
+GstElement *gst_fakesink_new(gchar *name);
+void gst_fakesink_chain(GstPad *pad,GstBuffer *buf);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FAKESINK_H__ */

gst/elements/gstfakesrc.c

@@ -0,0 +1,112 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstfakesrc.h>
+
+
+GstElementDetails gst_fakesrc_details = {
+  "Fake Source",
+  "Source",
+  "Push empty (no data) buffers around",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* FakeSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_fakesrc_class_init(GstFakeSrcClass *klass);
+static void gst_fakesrc_init(GstFakeSrc *fakesrc);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_fakesrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_fakesrc_get_type(void) {
+  static GtkType fakesrc_type = 0;
+
+  if (!fakesrc_type) {
+    static const GtkTypeInfo fakesrc_info = {
+      "GstFakeSrc",
+      sizeof(GstFakeSrc),
+      sizeof(GstFakeSrcClass),
+      (GtkClassInitFunc)gst_fakesrc_class_init,
+      (GtkObjectInitFunc)gst_fakesrc_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    fakesrc_type = gtk_type_unique(GST_TYPE_SRC,&fakesrc_info);
+  }
+  return fakesrc_type;
+}
+
+static void
+gst_fakesrc_class_init(GstFakeSrcClass *klass) {
+  GstSrcClass *gstsrc_class;
+
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gstsrc_class->push = gst_fakesrc_push;
+  gstsrc_class->push_region = NULL;
+}
+
+static void gst_fakesrc_init(GstFakeSrc *fakesrc) {
+  fakesrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(fakesrc),fakesrc->srcpad);
+
+  // we're already complete, since we don't have any args...
+  gst_element_set_state(GST_ELEMENT(fakesrc),GST_STATE_COMPLETE);
+}
+
+GstElement *gst_fakesrc_new(gchar *name) {
+  GstElement *fakesrc = GST_ELEMENT(gtk_type_new(GST_TYPE_FAKESRC));
+  gst_element_set_name(GST_ELEMENT(fakesrc),name);
+  return fakesrc;
+}
+
+void gst_fakesrc_push(GstSrc *src) {
+  GstFakeSrc *fakesrc;
+  GstBuffer *buf;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_FAKESRC(src));
+  fakesrc = GST_FAKESRC(src);
+
+//  g_print("gst_fakesrc_push(): pushing fake buffer from '%s'\n",
+//          gst_element_get_name(GST_ELEMENT(fakesrc)));
+  g_print(">");
+  buf = gst_buffer_new();
+  gst_pad_push(fakesrc->srcpad,buf);
+}

gst/elements/gstfakesrc.h

@@ -0,0 +1,70 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_FAKESRC_H__
+#define __GST_FAKESRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_fakesrc_details;
+
+
+#define GST_TYPE_FAKESRC \
+  (gst_fakesrc_get_type())
+#define GST_FAKESRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_FAKESRC,GstFakeSrc))
+#define GST_FAKESRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESRC,GstFakeSrcClass))
+#define GST_IS_FAKESRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESRC))
+#define GST_IS_FAKESRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESRC)))
+
+typedef struct _GstFakeSrc GstFakeSrc;
+typedef struct _GstFakeSrcClass GstFakeSrcClass;
+
+struct _GstFakeSrc {
+  GstSrc src;
+
+  GstPad *srcpad;
+};
+
+struct _GstFakeSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_fakesrc_get_type(void);
+GstElement *gst_fakesrc_new(gchar *name);
+void gst_fakesrc_push(GstSrc *src);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FAKESRC_H__ */

gst/elements/gstfdsink.c

@@ -0,0 +1,155 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gstfdsink.h>
+
+
+GstElementDetails gst_fdsink_details = {
+  "Filedescriptor Sink",
+  "Sink",
+  "Write data to a file descriptor",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* FdSink signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_FD
+};
+
+
+static void gst_fdsink_class_init(GstFdSinkClass *klass);
+static void gst_fdsink_init(GstFdSink *fdsink);
+static void gst_fdsink_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_fdsink_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+
+static GstSinkClass *parent_class = NULL;
+static guint gst_fdsink_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_fdsink_get_type(void) {
+  static GtkType fdsink_type = 0;
+
+  if (!fdsink_type) {
+    static const GtkTypeInfo fdsink_info = {
+      "GstFdSink",
+      sizeof(GstFdSink),
+      sizeof(GstFdSinkClass),
+      (GtkClassInitFunc)gst_fdsink_class_init,
+      (GtkObjectInitFunc)gst_fdsink_init,
+      (GtkArgSetFunc)gst_fdsink_set_arg,
+      (GtkArgGetFunc)gst_fdsink_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    fdsink_type = gtk_type_unique(GST_TYPE_SINK,&fdsink_info);
+  }
+  return fdsink_type;
+}
+
+static void
+gst_fdsink_class_init(GstFdSinkClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstSinkClass *gstsink_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstsink_class = (GstSinkClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SINK);
+
+  gtk_object_add_arg_type("GstFdSink::fd", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FD);
+
+  gtkobject_class->set_arg = gst_fdsink_set_arg;
+  gtkobject_class->get_arg = gst_fdsink_get_arg;
+}
+
+static void gst_fdsink_init(GstFdSink *fdsink) {
+  fdsink->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(fdsink),fdsink->sinkpad);
+  gst_pad_set_chain_function(fdsink->sinkpad,gst_fdsink_chain);
+
+  fdsink->fd = 1;
+}
+
+GstElement *gst_fdsink_new(gchar *name) {
+  GstElement *fdsink = GST_ELEMENT(gtk_type_new(GST_TYPE_FDSINK));
+  gst_element_set_name(GST_ELEMENT(fdsink),name);
+  return fdsink;
+}
+
+GstElement *gst_fdsink_new_with_fd(gchar *name,gint fd) {
+  GstElement *fdsink = gst_fdsink_new(name);
+  gtk_object_set(GTK_OBJECT(fdsink),"fd",fd,NULL);
+  return fdsink;
+}
+
+void gst_fdsink_chain(GstPad *pad,GstBuffer *buf) {
+  GstFdSink *fdsink;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  fdsink = GST_FDSINK(pad->parent);
+  g_return_if_fail(fdsink->fd >= 0);
+  if (GST_BUFFER_DATA(buf))
+    write(fdsink->fd,GST_BUFFER_DATA(buf),GST_BUFFER_SIZE(buf));
+  gst_buffer_unref(buf);
+}
+
+static void gst_fdsink_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstFdSink *fdsink;
+   
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FDSINK(object));
+  fdsink = GST_FDSINK(object);
+
+  switch(id) {
+    case ARG_FD:
+      fdsink->fd = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_fdsink_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstFdSink *fdsink;
+   
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FDSINK(object));
+  fdsink = GST_FDSINK(object);
+
+  switch(id) {
+    case ARG_FD:
+      GTK_VALUE_INT(*arg) = fdsink->fd;
+      break;
+    default:
+      break;
+  }
+}

gst/elements/gstfdsink.h

@@ -0,0 +1,74 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_FDSINK_H__
+#define __GST_FDSINK_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_fdsink_details;
+
+
+#define GST_TYPE_FDSINK \
+  (gst_fdsink_get_type())
+#define GST_FDSINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_FDSINK,GstFdSink))
+#define GST_FDSINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSINK,GstFdSinkClass))
+#define GST_IS_FDSINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_FDSINK))
+#define GST_IS_FDSINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSINK)))
+
+typedef struct _GstFdSink GstFdSink;
+typedef struct _GstFdSinkClass GstFdSinkClass;
+
+struct _GstFdSink {
+  GstSink sink;
+
+  GstPad *sinkpad;
+
+  int fd;
+};
+
+struct _GstFdSinkClass {
+  GstSinkClass parent_class;
+};
+
+GtkType gst_fdsink_get_type(void);
+GstElement *gst_fdsink_new(gchar *name);
+GstElement *gst_fdsink_new_with_fd(gchar *name,gint fd);
+void gst_fdsink_chain(GstPad *pad,GstBuffer *buf);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FDSINK_H__ */

gst/elements/gstfdsrc.c

@@ -0,0 +1,206 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <gstfdsrc.h>
+
+
+GstElementDetails gst_fdsrc_details = {
+  "Disk Source",
+  "Source/File",
+  "Synchronous read from a file",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* FdSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_OFFSET,
+};
+
+
+static void gst_fdsrc_class_init(GstFdSrcClass *klass);
+static void gst_fdsrc_init(GstFdSrc *fdsrc);
+static void gst_fdsrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_fdsrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+static void gst_fdsrc_push(GstSrc *src);
+static void gst_fdsrc_push_region(GstSrc *src,gulong offset,gulong size);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_fdsrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_fdsrc_get_type(void) {
+  static GtkType fdsrc_type = 0;
+
+  if (!fdsrc_type) {
+    static const GtkTypeInfo fdsrc_info = {
+      "GstFdSrc",
+      sizeof(GstFdSrc),
+      sizeof(GstFdSrcClass),
+      (GtkClassInitFunc)gst_fdsrc_class_init,
+      (GtkObjectInitFunc)gst_fdsrc_init,
+      (GtkArgSetFunc)gst_fdsrc_set_arg,
+      (GtkArgGetFunc)gst_fdsrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    fdsrc_type = gtk_type_unique(GST_TYPE_SRC,&fdsrc_info);
+  }
+  return fdsrc_type;
+}
+
+static void
+gst_fdsrc_class_init(GstFdSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstFdSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_WRITABLE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstFdSrc::bytesperread", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+  gtk_object_add_arg_type("GstFdSrc::offset", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_OFFSET);
+
+  gtkobject_class->set_arg = gst_fdsrc_set_arg;
+  gtkobject_class->get_arg = gst_fdsrc_get_arg;
+
+  gstsrc_class->push = gst_fdsrc_push;
+  /* we nominally can't (won't) do async */
+  gstsrc_class->push_region = NULL;
+}
+
+static void gst_fdsrc_init(GstFdSrc *fdsrc) {
+  fdsrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(fdsrc),fdsrc->srcpad);
+
+  fdsrc->fd = 0;
+  fdsrc->curoffset = 0;
+  fdsrc->bytes_per_read = 4096;
+  fdsrc->seq = 0;
+}
+
+
+static void gst_fdsrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstFdSrc *src;
+  int fd;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FDSRC(object));
+  src = GST_FDSRC(object);
+
+  switch(id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      /* if we get a NULL, consider it to be a fd of 0 */
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->fd = 0;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      /* otherwise set the new filename */
+      } else {
+        if (sscanf(GTK_VALUE_STRING(*arg),"%d",&fd))
+          src->fd = fd;
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_fdsrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstFdSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FDSRC(object));
+  src = GST_FDSRC(object);
+
+  switch (id) {
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = src->bytes_per_read;
+      break;
+    case ARG_OFFSET:
+      GTK_VALUE_INT(*arg) = src->curoffset;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+void gst_fdsrc_push(GstSrc *src) {
+  GstFdSrc *fdsrc;
+  GstBuffer *buf;
+  glong readbytes;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_FDSRC(src));
+  fdsrc = GST_FDSRC(src);
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+
+  /* allocate the space for the buffer data */
+  GST_BUFFER_DATA(buf) = g_malloc(fdsrc->bytes_per_read);
+  g_return_if_fail(GST_BUFFER_DATA(buf) != NULL);
+
+  /* read it in from the file */
+  readbytes = read(fdsrc->fd,GST_BUFFER_DATA(buf),fdsrc->bytes_per_read);
+  if (readbytes == 0) {
+    gst_src_signal_eos(GST_SRC(fdsrc));
+    return;
+  }
+
+  /* if we didn't get as many bytes as we asked for, we're at EOF */
+  if (readbytes < fdsrc->bytes_per_read) {
+    // FIXME: set the buffer's EOF bit here
+  }
+  GST_BUFFER_OFFSET(buf) = fdsrc->curoffset;
+  GST_BUFFER_SIZE(buf) = readbytes;
+  fdsrc->curoffset += readbytes;
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(fdsrc->srcpad,buf);
+}

gst/elements/gstfdsrc.h

@@ -0,0 +1,77 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_FDSRC_H__
+#define __GST_FDSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_fdsrc_details;
+
+
+#define GST_TYPE_FDSRC \
+  (gst_fdsrc_get_type())
+#define GST_FDSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_FDSRC,GstFdSrc))
+#define GST_FDSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSRC,GstFdSrcClass))
+#define GST_IS_FDSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_FDSRC))
+#define GST_IS_FDSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSRC)))
+
+
+typedef struct _GstFdSrc GstFdSrc;
+typedef struct _GstFdSrcClass GstFdSrcClass;
+
+struct _GstFdSrc {
+  GstSrc src;
+  /* pads */
+  GstPad *srcpad;
+
+  /* fd */
+  gint fd;
+
+  gulong curoffset;			/* current offset in file */
+  gulong bytes_per_read;		/* bytes per read */
+
+  gulong seq;				/* buffer sequence number */
+};
+
+struct _GstFdSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_fdsrc_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FDSRC_H__ */

gst/elements/gsthttpsrc.c

@@ -0,0 +1,258 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <gsthttpsrc.h>
+
+
+GstElementDetails gst_httpsrc_details = {
+  "HTTP Source",
+  "Source/Network",
+  "Read data from an HTTP stream",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+static void gst_httpsrc_push(GstSrc *src);
+static gboolean gst_httpsrc_open_url(GstHttpSrc *src);
+static void gst_httpsrc_close_url(GstHttpSrc *src);
+static gboolean gst_httpsrc_change_state(GstElement *element,
+                                         GstElementState state);
+
+
+/* HttpSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_OFFSET
+};
+
+
+static void gst_httpsrc_class_init(GstHttpSrcClass *klass);
+static void gst_httpsrc_init(GstHttpSrc *httpsrc);
+static void gst_httpsrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_httpsrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_httpsrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_httpsrc_get_type(void) {
+  static GtkType httpsrc_type = 0;
+
+  if (!httpsrc_type) {
+    static const GtkTypeInfo httpsrc_info = {
+      "GstHttpSrc",
+      sizeof(GstHttpSrc),
+      sizeof(GstHttpSrcClass),
+      (GtkClassInitFunc)gst_httpsrc_class_init,
+      (GtkObjectInitFunc)gst_httpsrc_init,
+      (GtkArgSetFunc)gst_httpsrc_set_arg,
+      (GtkArgGetFunc)gst_httpsrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    httpsrc_type = gtk_type_unique(GST_TYPE_SRC,&httpsrc_info);
+  }
+  return httpsrc_type;
+}
+
+static void
+gst_httpsrc_class_init(GstHttpSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+
+  gtk_object_add_arg_type("GstHttpSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_READWRITE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstHttpSrc::bytesperread", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+
+  gtkobject_class->set_arg = gst_httpsrc_set_arg;
+  gtkobject_class->get_arg = gst_httpsrc_get_arg;
+
+  gstelement_class->change_state = gst_httpsrc_change_state;
+
+  gstsrc_class->push = gst_httpsrc_push;
+  gstsrc_class->push_region = NULL;
+}
+
+static void gst_httpsrc_init(GstHttpSrc *httpsrc) {
+  httpsrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(httpsrc),httpsrc->srcpad);
+
+  httpsrc->url = NULL;
+  httpsrc->request = NULL;
+  httpsrc->fd = 0;
+  httpsrc->curoffset = 0;
+  httpsrc->bytes_per_read = 4096;
+}
+
+static void gst_httpsrc_push(GstSrc *src) {
+  GstHttpSrc *httpsrc;
+  GstBuffer *buf;
+  glong readbytes;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_HTTPSRC(src));
+//  g_return_if_fail(GST_FLAG_IS_SET(src,GST_));
+  httpsrc = GST_HTTPSRC(src);
+
+  buf = gst_buffer_new();
+  GST_BUFFER_DATA(buf) = (gpointer)malloc(httpsrc->bytes_per_read);
+  readbytes = read(httpsrc->fd,GST_BUFFER_DATA(buf),httpsrc->bytes_per_read);
+  if (readbytes == 0) {
+    gst_src_signal_eos(GST_SRC(httpsrc));
+    return;
+  }
+
+  if (readbytes < httpsrc->bytes_per_read) {
+    // FIXME: set the buffer's EOF bit here
+  }
+  GST_BUFFER_OFFSET(buf) = httpsrc->curoffset;
+  GST_BUFFER_SIZE(buf) = readbytes;
+  httpsrc->curoffset += readbytes;
+
+  gst_pad_push(httpsrc->srcpad,buf);
+}
+
+static gboolean gst_httpsrc_open_url(GstHttpSrc *httpsrc) {
+  gint status;
+
+  g_return_if_fail(httpsrc != NULL);
+  g_return_if_fail(GST_IS_HTTPSRC(httpsrc));
+  g_return_if_fail(httpsrc->url != NULL);
+
+  httpsrc->request = ghttp_request_new();
+  ghttp_set_uri(httpsrc->request,httpsrc->url);
+  ghttp_set_sync(httpsrc->request,ghttp_async);
+  ghttp_set_header(httpsrc->request,"User-Agent","GstHttpSrc");
+  ghttp_prepare(httpsrc->request);
+
+  /* process everything up to the actual data stream */
+  /* FIXME: should be in preroll, but hey */
+  status = 0;
+  while ((ghttp_get_status(httpsrc->request).proc != ghttp_proc_response)
+         && (status >= 0)) {
+    status = ghttp_process(httpsrc->request);
+  }
+
+  /* get the fd so we can read data ourselves */
+  httpsrc->fd = ghttp_get_socket(httpsrc->request);
+  return TRUE;
+}
+
+/* unmap and close the file */
+static void gst_httpsrc_close_url(GstHttpSrc *src) {  
+  g_return_if_fail(src->fd > 0);
+ 
+  close(src->fd);
+  src->fd = 0;
+}
+
+static void gst_httpsrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstHttpSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_HTTPSRC(object));
+  src = GST_HTTPSRC(object);
+
+  switch(id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->url) g_free(src->url);
+      /* clear the url if we get a NULL (is that possible?) */
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->url = NULL;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      /* otherwise set the new url */
+      } else {
+        src->url = g_strdup(GTK_VALUE_STRING(*arg));
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_httpsrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstHttpSrc *httpsrc;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_HTTPSRC(object));
+  httpsrc = GST_HTTPSRC(object);
+                          
+  switch (id) {
+    case ARG_LOCATION:
+      GTK_VALUE_STRING(*arg) = httpsrc->url;
+      break;
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = httpsrc->bytes_per_read;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+static gboolean gst_httpsrc_change_state(GstElement *element,
+                                         GstElementState state) {
+  g_return_if_fail(GST_IS_HTTPSRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_httpsrc_open_url(GST_HTTPSRC(element)))
+        return FALSE;
+      break;  
+    case ~GST_STATE_RUNNING:
+      gst_httpsrc_close_url(GST_HTTPSRC(element));
+      break;
+    default:   
+      break;
+  }
+ 
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+

gst/elements/gsthttpsrc.h

@@ -0,0 +1,77 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_HTTPSRC_H__
+#define __GST_HTTPSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+#include <ghttp.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_httpsrc_details;
+
+
+#define GST_TYPE_HTTPSRC \
+  (gst_httpsrc_get_type())
+#define GST_HTTPSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_HTTPSRC,GstHttpSrc))
+#define GST_HTTPSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_HTTPSRC,GstHttpSrcClass))
+#define GST_IS_HTTPSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_HTTPSRC))
+#define GST_IS_HTTPSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_HTTPSRC)))
+
+typedef struct _GstHttpSrc GstHttpSrc;
+typedef struct _GstHttpSrcClass GstHttpSrcClass;
+
+struct _GstHttpSrc {
+  GstSrc src;
+  /* pads */
+  GstPad *srcpad;
+
+  gchar *url;
+  ghttp_request *request;
+  int fd;
+
+  gulong curoffset;			/* current offset in file */
+  gulong bytes_per_read;		/* bytes per read */
+};
+
+struct _GstHttpSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_httpsrc_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_HTTPSRC_H__ */

gst/elements/gstidentity.c

@@ -0,0 +1,152 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstidentity.h>
+
+
+GstElementDetails gst_identity_details = {
+  "Identity",
+  "Filter",
+  "Pass data without modification",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* Identity signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_CONTROL
+};
+
+
+static void gst_identity_class_init(GstIdentityClass *klass);
+static void gst_identity_init(GstIdentity *identity);
+static void gst_identity_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_identity_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+
+static GstFilterClass *parent_class = NULL;
+static guint gst_identity_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_identity_get_type(void) {
+  static GtkType identity_type = 0;
+
+  if (!identity_type) {
+    static const GtkTypeInfo identity_info = {
+      "GstIdentity",
+      sizeof(GstIdentity),
+      sizeof(GstIdentityClass),
+      (GtkClassInitFunc)gst_identity_class_init,
+      (GtkObjectInitFunc)gst_identity_init,
+      (GtkArgSetFunc)gst_identity_set_arg,
+      (GtkArgGetFunc)gst_identity_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    identity_type = gtk_type_unique(GST_TYPE_FILTER,&identity_info);
+  }
+  return identity_type;
+}
+
+static void gst_identity_class_init(GstIdentityClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstFilterClass *gstfilter_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstfilter_class = (GstFilterClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_FILTER);
+
+  gtk_object_add_arg_type("GstIdentity::control", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_CONTROL);
+
+  gtkobject_class->set_arg = gst_identity_set_arg;  
+  gtkobject_class->get_arg = gst_identity_get_arg;
+}
+
+static void gst_identity_init(GstIdentity *identity) {
+  identity->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(identity),identity->sinkpad);
+  gst_pad_set_chain_function(identity->sinkpad,gst_identity_chain);
+  identity->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(identity),identity->srcpad);
+
+  identity->control = 0;
+}
+
+GstElement *gst_identity_new(gchar *name) {
+  GstElement *identity = GST_ELEMENT(gtk_type_new(GST_TYPE_IDENTITY));
+  gst_element_set_name(GST_ELEMENT(identity),name);
+  return identity;
+}
+
+void gst_identity_chain(GstPad *pad,GstBuffer *buf) {
+  GstIdentity *identity;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  identity = GST_IDENTITY(pad->parent);
+//  g_print("gst_identity_chain: got buffer in '%s'\n",
+//          gst_element_get_name(GST_ELEMENT(identity)));
+  g_print("i");
+  gst_pad_push(identity->srcpad,buf);
+}
+
+static void gst_identity_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstIdentity *identity;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_IDENTITY(object));
+  identity = GST_IDENTITY(object);
+
+  switch(id) {
+    case ARG_CONTROL:
+      identity->control = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_identity_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstIdentity *identity;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_IDENTITY(object));
+  identity = GST_IDENTITY(object);
+
+  switch (id) {
+    case ARG_CONTROL:
+      GTK_VALUE_INT(*arg) = identity->control;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}

gst/elements/gstidentity.h

@@ -0,0 +1,74 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_IDENTITY_H__
+#define __GST_IDENTITY_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_identity_details;
+
+
+#define GST_TYPE_IDENTITY \
+  (gst_identity_get_type())
+#define GST_IDENTITY(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_IDENTITY,GstIdentity))
+#define GST_IDENTITY_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_IDENTITY,GstIdentityClass))
+#define GST_IS_IDENTITY(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_IDENTITY))
+#define GST_IS_IDENTITY_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_IDENTITY)))
+
+typedef struct _GstIdentity GstIdentity;
+typedef struct _GstIdentityClass GstIdentityClass;
+
+struct _GstIdentity {
+  GstFilter filter;
+
+  GstPad *sinkpad;
+  GstPad *srcpad;
+
+  gint control;
+};
+
+struct _GstIdentityClass {
+  GstFilterClass parent_class;
+};
+
+GtkType gst_identity_get_type(void);
+GstElement *gst_identity_new(gchar *name);
+void gst_identity_chain(GstPad *pad,GstBuffer *buf);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_IDENTITY_H__ */

gst/elements/gstqueue.c

@@ -0,0 +1,216 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstqueue.h>
+
+
+GstElementDetails gst_queue_details = {
+  "Queue",
+  "Connection",
+  "Simple data queue",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* Queue signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LEVEL,
+};
+
+
+static void gst_queue_class_init(GstQueueClass *klass);
+static void gst_queue_init(GstQueue *queue);
+static void gst_queue_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_queue_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+
+static GstConnectionClass *parent_class = NULL;
+static guint gst_queue_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_queue_get_type(void) {
+  static GtkType queue_type = 0;
+
+  if (!queue_type) {
+    static const GtkTypeInfo queue_info = {
+      "GstQueue",
+      sizeof(GstQueue),
+      sizeof(GstQueueClass),
+      (GtkClassInitFunc)gst_queue_class_init,
+      (GtkObjectInitFunc)gst_queue_init,
+      (GtkArgSetFunc)gst_queue_set_arg,
+      (GtkArgGetFunc)gst_queue_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    queue_type = gtk_type_unique(GST_TYPE_CONNECTION,&queue_info);
+  }
+  return queue_type;
+}
+
+static void gst_queue_class_init(GstQueueClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstConnectionClass *gstconnection_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstconnection_class = (GstConnectionClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_CONNECTION);
+
+  gtk_object_add_arg_type("GstQueue::level", GTK_TYPE_INT,
+                          GTK_ARG_READABLE, ARG_LEVEL);
+
+  gstconnection_class->push = gst_queue_push;
+
+  gtkobject_class->set_arg = gst_queue_set_arg;  
+  gtkobject_class->get_arg = gst_queue_get_arg;
+}
+
+static void gst_queue_init(GstQueue *queue) {
+  queue->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(queue),queue->sinkpad);
+  gst_pad_set_chain_function(queue->sinkpad,gst_queue_chain);
+  queue->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(queue),queue->srcpad);
+
+  queue->queue = NULL;
+  queue->tail = NULL;
+  queue->level_buffers = 0;
+  queue->level_bytes = 0;
+  queue->size_buffers = 0;
+  queue->size_bytes = 0;
+
+  queue->waiterlock = g_mutex_new();
+  queue->waitercond = g_cond_new();
+}
+
+GstElement *gst_queue_new(gchar *name) {
+  GstElement *queue = GST_ELEMENT(gtk_type_new(GST_TYPE_QUEUE));
+  gst_element_set_name(GST_ELEMENT(queue),name);
+  return queue;
+}
+
+void gst_queue_chain(GstPad *pad,GstBuffer *buf) {
+  GstQueue *queue;
+  gboolean tosignal = FALSE;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  queue = GST_QUEUE(pad->parent);
+
+  /* we have to lock the queue since we span threads */
+  GST_LOCK(queue);
+
+  /* put the buffer on the head of the list */
+  /* if the queue is NULL, start a new list and make this the tail */
+  if (!queue->queue) {
+    queue->queue = g_list_prepend(queue->queue,buf);
+//    queue->tail = queue->queue;
+  /* otherwise append to the end of the list */
+  } else {
+//    queue->tail = g_list_append(queue->tail,buf);
+//    queue->tail = g_list_next(queue->tail);
+    queue->queue = g_list_append(queue->queue,buf);
+  }
+//  g_print("+");
+
+  /* if we were empty, but aren't any more, signal a condition */
+  tosignal = (queue->level_buffers++ == 0);
+
+  /* we can unlock now */
+  GST_UNLOCK(queue);
+
+  if (tosignal) {
+    g_mutex_lock(queue->waiterlock);
+    g_cond_signal(queue->waitercond);
+    g_mutex_unlock(queue->waiterlock);
+//    g_print(">");
+  }
+}
+
+void gst_queue_push(GstConnection *connection) {
+  GstQueue *queue = GST_QUEUE(connection);
+  GstBuffer *buf = NULL;
+  GList *front;
+
+  /* have to lock for thread-safety */
+  GST_LOCK(queue);
+
+  if (!queue->level_buffers) {
+    GST_UNLOCK(queue);
+    while (!queue->level_buffers) {
+      g_mutex_lock(queue->waiterlock);
+//      g_print("0");
+      g_cond_wait(queue->waitercond,queue->waiterlock);
+      g_mutex_unlock(queue->waiterlock);
+    }
+    GST_LOCK(queue);
+  }
+
+  front = queue->queue;
+  buf = (GstBuffer *)(front->data);
+  queue->queue = g_list_remove_link(queue->queue,front);
+  gst_pad_push(queue->srcpad,buf);
+  queue->level_buffers--;
+//  g_print("-");
+
+  /* unlock now */
+  GST_UNLOCK(queue);
+}
+
+
+static void gst_queue_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstQueue *queue;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_QUEUE(object));
+  queue = GST_QUEUE(object);
+
+  switch(id) {
+    default:
+      break;
+  }
+}
+
+static void gst_queue_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstQueue *queue;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_QUEUE(object));
+  queue = GST_QUEUE(object);
+
+  switch (id) {
+    case ARG_LEVEL:
+      GTK_VALUE_INT(*arg) = queue->level_buffers;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}

gst/elements/gstqueue.h

@@ -0,0 +1,84 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_QUEUE_H__
+#define __GST_QUEUE_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_queue_details;
+
+
+#define GST_TYPE_QUEUE \
+  (gst_queue_get_type())
+#define GST_QUEUE(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_QUEUE,GstQueue))
+#define GST_QUEUE_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_QUEUE,GstQueueClass))
+#define GST_IS_QUEUE(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_QUEUE))
+#define GST_IS_QUEUE_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_QUEUE)))
+
+typedef struct _GstQueue GstQueue;
+typedef struct _GstQueueClass GstQueueClass;
+
+struct _GstQueue {
+  GstConnection Connection;
+
+  GstPad *sinkpad;
+  GstPad *srcpad;
+
+  /* the queue of buffers we're keeping our grubby hands on */
+  GList *queue;
+  GList *tail;		/* have to keep track of this myself */
+
+  gint level_buffers;	/* number of buffers queued here */
+  gint level_bytes;	/* number of bytes queued here */
+  gint size_buffers;	/* size of queue in buffers */
+  gint size_bytes;	/* size of queue in bytes */
+
+  GMutex *waiterlock;	/* used when the queue is empty */
+  GCond *waitercond;
+};
+
+struct _GstQueueClass {
+  GstConnectionClass parent_class;
+};
+
+GtkType gst_queue_get_type(void);
+GstElement *gst_queue_new(gchar *name);
+void gst_queue_chain(GstPad *pad,GstBuffer *buf);
+void gst_queue_push(GstConnection *connection);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_QUEUE_H__ */

gst/elements/gstsinesrc.c

@@ -0,0 +1,269 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+#include <math.h>
+
+#include <gstsinesrc.h>
+
+
+GstElementDetails gst_sinesrc_details = {
+  "Sine-wave src",
+  "Source/Audio",
+  "Create a sine wave of a given frequency and volume",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* SineSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_VOLUME,
+  ARG_FREQ,
+  ARG_FORMAT,
+  ARG_CHANNELS,
+  ARG_FREQUENCY,
+};
+
+
+static void gst_sinesrc_class_init(GstSineSrcClass *klass);
+static void gst_sinesrc_init(GstSineSrc *sinesrc);
+static void gst_sinesrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_sinesrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+//static gboolean gst_sinesrc_change_state(GstElement *element,
+//                                          GstElementState state);
+static void gst_sinesrc_close_audio(GstSineSrc *src);
+static gboolean gst_sinesrc_open_audio(GstSineSrc *src);
+void gst_sinesrc_sync_parms(GstSineSrc *sinesrc);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_sinesrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_sinesrc_get_type(void) {
+  static GtkType sinesrc_type = 0;
+
+  if (!sinesrc_type) {
+    static const GtkTypeInfo sinesrc_info = {
+      "GstSineSrc",
+      sizeof(GstSineSrc),
+      sizeof(GstSineSrcClass),
+      (GtkClassInitFunc)gst_sinesrc_class_init,
+      (GtkObjectInitFunc)gst_sinesrc_init,
+      (GtkArgSetFunc)gst_sinesrc_set_arg,
+      (GtkArgGetFunc)gst_sinesrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    sinesrc_type = gtk_type_unique(GST_TYPE_SRC,&sinesrc_info);
+  }
+  return sinesrc_type;
+}
+
+static void
+gst_sinesrc_class_init(GstSineSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstSineSrc::volume", GTK_TYPE_DOUBLE,
+                          GTK_ARG_READWRITE, ARG_VOLUME);
+  gtk_object_add_arg_type("GstSineSrc::freq", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FREQ);
+  gtk_object_add_arg_type("GstSineSrc::format", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FORMAT);
+  gtk_object_add_arg_type("GstSineSrc::channels", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_CHANNELS);
+  gtk_object_add_arg_type("GstSineSrc::frequency", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_FREQUENCY);
+
+  gtkobject_class->set_arg = gst_sinesrc_set_arg;
+  gtkobject_class->get_arg = gst_sinesrc_get_arg;
+
+//  gstelement_class->change_state = gst_sinesrc_change_state;
+
+  gstsrc_class->push = gst_sinesrc_push;
+}
+
+static void gst_sinesrc_init(GstSineSrc *sinesrc) {
+  sinesrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(sinesrc),sinesrc->srcpad);
+
+  sinesrc->volume = 1.0;
+  sinesrc->freq = 512;
+
+  sinesrc->format = AFMT_S16_LE;
+  sinesrc->channels = 2;
+  sinesrc->frequency = 44100;
+
+  sinesrc->seq = 0;
+
+  sinesrc->sentmeta = FALSE;
+}
+
+GstElement *gst_sinesrc_new(gchar *name) {
+  GstElement *sinesrc = GST_ELEMENT(gtk_type_new(GST_TYPE_SINESRC));
+  gst_element_set_name(GST_ELEMENT(sinesrc),name);
+  return sinesrc;
+}
+
+GstElement *gst_sinesrc_new_with_fd(gchar *name,gchar *filename) {
+  GstElement *sinesrc = gst_sinesrc_new(name);
+  gtk_object_set(GTK_OBJECT(sinesrc),"location",filename,NULL);
+  return sinesrc;
+}
+
+void gst_sinesrc_push(GstSrc *src) {
+  GstSineSrc *sinesrc;
+  GstBuffer *buf;
+  gint16 *samples;
+  gint i;
+  gint volume;
+  gdouble val;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_SINESRC(src));
+  sinesrc = GST_SINESRC(src);
+
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+  GST_BUFFER_DATA(buf) = (gpointer)malloc(4096);
+  samples = (gint16*)GST_BUFFER_DATA(buf);
+  GST_BUFFER_DATA(buf) = 4096;
+
+  volume = 65535 * sinesrc->volume;
+  for (i=0;i<1024;i++) {
+    val = sin((gdouble)i/sinesrc->frequency);
+    samples[i] = val * volume;
+    samples[i+1] = samples[i];
+  }
+
+  if (!sinesrc->sentmeta) {
+    MetaAudioRaw *newmeta = g_new(MetaAudioRaw,1);
+    memcpy(newmeta,&sinesrc->meta,sizeof(MetaAudioRaw));
+    gst_buffer_add_meta(buf,GST_META(newmeta));
+    sinesrc->sentmeta = TRUE;
+  }
+
+  gst_pad_push(sinesrc->srcpad,buf);
+  g_print(">");
+}
+
+static void gst_sinesrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstSineSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SINESRC(object));
+  src = GST_SINESRC(object);
+
+  switch (id) {
+    case ARG_VOLUME:
+      src->volume = GTK_VALUE_DOUBLE(*arg);
+      break;
+    case ARG_FREQ:
+      src->freq = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_FORMAT:
+      src->format = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_CHANNELS:
+      src->channels = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_FREQUENCY:
+      src->frequency = GTK_VALUE_INT(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_sinesrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstSineSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SINESRC(object));
+  src = GST_SINESRC(object);
+
+  switch (id) {
+    case ARG_VOLUME:
+      GTK_VALUE_DOUBLE(*arg) = src->volume;
+      break;
+    case ARG_FREQ:
+      GTK_VALUE_INT(*arg) = src->freq;
+      break;
+    case ARG_FORMAT:
+      GTK_VALUE_INT(*arg) = src->format;
+      break;
+    case ARG_CHANNELS:
+      GTK_VALUE_INT(*arg) = src->channels;
+      break;
+    case ARG_FREQUENCY:
+      GTK_VALUE_INT(*arg) = src->frequency;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+/*
+static gboolean gst_sinesrc_change_state(GstElement *element,
+                                          GstElementState state) {
+  g_return_if_fail(GST_IS_SINESRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_sinesrc_open_audio(GST_SINESRC(element)))
+        return FALSE;
+      break;
+    case ~GST_STATE_RUNNING:
+      gst_sinesrc_close_audio(GST_SINESRC(element));
+      break;
+    default:
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+*/
+
+void gst_sinesrc_sync_parms(GstSineSrc *sinesrc) {
+  sinesrc->meta.format = sinesrc->format;
+  sinesrc->meta.channels = sinesrc->channels;
+  sinesrc->meta.frequency = sinesrc->frequency;
+  sinesrc->sentmeta = FALSE;
+}

gst/elements/gstsinesrc.h

@@ -0,0 +1,87 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_SINESRC_H__
+#define __GST_SINESRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+#include <gst/meta/audioraw.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_sinesrc_details;
+
+
+#define GST_TYPE_SINESRC \
+  (gst_sinesrc_get_type())
+#define GST_SINESRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_SINESRC,GstSineSrc))
+#define GST_SINESRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINESRC,GstSineSrcClass))
+#define GST_IS_SINESRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_SINESRC))
+#define GST_IS_SINESRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINESRC)))
+
+typedef struct _GstSineSrc GstSineSrc;
+typedef struct _GstSineSrcClass GstSineSrcClass;
+
+struct _GstSineSrc {
+  GstSrc src;
+
+  /* pads */
+  GstPad *srcpad;
+
+  /* parameters */
+  gdouble volume;
+  gint freq;
+
+  /* audio parameters */
+  gint format;
+  gint channels;
+  gint frequency;
+
+  gulong seq;
+
+  MetaAudioRaw meta;
+  gboolean sentmeta;
+};
+
+struct _GstSineSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_sinesrc_get_type(void);
+GstElement *gst_sinesrc_new(gchar *name);
+
+void gst_sinesrc_push(GstSrc *src);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SINESRC_H__ */

gst/gst.c

@@ -0,0 +1,60 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gst.h>
+
+extern gint _gst_trace_on;
+
+/**
+ * gst_init:
+ * @argc: pointer to application's argc
+ * @argv: pointer to application's argv
+ *
+ * Initializes the GStreamer system, setting up internal lists and loading
+ * standard plugins.
+ */
+void gst_init(int *argc,char **argv[]) {
+  GstTrace *gst_trace;
+  GstElementFactory *factory;
+
+  gtk_init(argc,argv);
+
+  if (!g_thread_supported()) g_thread_init (NULL);
+
+  _gst_type_initialize();
+  _gst_plugin_initialize();
+  _gst_buffer_initialize();
+
+  /* register some standard builtin types */
+  gst_elementfactory_register(gst_elementfactory_new(
+    "bin",gst_bin_get_type(),&gst_bin_details));
+  gst_elementfactory_register(gst_elementfactory_new(
+    "pipeline",gst_pipeline_get_type(),&gst_pipeline_details));
+  gst_elementfactory_register(gst_elementfactory_new(
+    "thread",gst_thread_get_type(),&gst_thread_details));
+
+  gst_plugin_load("libgsttypes.so");
+  gst_plugin_load("libgstelements.so");
+
+  _gst_trace_on = 0;
+  if (_gst_trace_on) {
+    gst_trace = gst_trace_new("gst.trace",1024);
+    gst_trace_set_default(gst_trace);
+  }
+}

gst/gst.h

@@ -0,0 +1,60 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_H__
+#define __GST_H__
+
+#include <gtk/gtk.h>
+
+#include <gst/gstlog.h>
+
+#include <gst/gstobject.h>
+#include <gst/gstpad.h>
+#include <gst/gstbuffer.h>
+#include <gst/gstelement.h>
+
+#include <gst/gstbin.h>
+#include <gst/gstpipeline.h>
+#include <gst/gstthread.h>
+#include <gst/gstsrc.h>
+#include <gst/gstfilter.h>
+#include <gst/gstsink.h>
+#include <gst/gstconnection.h>
+#include <gst/gsttype.h>
+#include <gst/gstplugin.h>
+#include <gst/gstutils.h>
+#include <gst/gsttrace.h>
+#include <gst/gstxml.h>
+
+#include <gst/gsttee.h>
+
+/* initialize GST */
+void gst_init(int *argc,char **argv[]);
+
+/* debugging */
+#ifndef DEBUG
+#ifdef DEBUG_ENABLED
+#define DEBUG(format,args...) g_print("DEBUG: " format, ##args)
+#else
+#define DEBUG(format,args...)
+#endif
+#endif
+
+#endif /* __GST_H__ */

gst/gstbin.c

@@ -0,0 +1,449 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gst.h>
+
+GstElementDetails gst_bin_details = { 
+  "Generic bin",
+  "Bin",
+  "Simple container object",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+void gst_bin_real_destroy(GtkObject *object);
+
+static gboolean gst_bin_change_state(GstElement *element,
+                                     GstElementState state);
+static gboolean gst_bin_change_state_type(GstBin *bin,
+                                          GstElementState state,
+                                          GtkType type);
+static gboolean gst_bin_change_state_norecurse(GstElement *element,
+                                     GstElementState state);
+
+static void gst_bin_create_plan_func(GstBin *bin);
+static void gst_bin_iterate_func(GstBin *bin);
+
+static xmlNodePtr gst_bin_save_thyself(GstElement *element,xmlNodePtr parent);
+
+/* Bin signals and args */
+enum {
+  OBJECT_ADDED,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_bin_class_init(GstBinClass *klass);
+static void gst_bin_init(GstBin *bin);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_bin_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_bin_get_type(void) {
+  static GtkType bin_type = 0;
+
+  if (!bin_type) {
+    static const GtkTypeInfo bin_info = {
+      "GstBin",
+      sizeof(GstBin),
+      sizeof(GstBinClass),
+      (GtkClassInitFunc)gst_bin_class_init,
+      (GtkObjectInitFunc)gst_bin_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    bin_type = gtk_type_unique(GST_TYPE_ELEMENT,&bin_info);
+  }
+  return bin_type;
+}
+
+static void
+gst_bin_class_init(GstBinClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+
+  gst_bin_signals[OBJECT_ADDED] =
+    gtk_signal_new("object_added",GTK_RUN_FIRST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstBinClass,object_added),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+  gtk_object_class_add_signals(gtkobject_class,gst_bin_signals,LAST_SIGNAL);
+
+  klass->change_state_type = gst_bin_change_state_type;
+  klass->create_plan = gst_bin_create_plan_func;
+  klass->iterate = gst_bin_iterate_func;
+
+  gstelement_class->change_state = gst_bin_change_state;
+  gstelement_class->save_thyself = gst_bin_save_thyself;
+
+  gtkobject_class->destroy = gst_bin_real_destroy;
+}
+
+static void gst_bin_init(GstBin *bin) {
+  bin->numchildren = 0;
+  bin->children = NULL;
+}
+
+/**
+ * gst_bin_new:
+ * @name: name of new bin
+ *
+ * Create a new bin with given name.
+ *
+ * Returns: new bin
+ */
+GstElement *gst_bin_new(gchar *name) {
+  GstElement *bin = GST_ELEMENT(gtk_type_new(GST_TYPE_BIN));
+  gst_element_set_name(GST_ELEMENT(bin),name);
+  return bin;
+}
+
+/**
+ * gst_bin_add:
+ * @bin: #GstBin to add element to
+ * @element: #GstElement to add to bin
+ *
+ * Add the given element to the bin.  Set the elements parent, and thus
+ * add a reference.
+ */
+void gst_bin_add(GstBin *bin,GstElement *element) {
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+
+  bin->children = g_list_append(bin->children,element);
+  bin->numchildren++;
+  gst_object_set_parent(GST_OBJECT(element),GST_OBJECT(bin));
+
+  if (GST_STATE_IS_SET(element,GST_STATE_COMPLETE)) {
+    if (!GST_STATE_IS_SET(bin,GST_STATE_COMPLETE))
+      gst_bin_change_state_norecurse(GST_ELEMENT(bin),GST_STATE_COMPLETE);
+  } else
+    gst_bin_change_state_norecurse(GST_ELEMENT(bin),~GST_STATE_COMPLETE);
+
+  gtk_signal_emit(GTK_OBJECT(bin),gst_bin_signals[OBJECT_ADDED],element);
+}
+
+/**
+ * gst_bin_remove:
+ * @bin: #Gstbin to remove element from
+ * @element: #GstElement to remove
+ *
+ * Remove the element from its associated bin, unparenting as well.
+ */
+void gst_bin_remove(GstBin *bin,GstElement *element) {
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+  g_return_if_fail(bin->children != NULL);
+
+  gst_object_unparent(GST_OBJECT(element));
+  bin->children = g_list_remove(bin->children,element);
+  bin->numchildren--;
+}
+
+
+static gboolean gst_bin_change_state(GstElement *element,
+                                     GstElementState state) {
+  GstBin *bin;
+  GList *children;
+  GstElement *child;
+
+//  g_print("gst_bin_change_state(\"%s\",%d);\n",
+//          gst_object_get_name(GST_OBJECT(bin)),state);
+
+  g_return_if_fail(GST_IS_BIN(element));
+  bin = GST_BIN(element);
+  g_return_if_fail(bin->numchildren != 0);
+
+//  g_print("-->\n");
+  children = bin->children;
+  while (children) {
+    child = GST_ELEMENT(children->data);
+//    g_print("gst_bin_change_state setting state on \"%s\"\n",
+//            gst_object_get_name(GST_OBJECT(child)));
+    if (!gst_element_set_state(child,state)) {
+      g_print("child %p failed to set state 0x%08x\n",child,state);
+      return FALSE;
+    }
+//    g_print("\n");
+    children = g_list_next(children);
+  }
+//  g_print("<-- \"%s\"\n",gst_object_get_name(GST_OBJECT(bin)));
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+
+
+static gboolean gst_bin_change_state_norecurse(GstElement *element,
+                                     GstElementState state) {
+  GstBin *bin;
+
+  g_return_if_fail(GST_IS_BIN(element));
+  bin = GST_BIN(element);
+  g_return_if_fail(bin->numchildren != 0);
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+
+static gboolean gst_bin_change_state_type(GstBin *bin,
+                                          GstElementState state,
+                                          GtkType type) {
+  GList *children;
+  GstElement *child;
+
+//  g_print("gst_bin_change_state_type(\"%s\",%d,%d);\n",
+//          gst_object_get_name(GST_OBJECT(bin)),state,type);
+
+  g_return_if_fail(GST_IS_BIN(bin));
+  g_return_if_fail(bin->numchildren != 0);
+
+//  g_print("-->\n");
+  children = bin->children;
+  while (children) {
+    child = GST_ELEMENT(children->data);
+    if (GST_IS_BIN(child)) {
+      if (!gst_bin_set_state_type(GST_BIN(child),state,type))
+        return FALSE;
+    } else if (GTK_CHECK_TYPE(child,type)) {
+      if (!gst_element_set_state(child,state))
+        return FALSE;
+    }
+//    g_print("\n");
+    children = g_list_next(children);
+  }
+//  g_print("<-- \"%s\"\n",gst_object_get_name(GST_OBJECT(bin)));
+  if (type == GST_TYPE_BIN)
+    gst_element_change_state(GST_ELEMENT(bin),state);
+
+  return TRUE;
+}
+
+
+gboolean gst_bin_set_state_type(GstBin *bin,
+                                GstElementState state,
+                                GtkType type) {
+  GstBinClass *oclass;
+
+//  g_print("gst_bin_set_state_type(\"%s\",%d,%d)\n",
+//          gst_object_get_name(GST_OBJECT(bin)),state,type);
+
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+
+  oclass = GST_BIN_CLASS(GTK_OBJECT(bin)->klass);
+
+  if (oclass->change_state_type)
+    (oclass->change_state_type)(bin,state,type);
+}
+
+void gst_bin_real_destroy(GtkObject *object) {
+  GstBin *bin = GST_BIN(object);
+  GList *children;
+  GstElement *child;
+
+//  g_print("in gst_bin_real_destroy()\n");
+
+  children = bin->children;
+  while (children) {
+    child = GST_ELEMENT(children->data);
+    gst_element_destroy(child);
+    children = g_list_next(children);
+  }
+
+  g_list_free(bin->children);
+}
+
+GstElement *gst_bin_get_by_name(GstBin *bin,gchar *name) {
+  GList *children;
+  GstElement *child;
+
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+  g_return_if_fail(name != NULL);
+
+  children = bin->children;
+  while (children) {
+    child = GST_ELEMENT(children->data);
+    if (!strcmp(child->name,name))
+      return child;
+    children = g_list_next(children);
+  }
+
+  return NULL;
+}
+
+GList *gst_bin_get_list(GstBin *bin) {
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+
+  return bin->children;
+}
+
+static xmlNodePtr gst_bin_save_thyself(GstElement *element,xmlNodePtr parent) {
+  GstBin *bin = GST_BIN(element);
+  xmlNodePtr childlist;
+  GList *children;
+  GstElement *child;
+
+  if (GST_ELEMENT_CLASS(parent_class)->save_thyself)
+    GST_ELEMENT_CLASS(parent_class)->save_thyself(GST_ELEMENT(bin),parent);
+
+  childlist = xmlNewChild(parent,NULL,"children",NULL);
+
+  children = bin->children;
+  while (children) {
+    child = GST_ELEMENT(children->data);
+    gst_element_save_thyself(child,childlist);
+    children = g_list_next(children);
+  }
+}
+
+void gst_bin_iterate(GstBin *bin) {
+  GstBinClass *oclass;
+
+  oclass = GST_BIN_CLASS(GTK_OBJECT(bin)->klass);
+
+  if (oclass->iterate)
+    (oclass->iterate)(bin);
+}
+
+void gst_bin_create_plan(GstBin *bin) {
+  GstBinClass *oclass;
+
+  oclass = GST_BIN_CLASS(GTK_OBJECT(bin)->klass);
+
+  if (oclass->create_plan)
+    (oclass->create_plan)(bin);
+}
+
+static void gst_bin_create_plan_func(GstBin *bin) {
+  GList *elements;
+  GstElement *element;
+  GList *pads;
+  GstPad *pad, *peer;
+  GstElement *outside;
+
+  bin->numentries = 0;
+
+  g_print("attempting to create a plan for bin %p\n",bin);
+
+  /* walk through all the elements to figure out all kinds of things */
+  elements = GST_BIN(bin)->children;
+  while (elements) {
+    element = GST_ELEMENT(elements->data);
+
+    // have to use cothreads if any elements use loop functions
+    if (element->loopfunc != NULL) {
+      if (bin->threadcontext == NULL) {
+        g_print("initializing cothread context\n");
+        bin->threadcontext = cothread_init();
+      }
+      if (element->threadstate == NULL) {
+        g_print("creating thread state for element\n");
+        element->threadstate = cothread_create(bin->threadcontext);
+        cothread_setfunc(element->threadstate,gst_element_loopfunc_wrapper, 
+                         0,element);
+      }
+    }
+
+    /* we need to find all the entry points into the bin */
+    if (GST_IS_SRC(element)) {
+      g_print("element '%s' is a source entry point for the bin\n",
+              gst_element_get_name(GST_ELEMENT(element)));
+      bin->entries = g_list_prepend(bin->entries,element);
+      bin->numentries++;
+    } else {
+      /* go through the list of pads to see if there's a Connection */
+      pads = gst_element_get_pad_list(element);
+      while (pads) {
+        pad = GST_PAD(pads->data);
+        /* we only worry about sink pads */
+        if (gst_pad_get_direction(pad) == GST_PAD_SINK) {
+          /* get the pad's peer */
+          peer = gst_pad_get_peer(pad);
+          if (!peer) break;
+          /* get the parent of the peer of the pad */
+          outside = GST_ELEMENT(gst_pad_get_parent(peer));
+          if (!outside) break;
+          /* if it's a connection and it's not ours... */
+          if (GST_IS_CONNECTION(outside) &&
+              (gst_object_get_parent(GST_OBJECT(outside)) != GST_OBJECT(bin))) {
+            g_print("element '%s' is the external source Connection \
+for internal element '%s'\n",
+                    gst_element_get_name(GST_ELEMENT(outside)),
+                    gst_element_get_name(GST_ELEMENT(element)));
+            bin->entries = g_list_prepend(bin->entries,outside);
+            bin->numentries++;
+          }
+        }
+        pads = g_list_next(pads);
+      }
+    }
+    elements = g_list_next(elements);
+  }
+  g_print("have %d entries into bin\n",bin->numentries);
+}
+
+void gst_bin_iterate_func(GstBin *bin) {
+  GList *entries;
+  GstElement *entry;
+   
+  g_return_if_fail(bin != NULL);
+  g_return_if_fail(GST_IS_BIN(bin));
+//  g_return_if_fail(GST_FLAG_IS_SET(thread,GST_STATE_RUNNING));
+  g_return_if_fail(bin->numentries > 0);
+  
+  entries = bin->entries;  
+
+  g_print("iterating\n");
+
+  while (entries) {
+    entry = GST_ELEMENT(entries->data);
+    if (GST_IS_SRC(entry))
+      gst_src_push(GST_SRC(entry));
+    else if (GST_IS_CONNECTION(entry))
+      gst_connection_push(GST_CONNECTION(entry));
+    else
+      g_assert_not_reached();
+    entries = g_list_next(entries);
+  }
+//  g_print(",");
+}

gst/gstbin.h

@@ -0,0 +1,106 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_BIN_H__
+#define __GST_BIN_H__
+
+
+#include <gst/gstelement.h>
+#include <gst/gstsrc.h>
+#include <gst/gstconnection.h>
+#include <gst/cothreads.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+GstElementDetails gst_bin_details;
+
+
+#define GST_TYPE_BIN \
+  (gst_bin_get_type())
+#define GST_BIN(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_BIN,GstBin))
+#define GST_BIN_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_BIN,GstBinClass))
+#define GST_IS_BIN(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_BIN))
+#define GST_IS_BIN_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_BIN)))
+
+typedef struct _GstBin GstBin;
+typedef struct _GstBinClass GstBinClass;
+
+struct _GstBin {
+  GstElement element;
+
+  gint numchildren;
+  GList *children;
+
+  GList *entries;
+  gint numentries;
+
+  cothread_context *threadcontext;
+};
+
+struct _GstBinClass {
+  GstElementClass parent_class;
+
+  void (*object_added) (GstObject *object,GstObject *child);
+
+  /* change the state of elements of the given type */
+  gboolean (*change_state_type) (GstBin *bin,
+                                 GstElementState state,
+                                 GtkType type);
+
+  /* create a plan for the execution of the bin */
+  void (*create_plan) (GstBin *bin);
+
+  /* run a full iteration of operation */
+  void (*iterate) (GstBin *bin);
+};
+
+GtkType gst_bin_get_type(void);
+GstElement *gst_bin_new(gchar *name);
+
+/* add and remove elements from the bin */
+void gst_bin_add(GstBin *bin,GstElement *element);
+void gst_bin_remove(GstBin *bin,GstElement *element);
+
+/* retrieve a single element or the while list of children */
+GstElement *gst_bin_get_by_name(GstBin *bin,gchar *name);
+GList *gst_bin_get_list(GstBin *bin);
+
+/* set the state for only elements of the given type */
+gboolean gst_bin_set_state_type(GstBin *bin,
+                                GstElementState state,
+                                GtkType type);
+
+void gst_bin_iterate(GstBin *bin);
+void gst_bin_create_plan(GstBin *bin);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_BIN_H__ */     
+

gst/gstbuffer.c

@@ -0,0 +1,241 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstbuffer.h>
+
+//#define DEBUG(format,args...) g_print("DEBUG: " format, ##args)
+#define DEBUG(format,args...)
+
+
+
+GMemChunk *_gst_buffer_chunk;
+
+
+void _gst_buffer_initialize() {
+  _gst_buffer_chunk = g_mem_chunk_new("GstBuffer",sizeof(GstBuffer),
+    sizeof(GstBuffer)*16,G_ALLOC_AND_FREE);
+}
+
+
+/**
+ * gst_buffer_new:
+ *
+ * Create a new buffer.
+ *
+ * Returns: new buffer
+ */
+GstBuffer *gst_buffer_new() {
+  GstBuffer *buffer;
+
+  buffer = g_mem_chunk_alloc(_gst_buffer_chunk);
+  DEBUG("BUF: allocating new buffer %p\n",buffer);
+
+//  g_print("allocating new mutex\n");
+  buffer->lock = g_mutex_new();
+#ifdef HAVE_ATOMIC_H
+  atomic_set(&buffer->refcount,1);
+#else
+  buffer->refcount = 1;
+#endif
+  buffer->flags = 0;
+  buffer->type = 0;
+  buffer->data = NULL;
+  buffer->size = 0;
+  buffer->maxsize = 0;
+  buffer->offset = 0;
+  buffer->timestamp = 0;
+  buffer->metas = NULL;
+  buffer->parent = NULL;
+  return buffer;
+}
+
+
+/**
+ * gst_buffer_create_sub:
+ * @parent: parent buffer
+ * @offset: offset into parent buffer
+ * @size: size of new subbuffer
+ *
+ * Creates a sub-buffer from the parent at a given offset.
+ *
+ * Returns: new buffer
+ */
+GstBuffer *gst_buffer_create_sub(GstBuffer *parent,guint32 offset,guint32 size) {
+  GstBuffer *buffer;
+
+  g_return_if_fail(parent != NULL);
+  g_return_if_fail(size > 0);
+  g_return_if_fail((offset+size) <= parent->size);
+
+  buffer = g_mem_chunk_alloc(_gst_buffer_chunk);
+  DEBUG("BUF: allocating new subbuffer %p, parent %p\n",buffer,parent);
+
+  buffer->lock = g_mutex_new();
+#ifdef HAVE_ATOMIC_H
+  atomic_set(&buffer->refcount,1);
+#else
+  buffer->refcount = 1;
+#endif
+
+  // copy flags and type from parent, for lack of better
+  buffer->flags = parent->flags;
+  buffer->type = parent->type;
+
+  // set the data pointer, size, offset, and maxsize
+  buffer->data = parent->data + offset;
+  buffer->size = size;
+  buffer->offset = offset;
+  buffer->maxsize = parent->size - offset;
+
+  // again, for lack of better, copy parent's timestamp
+  buffer->timestamp = parent->timestamp;
+
+  // no metas, this is sane I think
+  buffer->metas = NULL;
+
+  // set parentage and reference the parent
+  buffer->parent = parent;
+  gst_buffer_ref(parent);
+
+  // return the new subbuffer
+  return buffer;
+}
+
+
+void gst_buffer_destroy(GstBuffer *buffer) {
+  GSList *metas;
+
+  g_return_if_fail(buffer != NULL);
+
+  if (buffer->parent != NULL)
+    DEBUG("BUF: freeing subbuffer %p\n",buffer);
+  else
+    DEBUG("BUF: freeing buffer %p\n",buffer);
+
+  // free the data only if there is some, DONTFREE isn't set, and not sub
+  if (GST_BUFFER_DATA(buffer) &&
+      !GST_BUFFER_FLAG_IS_SET(buffer,GST_BUFFER_DONTFREE) &&
+      (buffer->parent == NULL)) {
+    g_free(GST_BUFFER_DATA(buffer));
+//    g_print("freed data in buffer\n");
+  }
+
+  // unreference any metadata attached to this buffer
+  metas = buffer->metas;
+  while (metas) {
+    gst_meta_unref((GstMeta *)(metas->data));
+    metas = g_slist_next(metas);
+  }
+  g_slist_free(buffer->metas);
+
+  // unreference the parent if there is one
+  if (buffer->parent != NULL)
+    gst_buffer_unref(buffer->parent);
+
+  g_mutex_free(buffer->lock);
+//  g_print("freed mutex\n");
+
+  // remove it entirely from memory
+  g_mem_chunk_free(_gst_buffer_chunk,buffer);
+}
+
+void gst_buffer_ref(GstBuffer *buffer) {
+  g_return_if_fail(buffer != NULL);
+
+  DEBUG("BUF: referencing buffer %p\n",buffer);
+
+#ifdef HAVE_ATOMIC_H
+  g_return_if_fail(atomic_read(&(buffer->refcount)) > 0);
+  atomic_inc(&(buffer->refcount))
+#else
+  g_return_if_fail(buffer->refcount > 0);
+  GST_BUFFER_LOCK(buffer);
+  buffer->refcount++;
+  GST_BUFFER_UNLOCK(buffer);
+#endif
+}
+
+void gst_buffer_ref_by_count(GstBuffer *buffer,int count) {
+  g_return_if_fail(buffer != NULL);
+  g_return_if_fail(count > 0);
+
+#ifdef HAVE_ATOMIC_H
+  g_return_if_fail(atomic_read(&(buffer->refcount)) > 0);
+  atomic_add(count,&(buffer->refcount))
+#else
+  g_return_if_fail(buffer->refcount > 0);
+  GST_BUFFER_LOCK(buffer);
+  buffer->refcount += count;
+  GST_BUFFER_UNLOCK(buffer);
+#endif
+}
+
+void gst_buffer_unref(GstBuffer *buffer) {
+  int zero;
+
+  g_return_if_fail(buffer != NULL);
+
+  DEBUG("BUF: unreferencing buffer %p\n",buffer);
+
+#ifdef HAVE_ATOMIC_H
+  g_return_if_fail(atomic_read(&(buffer->refcount)) > 0);
+  zero = atomic_dec_and_test(&(buffer->refcount))
+#else
+  g_return_if_fail(buffer->refcount > 0);
+  GST_BUFFER_LOCK(buffer);
+  buffer->refcount--;
+  zero = (buffer->refcount == 0);
+  GST_BUFFER_UNLOCK(buffer);
+#endif
+
+  /* if we ended up with the refcount at zero, destroy the buffer */
+  if (zero)
+    gst_buffer_destroy(buffer);
+}
+
+void gst_buffer_add_meta(GstBuffer *buffer,GstMeta *meta) {
+  g_return_if_fail(buffer != NULL);
+  g_return_if_fail(meta != NULL);
+
+  gst_meta_ref(meta);
+  buffer->metas = g_slist_append(buffer->metas,meta);
+}
+
+GSList *gst_buffer_get_metas(GstBuffer *buffer) {
+  g_return_if_fail(buffer != NULL);
+
+  return buffer->metas;
+}
+
+GstMeta *gst_buffer_get_first_meta(GstBuffer *buffer) {
+  g_return_if_fail(buffer != NULL);
+
+  if (buffer->metas == NULL)
+    return NULL;
+  return GST_META(buffer->metas->data);
+}
+
+void gst_buffer_remove_meta(GstBuffer *buffer,GstMeta *meta) {
+  g_return_if_fail(buffer != NULL);
+  g_return_if_fail(meta != NULL);
+
+  buffer->metas = g_slist_remove(buffer->metas,meta);
+  gst_meta_unref(meta);
+}

gst/gstbuffer.h

@@ -0,0 +1,128 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_BUFFER_H__
+#define __GST_BUFFER_H__
+
+#include <gst/gstmeta.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_BUFFER(buf) ((GstBuffer *)(buf))
+
+
+#define GST_BUFFER_FLAGS(buf) \
+  (GST_BUFFER(buf)->flags)
+#define GST_BUFFER_FLAG_IS_SET(buf,flag) \
+  (GST_BUFFER_FLAGS(buf) & (flag))
+#define GST_BUFFER_FLAG_SET(buf,flag) \
+  G_STMT_START{ (GST_BUFFER_FLAGS(buf) |= (flag)); }G_STMT_END
+#define GST_BUFFER_FLAG_UNSET(buf,flag) \
+  G_STMT_START{ (GST_BUFFER_FLAGS(buf) &= ~(flag)); }G_STMT_END
+
+
+#define GST_BUFFER_TYPE(buf)		(GST_BUFFER(buf)->type)
+#define GST_BUFFER_DATA(buf)		(GST_BUFFER(buf)->data)
+#define GST_BUFFER_SIZE(buf)		(GST_BUFFER(buf)->size)
+#define GST_BUFFER_OFFSET(buf)		(GST_BUFFER(buf)->offset)
+#define GST_BUFFER_MAXSIZE(buf)		(GST_BUFFER(buf)->maxsize)
+#define GST_BUFFER_TIMESTAMP(buf)	(GST_BUFFER(buf)->timestamp)
+
+
+#define GST_BUFFER_LOCK(buf)	(g_mutex_lock(GST_BUFFER(buf)->lock))
+#define GST_BUFFER_TRYLOCK(buf)	(g_mutex_trylock(GST_BUFFER(buf)->lock))
+#define GST_BUFFER_UNLOCK(buf)	(g_mutex_unlock(GST_BUFFER(buf)->lock))
+
+
+typedef enum {
+  GST_BUFFER_READONLY		= (1 << 0),
+  GST_BUFFER_EOS		= (1 << 1),
+  GST_BUFFER_ORIGINAL		= (1 << 2),
+  GST_BUFFER_DONTFREE		= (1 << 3),
+} GstBufferFlags;
+
+
+typedef struct _GstBuffer GstBuffer;
+
+struct _GstBuffer {
+  /* locking */
+  GMutex *lock;
+
+  /* refcounting */
+#ifdef HAVE_ATOMIC_H
+  atomic_t refcount;
+#else
+  int refcount;
+#endif
+
+  /* data type of this buffer */
+  guint16 type;
+  /* flags */
+  guint16 flags;
+
+  /* pointer to data, its size, and offset in original source if known */
+  guchar *data;
+  guint32 size;
+  guint32 maxsize;
+  guint32 offset;
+
+  /* timestamp */
+  guint64 timestamp;
+  /* max age */
+  guint64 maxage;
+
+  /* pointer to metadata, is really lame right now */
+  GSList *metas;
+
+  /* subbuffer support, who's my parent? */
+  GstBuffer *parent;
+};
+
+/* creating a new buffer from scratch */
+GstBuffer *gst_buffer_new();
+
+/* creating a subbuffer */
+GstBuffer *gst_buffer_create_sub(GstBuffer *parent,guint32 offset,guint32 size);
+
+/* refcounting */
+void gst_buffer_ref(GstBuffer *buffer);
+void gst_buffer_ref_by_count(GstBuffer *buffer,int count);
+void gst_buffer_unref(GstBuffer *buffer);
+
+/* destroying the buffer */
+void gst_buffer_destroy(GstBuffer *buffer);
+
+/* add, retrieve, and remove metadata from the buffer */
+void gst_buffer_add_meta(GstBuffer *buffer,GstMeta *meta);
+GstMeta *gst_buffer_get_first_meta(GstBuffer *buffer);
+GSList *gst_buffer_get_metas(GstBuffer *buffer);
+void gst_buffer_remove_meta(GstBuffer *buffer,GstMeta *meta);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_BUFFER_H__ */

gst/gstconnection.c

@@ -0,0 +1,99 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstconnection.h>
+
+
+/* Connection signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_connection_class_init(GstConnectionClass *klass);
+static void gst_connection_init(GstConnection *connection);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_connection_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_connection_get_type(void) {
+  static GtkType connection_type = 0;
+
+  if (!connection_type) {
+    static const GtkTypeInfo connection_info = {
+      "GstConnection",
+      sizeof(GstConnection),
+      sizeof(GstConnectionClass),
+      (GtkClassInitFunc)gst_connection_class_init,
+      (GtkObjectInitFunc)gst_connection_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    connection_type = gtk_type_unique(GST_TYPE_ELEMENT,&connection_info);
+  }
+  return connection_type;
+}
+
+static void
+gst_connection_class_init(GstConnectionClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+}
+
+static void gst_connection_init(GstConnection *connection) {
+}
+
+/**
+ * gst_connection_new:
+ * @name: name of new connection
+ *
+ * Create a new connection with given name.
+ *
+ * Returns: new connection
+ */
+GstElement *gst_connection_new(gchar *name) {
+  GstElement *connection = GST_ELEMENT(gtk_type_new(gst_connection_get_type()));
+  gst_element_set_name(GST_ELEMENT(connection),name);
+  return connection;
+}
+
+void gst_connection_push(GstConnection *connection) {
+  GstConnectionClass *oclass;
+
+  g_return_if_fail(connection != NULL);
+  g_return_if_fail(GST_IS_CONNECTION(connection));
+
+  oclass = (GstConnectionClass *)(GTK_OBJECT(connection)->klass);
+
+  g_return_if_fail(oclass->push != NULL);
+
+  (oclass->push)(connection);
+}

gst/gstconnection.h

@@ -0,0 +1,69 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_CONNECTION_H__
+#define __GST_CONNECTION_H__
+
+
+#include <gst/gstelement.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_CONNECTION \
+  (gst_connection_get_type())
+#define GST_CONNECTION(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_CONNECTION,GstConnection))
+#define GST_CONNECTION_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_CONNECTION,GstConnectionClass))
+#define GST_IS_CONNECTION(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_CONNECTION))
+#define GST_IS_CONNECTION_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_CONNECTION)))
+
+typedef struct _GstConnection GstConnection;
+typedef struct _GstConnectionClass GstConnectionClass;
+
+struct _GstConnection {
+  GstElement element;
+};
+
+struct _GstConnectionClass {
+  GstElementClass parent_class;
+
+  /* push function */
+  void (*push) (GstConnection *connection);
+};
+
+GtkType gst_connection_get_type(void);
+GstElement *gst_connection_new(gchar *name);
+
+void gst_connection_push(GstConnection *connection);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_CONNECTION_H__ */

gst/gstelement.c

@@ -0,0 +1,507 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstelement.h>
+
+
+/* Element signals and args */
+enum {
+  STATE_CHANGE,
+  NEW_PAD,
+  NEW_GHOST_PAD,
+  ERROR,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_element_class_init(GstElementClass *klass);
+static void gst_element_init(GstElement *element);
+static void gst_element_real_destroy(GtkObject *object);
+
+
+static GstObjectClass *parent_class = NULL;
+static guint gst_element_signals[LAST_SIGNAL] = { 0 };
+
+GtkType gst_element_get_type(void) {
+  static GtkType element_type = 0;
+
+  if (!element_type) {
+    static const GtkTypeInfo element_info = {
+      "GstElement",
+      sizeof(GstElement),
+      sizeof(GstElementClass),
+      (GtkClassInitFunc)gst_element_class_init,
+      (GtkObjectInitFunc)gst_element_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    element_type = gtk_type_unique(GST_TYPE_OBJECT,&element_info);
+  }
+  return element_type;
+}
+
+static void gst_element_class_init(GstElementClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_OBJECT);
+
+  gst_element_signals[STATE_CHANGE] =
+    gtk_signal_new("state_change",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstElementClass,state_change),
+                   gtk_marshal_NONE__INT,GTK_TYPE_NONE,1,
+                   GTK_TYPE_INT);
+  gst_element_signals[NEW_PAD] =
+    gtk_signal_new("new_pad",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstElementClass,new_pad),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+  gst_element_signals[NEW_GHOST_PAD] =
+    gtk_signal_new("new_ghost_pad",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstElementClass,new_ghost_pad),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+  gst_element_signals[ERROR] =
+    gtk_signal_new("error",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstElementClass,error),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+
+
+  gtk_object_class_add_signals(gtkobject_class,gst_element_signals,LAST_SIGNAL);
+
+  klass->start = NULL;
+  klass->stop = NULL;
+  klass->change_state = gst_element_change_state;
+
+  gtkobject_class->destroy = gst_element_real_destroy;
+}
+
+static void gst_element_init(GstElement *element) {
+  element->state = 0;
+  element->numpads = 0;
+  element->pads = NULL;
+  element->loopfunc = NULL;
+}
+
+/**
+ * gst_element_new:
+ *
+ * Create a new element.
+ *
+ * Returns: new element
+ */
+GstElement *gst_element_new() {
+  return GST_ELEMENT(gtk_type_new(GST_TYPE_ELEMENT));
+}
+
+/**
+ * gst_element_add_pad:
+ * @element: element to add pad to
+ * @pad: pad to add
+ *
+ * Add a pad (connection point) to the element, setting the parent of the
+ * pad to the element (and thus adding a reference).
+ */
+void gst_element_add_pad(GstElement *element,GstPad *pad) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  /* set the pad's parent */
+  gst_pad_set_parent(pad,GST_OBJECT(element));
+
+  /* add it to the list */
+  element->pads = g_list_append(element->pads,pad);
+  element->numpads++;
+
+  /* emit the NEW_PAD signal */
+//  g_print("emitting NEW_PAD signal, \"%s\"!\n",gst_pad_get_name(pad));
+  gtk_signal_emit(GTK_OBJECT(element),gst_element_signals[NEW_PAD],pad);
+}
+
+/**
+ * gst_element_add_ghost_pad:
+ * @element: element to add ghost pad to
+ * @pad: ghost pad to add
+ *
+ * Add a ghost pad to the element, setting the ghost parent of the pad to
+ * the element (and thus adding a reference).
+ */
+void gst_element_add_ghost_pad(GstElement *element,GstPad *pad) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  /* set the pad's parent */
+  gst_pad_add_ghost_parent(pad,GST_OBJECT(element));
+
+  /* add it to the list */
+  element->pads = g_list_append(element->pads,pad);
+  element->numpads++;
+
+  /* emit the NEW_PAD signal */
+  gtk_signal_emit(GTK_OBJECT(element),gst_element_signals[NEW_GHOST_PAD],pad);
+}
+
+/**
+ * gst_element_get_pad:
+ * @element: element to find pad of
+ * @name: name of pad to retrieve
+ *
+ * Retrieve a pad from the element by name.
+ *
+ * Returns: requested pad if found, otherwise NULL.
+ */
+GstPad *gst_element_get_pad(GstElement *element,gchar *name) {
+  GList *walk;
+
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+  if (name == NULL)
+    return NULL;
+  if (!element->numpads)
+    return NULL;
+
+  walk = element->pads;
+  while (walk) {
+    if (!strcmp(((GstPad *)(walk->data))->name,name))
+      return (GstPad *)(walk->data);
+    walk = g_list_next(walk);
+  }
+
+  return NULL;
+}
+
+/**
+ * gst_element_get_pad_list:
+ * @element: element to get pads of
+ *
+ * Retrieve a list of the pads associated with the element.
+ *
+ * Returns: <type>GList</type> of pads
+ */
+GList *gst_element_get_pad_list(GstElement *element) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+
+  return element->pads;
+}
+
+/**
+ * gst_element_connect:
+ * @src: element containing source pad
+ * @srcpadname: name of pad in source element
+ * @dest: element containing destination pad
+ * @destpadname: name of pad in destination element
+ *
+ * Connect the two named pads of the source and destination elements.
+ * Side effect is that if one of the pads has no parent, it becomes a
+ * child of the parent of the other element.  If they have different
+ * parents, the connection fails.
+ */
+void gst_element_connect(GstElement *src,gchar *srcpadname,
+                         GstElement *dest,gchar *destpadname) {
+  GstPad *srcpad,*destpad;
+  GstObject *srcparent,*destparent;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(src));
+  g_return_if_fail(srcpadname != NULL);
+  g_return_if_fail(dest != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(dest));
+  g_return_if_fail(destpadname != NULL);
+
+  srcpad = gst_element_get_pad(src,srcpadname);
+  destpad = gst_element_get_pad(dest,destpadname);
+
+  g_return_if_fail(srcpad != NULL);
+  g_return_if_fail(destpad != NULL);
+
+  srcparent = gst_object_get_parent(GST_OBJECT(src));
+  destparent = gst_object_get_parent(GST_OBJECT(dest));
+  /* we can't do anything if neither have parents */
+  if ((srcparent == NULL) && (destparent == NULL))
+    return;
+
+  /* and we have to make sure that they have the same parents... */
+  if ((srcparent == NULL) && (destparent == NULL)) {
+    if (srcparent != destparent)
+      return;
+  }
+}
+
+void gst_element_error(GstElement *element,gchar *error) {
+  g_error("error in element '%s': %s\n",element->name,error);
+
+  gtk_signal_emit(GTK_OBJECT(element),gst_element_signals[ERROR],error);
+}
+
+
+/**
+ * gst_element_set_state:
+ * @element: element to change state of
+ * @state: new element state
+ *
+ * Sets the state of the element, but more importantly fires off a signal
+ * indicating the new state.  You can clear state by simply prefixing the
+ * GstElementState value with ~, it will be detected and used to turn off
+ * that bit.
+ *
+ * Returns: whether or not the state was successfully set.
+ */
+gboolean gst_element_set_state(GstElement *element,GstElementState state) {
+  GstElementClass *oclass;
+  gboolean stateset = FALSE;
+
+//  g_print("gst_element_set_state(\"%s\",%08lx)\n",
+//          element->name,state);
+
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+
+  oclass = GST_ELEMENT_CLASS(GTK_OBJECT(element)->klass);
+
+  if (oclass->change_state)
+    stateset = (oclass->change_state)(element,state);
+
+  /* if a state *set* failed, unset it immediately */
+/*
+  if (!(state & GST_STATE_MAX) && !stateset) {
+    g_print("set state failed miserably, forcing unset\n");
+    if (oclass->change_state)
+      stateset = (oclass->change_state)(element,~state);
+    return FALSE;
+  }*/
+
+  return stateset;
+}
+
+/* class function to set the state of a simple element */
+gboolean gst_element_change_state(GstElement *element,
+                                  GstElementState state) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+
+//  g_print("gst_element_change_state(\"%s\",%d)\n",
+//          element->name,state);
+
+  /* deal with the inverted state */
+//  g_print("changing element state, was %08lx",GST_STATE(element));
+  if (state & GST_STATE_MAX)
+    GST_STATE_UNSET(element,~state);
+  else
+    GST_STATE_SET(element,state);
+//  g_print(", is now %08lx\n",GST_STATE(element));
+  gtk_signal_emit(GTK_OBJECT(element),gst_element_signals[STATE_CHANGE],
+                  state);
+}
+
+/**
+ * gst_element_set_name:
+ * @element: GstElement to set name of
+ * @name: new name of element
+ *
+ * Set the name of the element, getting rid of the old name if there was
+ * one.
+ */
+void gst_element_set_name(GstElement *element,gchar *name) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+  g_return_if_fail(name != NULL);
+
+  if (element->name != NULL)
+    g_free(element->name);
+
+  element->name = g_strdup(name);
+}
+
+/**
+ * gst_element_get_name:
+ * @element: GstElement to set name of
+ *
+ * Get the name of the element.
+ *
+ * Returns: name of the element
+ */
+gchar *gst_element_get_name(GstElement *element) {
+  g_return_if_fail(element != NULL);
+  g_return_if_fail(GST_IS_ELEMENT(element));
+
+  return element->name;
+}
+
+static void gst_element_real_destroy(GtkObject *object) {
+  GstElement *element = GST_ELEMENT(object);
+  GList *pads;
+  GstPad *pad;
+
+//  g_print("in gst_element_real_destroy()\n");
+
+  if (element->name)
+    g_free(element->name);
+  
+  pads = element->pads;
+  while (pads) {
+    pad = GST_PAD(pads->data);
+    gst_pad_destroy(pad);
+    pads = g_list_next(pads);
+  }
+
+  g_list_free(element->pads);
+}
+
+
+static gchar *_gst_element_type_names[] = {
+  "invalid",
+  "none",
+  "char",
+  "uchar",
+  "bool",
+  "int",
+  "uint",
+  "long",
+  "ulong",
+  "float",
+  "double",
+  "string",
+};
+
+xmlNodePtr gst_element_save_thyself(GstElement *element,xmlNodePtr parent) {
+  xmlNodePtr self, arglist;
+  GList *pads;
+  GstPad *pad;
+  GstElementClass *oclass;
+  GstElementFactory *factory;
+  GtkType type;
+
+  oclass = GST_ELEMENT_CLASS(GTK_OBJECT(element)->klass);
+
+  self = xmlNewChild(parent,NULL,"element",NULL);
+  xmlNewChild(self,NULL,"name",element->name);
+  if (oclass->elementfactory != NULL) {
+    factory = (GstElementFactory *)oclass->elementfactory;
+    xmlNewChild(self,NULL,"type",factory->name);
+    xmlNewChild(self,NULL,"version",factory->details->version);
+  }
+
+  pads = element->pads;
+  while (pads) {
+    pad = GST_PAD(pads->data);
+    // figure out if it's a direct pad or a ghostpad
+    if (pad->parent == element)
+      gst_pad_save_thyself(pad,self);
+    pads = g_list_next(pads);
+  }
+
+  // output all args to the element
+  arglist = xmlNewChild(self,NULL,"args",NULL);
+  type = GTK_OBJECT_TYPE(element);
+  while (type != GTK_TYPE_INVALID) {
+    GtkArg *args;
+    guint32 *flags;
+    guint num_args,i;
+
+    args = gtk_object_query_args(type,&flags,&num_args);
+    for (i=0;i<num_args;i++) {
+      if ((args[i].type > GTK_TYPE_NONE) &&
+          (args[i].type <= GTK_TYPE_STRING) &&
+          (flags && GTK_ARG_READABLE)) {
+        xmlNodePtr arg;
+        gtk_object_getv(GTK_OBJECT(element),1,&args[i]);
+        arg = xmlNewChild(arglist,NULL,"arg",NULL);
+        xmlNewChild(arg,NULL,"name",args[i].name);
+        switch (args[i].type) {
+          case GTK_TYPE_CHAR:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%c",GTK_VALUE_CHAR(args[i])));
+            break;
+          case GTK_TYPE_UCHAR:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%d",GTK_VALUE_UCHAR(args[i])));
+            break;
+          case GTK_TYPE_BOOL:
+            xmlNewChild(arg,NULL,"value",
+                        GTK_VALUE_BOOL(args[1])?"true":"false");
+            break;
+          case GTK_TYPE_INT:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%d",GTK_VALUE_INT(args[i])));
+            break;
+          case GTK_TYPE_LONG:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%ld",GTK_VALUE_LONG(args[i])));
+            break;
+          case GTK_TYPE_ULONG:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%ld",GTK_VALUE_ULONG(args[i])));
+            break;
+          case GTK_TYPE_FLOAT:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%f",GTK_VALUE_FLOAT(args[i])));
+            break;
+          case GTK_TYPE_DOUBLE:
+            xmlNewChild(arg,NULL,"value",
+                        g_strdup_printf("%lf",GTK_VALUE_DOUBLE(args[i])));
+            break;
+          case GTK_TYPE_STRING:
+            xmlNewChild(arg,NULL,"value",GTK_VALUE_STRING(args[i]));
+            break;
+        }
+      }
+    }
+    type = gtk_type_parent(type);
+  }
+
+  if (oclass->save_thyself)
+    (oclass->save_thyself)(element,self);
+
+  return self;
+}
+
+void gst_element_set_manager(GstElement *element,GstElement *manager) {
+  element->manager = manager;
+}
+
+GstElement *gst_element_get_manager(GstElement *element) {
+  return element->manager;
+}
+
+// note that this casts a char ** to a GstElement *.  Ick.
+int gst_element_loopfunc_wrapper(int argc,char **argv) {
+  GstElement *element = GST_ELEMENT(argv);
+  element->loopfunc(element);
+}
+
+void gst_element_set_loop_function(GstElement *element,
+                                   GstElementLoopFunction loop) {
+  element->loopfunc = loop;
+  if (element->threadstate != NULL)
+    cothread_setfunc(element->threadstate,gst_element_loopfunc_wrapper,
+                     0,element);
+}

gst/gstelement.h

@@ -0,0 +1,194 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_ELEMENT_H__
+#define __GST_ELEMENT_H__
+
+
+#include <gnome-xml/parser.h>
+#include <gst/gstlog.h>
+#include <gst/gstobject.h>
+#include <gst/gstpad.h>
+#include <gst/gstbuffer.h>
+#include <gst/cothreads.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+typedef enum {
+  GST_STATE_COMPLETE    = (1 << 0),
+  GST_STATE_RUNNING     = (1 << 1),
+  GST_STATE_DISCOVERY   = (1 << 2),
+  GST_STATE_PREROLL     = (1 << 3),
+
+  GST_STATE_PLAYING	= (1 << 4),
+  GST_STATE_PAUSED	= (1 << 5),
+
+  GST_STATE_MAX		= (1 << 15),
+} GstElementState;
+
+
+#define GST_STATE(obj)			(GST_ELEMENT(obj)->state)
+#define GST_STATE_IS_SET(obj,flag)	(GST_STATE (obj) & (flag))
+#define GST_STATE_SET(obj,flag) \
+G_STMT_START{ (GST_STATE (obj) |= (flag)); \
+gst_info("set '%s' state %d\n",gst_element_get_name(obj),flag); \
+}G_STMT_END
+#define GST_STATE_UNSET(obj,flag) \
+G_STMT_START{ (GST_STATE (obj) &= ~(flag)); \
+gst_info("unset '%s' state %d\n",gst_element_get_name(obj),flag); \
+}G_STMT_END
+
+
+#define GST_TYPE_ELEMENT \
+  (gst_element_get_type())
+#define GST_ELEMENT(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_ELEMENT,GstElement))
+#define GST_ELEMENT_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ELEMENT,GstElementClass))
+#define GST_IS_ELEMENT(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_ELEMENT))
+#define GST_IS_ELEMENT_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENT)))
+
+typedef struct _GstElement GstElement;
+typedef struct _GstElementClass GstElementClass;
+typedef struct _GstElementDetails GstElementDetails;
+typedef struct _GstElementFactory GstElementFactory;
+
+typedef void (*GstElementLoopFunction) (GstElement *element);
+
+struct _GstElement {
+  GstObject object;
+
+  gchar *name;
+
+  guint16 state;
+
+  GstElementLoopFunction loopfunc;
+  cothread_state *threadstate;
+
+  guint16 numpads;
+  GList *pads;
+
+  GstElement *manager;
+};
+
+struct _GstElementClass {
+  GstObjectClass parent_class;
+
+  /* the elementfactory that created us */
+  GstElementFactory *elementfactory;
+
+  /* signal callbacks */
+  void (*state_change) (GstElement *element,GstElementState state);
+  void (*new_pad) (GstElement *element,GstPad *pad);
+  void (*new_ghost_pad) (GstElement *element,GstPad *pad);
+  void (*error) (GstElement *element,gchar *error);
+
+  /* events */
+  gboolean (*start) (GstElement *element,GstElementState state);
+  gboolean (*stop) (GstElement *element);
+
+  /* change the element state */
+  gboolean (*change_state) (GstElement *element,GstElementState state);
+
+  /* create or read XML representation of self */
+  xmlNodePtr (*save_thyself)(GstElement *element,xmlNodePtr parent);
+  void (*restore_thyself)(GstElement *element,xmlNodePtr *self);
+};
+
+struct _GstElementDetails {
+  gchar *longname;              /* long, english name */
+  gchar *class;                 /* type of element, kinda */
+  gchar *description;           /* insights of one form or another */
+  gchar *version;               /* version of the element */
+  gchar *author;                /* who wrote this thing? */
+  gchar *copyright;             /* copyright details (year, etc.) */
+};
+
+struct _GstElementFactory {
+  gchar *name;
+  GtkType type;
+
+  GstElementDetails *details;
+};
+
+
+GtkType gst_element_get_type(void);
+GstElement *gst_element_new(void);
+
+void gst_element_set_loop_function(GstElement *element,
+                                   GstElementLoopFunction loop);
+
+void gst_element_set_name(GstElement *element,gchar *name);
+gchar *gst_element_get_name(GstElement *element);
+
+void gst_element_set_manager(GstElement *element,GstElement *manager);
+GstElement *gst_element_get_manager(GstElement *element);
+
+void gst_element_add_pad(GstElement *element,GstPad *pad);
+void gst_element_add_ghost_pad(GstElement *element,GstPad *pad);
+GstPad *gst_element_get_pad(GstElement *element,gchar *name);
+GList *gst_element_get_pad_list(GstElement *element);
+
+void gst_element_connect(GstElement *src,gchar *srcpadname,
+                         GstElement *dest,gchar *destpadname);
+
+/* called by the app to set the state of the element */
+gboolean gst_element_set_state(GstElement *element,GstElementState state);
+
+void gst_element_error(GstElement *element,gchar *error);
+
+/* callback to actually set the state */
+gboolean gst_element_change_state(GstElement *element,
+                                  GstElementState state);
+
+#define gst_element_destroy(element) gst_object_destroy(GST_OBJECT(element))
+
+/* XML write and read */
+xmlNodePtr gst_element_save_thyself(GstElement *element,xmlNodePtr parent);
+
+
+GstElementFactory *gst_elementfactory_new(gchar *name,GtkType type,
+                                          GstElementDetails *details);
+void gst_elementfactory_register(GstElementFactory *elementfactory);
+
+GstElementFactory *gst_elementfactory_find(gchar *name);
+GList *gst_elementfactory_get_list();
+
+GstElement *gst_elementfactory_create(GstElementFactory *factory,
+                                      gchar *name);
+  
+// FIXME this name is wrong, probably so is the one above it
+GstElement *gst_elementfactory_make(gchar *factoryname,gchar *name);
+
+int gst_element_loopfunc_wrapper(int argc,char **argv);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_ELEMENT_H__ */     
+

gst/gstelementfactory.c

@@ -0,0 +1,138 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstelement.h>
+
+
+/* global list of registered elementfactories */
+GList* _gst_elementfactories;
+
+void _gst_elementfactory_initialize() {
+  _gst_elementfactories = NULL;
+}
+
+/**
+ * gst_elementfactory_register:
+ * @elementfactory: factory to register
+ *
+ * Adds the elementfactory to the global list, so it can be retrieved by
+ * name.
+ */
+void gst_elementfactory_register(GstElementFactory *elementfactory) {
+  g_return_if_fail(elementfactory != NULL);
+
+  _gst_elementfactories = g_list_prepend(_gst_elementfactories,elementfactory);
+}
+
+/**
+ * gst_elementfactory_find:
+ * @name: name of factory to find
+ *
+ * Search for an elementfactory of the given name.
+ *
+ * Returns: #GstElementFactory if found, NULL otherwise
+ */
+GstElementFactory *gst_elementfactory_find(gchar *name) {
+  GList *walk = _gst_elementfactories;
+  GstElementFactory *factory;
+
+  while (walk) {
+    factory = (GstElementFactory *)(walk->data);
+    if (!strcmp(name,factory->name))
+      return factory;
+    walk = g_list_next(walk);
+  }
+
+  return NULL;
+}
+
+/**
+ * gst_elementfactory_get_list:
+ *
+ * Get the global list of elementfactories.
+ *
+ * Returns: <type>GList</type> of type #GstElementFactory
+ */
+GList *gst_elementfactory_get_list() {
+  return _gst_elementfactories;
+}
+
+
+/**
+ * gst_elementfactory_new:
+ * @name: name of new elementfactory
+ * @type: GtkType of new element
+ * @details: #GstElementDetails structure with element details
+ *
+ * Create a new elementfactory capable of insantiating objects of the
+ * given type.
+ *
+ * Returns: new elementfactory
+ */
+GstElementFactory *gst_elementfactory_new(gchar *name,GtkType type,
+                                          GstElementDetails *details) {
+  GstElementFactory *factory = g_new0(GstElementFactory, 1);
+  factory->name = g_strdup(name);
+  factory->type = type;
+  factory->details = details;
+  return factory;
+}
+
+/**
+ * gst_elementfactory_create:
+ * @factory: factory to instantiate
+ * @name: name of new element
+ *
+ * Create a new element of the type defined by the given elementfactory.
+ * It wll be given the name supplied, since all elements require a name as
+ * their first argument.
+ *
+ * Returns: new #GstElement
+ */
+GstElement *gst_elementfactory_create(GstElementFactory *factory,
+                                      gchar *name) {
+  GstElement *element;
+  GstElementClass *oclass;
+
+  g_return_if_fail(factory != NULL);
+  g_return_if_fail(factory->type != 0);
+
+  // create an instance of the element
+  element = GST_ELEMENT(gtk_type_new(factory->type));
+  g_assert(element != NULL);
+
+  // attempt to set the elemenfactory class pointer if necessary
+  oclass = GST_ELEMENT_CLASS(GTK_OBJECT(element)->klass);
+  if (oclass->elementfactory == NULL)
+    oclass->elementfactory = factory;
+
+  gst_element_set_name(GST_ELEMENT(element),name);
+
+  return element;
+}
+
+GstElement *gst_elementfactory_make(gchar *factoryname,gchar *name) {
+  GstElementFactory *factory;
+  GstElement *element;
+
+  factory = gst_elementfactory_find(factoryname);
+  if (factory == NULL) return NULL;
+  element = gst_elementfactory_create(factory,name);
+  return element;
+}

gst/gstfilter.c

@@ -0,0 +1,86 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstfilter.h>
+
+
+/* Filter signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_filter_class_init(GstFilterClass *klass);
+static void gst_filter_init(GstFilter *filter);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_filter_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_filter_get_type(void) {
+  static GtkType filter_type = 0;
+
+  if (!filter_type) {
+    static const GtkTypeInfo filter_info = {
+      "GstFilter",
+      sizeof(GstFilter),
+      sizeof(GstFilterClass),
+      (GtkClassInitFunc)gst_filter_class_init,
+      (GtkObjectInitFunc)gst_filter_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    filter_type = gtk_type_unique(GST_TYPE_ELEMENT,&filter_info);
+  }
+  return filter_type;
+}
+
+static void
+gst_filter_class_init(GstFilterClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+}
+
+static void gst_filter_init(GstFilter *filter) {
+}
+
+/**
+ * gst_filter_new:
+ * @name: name of new filter
+ *
+ * Create a new filter with given name.
+ *
+ * Returns: new filter
+ */
+GstElement *gst_filter_new(gchar *name) {
+  GstElement *filter = GST_ELEMENT(gtk_type_new(gst_filter_get_type()));
+  gst_element_set_name(GST_ELEMENT(filter),name);
+  return filter;
+}

gst/gstfilter.h

@@ -0,0 +1,63 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_FILTER_H__
+#define __GST_FILTER_H__
+
+
+#include <gst/gstelement.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_FILTER \
+  (gst_filter_get_type())
+#define GST_FILTER(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_FILTER,GstFilter))
+#define GST_FILTER_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FILTER,GstFilterClass))
+#define GST_IS_FILTER(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_FILTER))
+#define GST_IS_FILTER_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FILTER)))
+
+typedef struct _GstFilter GstFilter;
+typedef struct _GstFilterClass GstFilterClass;
+
+struct _GstFilter {
+  GstElement element;
+};
+
+struct _GstFilterClass {
+  GstElementClass parent_class;
+};
+
+GtkType gst_filter_get_type(void);
+GstElement *gst_filter_new(gchar *name);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FILTER_H__ */

gst/gstlog.h

@@ -0,0 +1,31 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public 
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GST_LOG_H__
+#define __GST_LOG_H__
+
+/* information messages */
+#define GST_SHOW_INFO
+#ifdef GST_SHOW_INFO
+#define gst_info(format,args...) fprintf(stderr,format,##args)
+#else
+#define gst_info(format,args...)
+#endif
+
+#endif /* __GST_LOG_H__ */

gst/gstmeta.c

@@ -0,0 +1,57 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstmeta.h>
+#include <gst/gsttrace.h>
+
+
+GstMeta *gst_meta_new_size(gint size) {
+  GstMeta *meta;
+
+  meta = g_malloc(size);
+  gst_meta_ref(meta);
+
+  return meta;
+}
+
+void gst_meta_ref(GstMeta *meta) {
+  g_return_if_fail(meta != NULL);
+
+  gst_trace_add_entry(NULL,0,meta,"ref meta");
+  meta->refcount++;
+}
+
+void gst_meta_unref(GstMeta *meta) {
+  g_return_if_fail(meta != NULL);
+
+  gst_trace_add_entry(NULL,0,meta,"unref meta");
+  meta->refcount--;
+
+  if (meta->refcount == 0) {
+//    gst_trace_add_entry(NULL,0,meta,"destroy meta");
+    g_free(meta);
+    g_print("freeing metadata\n");
+  }
+}
+
+
+GstMeta *gst_meta_cow(GstMeta *meta) {
+  g_return_if_fail(meta != NULL);
+}

gst/gstmeta.h

@@ -0,0 +1,85 @@
+/* Gnome-Streamer   
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+
+#ifndef __GST_META_H__
+#define __GST_META_H__
+
+#include <glib.h> 
+ 
+ 
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_META(meta) ((GstMeta *)(meta))
+
+
+#define GST_META_FLAGS(buf) \
+  (GST_META(buf)->flags)
+#define GST_META_FLAG_IS_SET(meta,flag) \
+  (GST_META_FLAGS(meta) & (flag))
+#define GST_META_FLAG_SET(meta,flag) \
+  G_STMT_START{ (GST_META_FLAGS(meta) |= (flag)); }G_STMT_END
+#define GST_META_FLAG_UNSET(meta,flag) \
+  G_STMT_START{ (GST_META_FLAGS(meta) &= ~(flag)); }G_STMT_END
+
+
+typedef enum {
+  GST_META_FREEABLE             = 1 << 0,
+} GstMetaFlags;
+
+
+typedef struct _GstMeta GstMeta;
+
+struct _GstMeta {
+  /* locking */
+  GMutex *lock;
+
+  /* refcounting */
+#ifdef HAVE_ATOMIC_H
+  atomic_t refcount;
+#else
+  int refcount;
+#endif
+
+  guint16 type;
+  guint16 flags;
+
+  void *data;
+  guint16 size;
+};
+
+
+GstMeta *gst_meta_new_size(gint size);
+#define gst_meta_new(type) (type *)gst_meta_new_size(sizeof(type))
+
+/* refcounting */
+void gst_meta_ref(GstMeta *meta);
+void gst_meta_unref(GstMeta *meta);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+ 
+ 
+#endif /* __GST_BUFFER_H__ */
+

gst/gstobject.c

@@ -0,0 +1,223 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstobject.h>
+#include <gst/gstbin.h>
+
+
+/* Object signals and args */
+enum {
+  PARENT_SET,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_object_class_init(GstObjectClass *klass);
+static void gst_object_init(GstObject *object);
+
+
+static GtkObjectClass *parent_class = NULL;
+static guint gst_object_signals[LAST_SIGNAL] = { 0 };
+
+GtkType gst_object_get_type(void) {
+  static GtkType object_type = 0;
+
+  if (!object_type) {
+    static const GtkTypeInfo object_info = {
+      "GstObject",
+      sizeof(GstObject),
+      sizeof(GstObjectClass),
+      (GtkClassInitFunc)gst_object_class_init,
+      (GtkObjectInitFunc)gst_object_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    object_type = gtk_type_unique(gtk_object_get_type(),&object_info);
+  }
+  return object_type;
+}
+
+static void gst_object_class_init(GstObjectClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(gtk_object_get_type());
+
+  gst_object_signals[PARENT_SET] =
+    gtk_signal_new("parent_set",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstObjectClass,parent_set),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+  gtk_object_class_add_signals(gtkobject_class,gst_object_signals,LAST_SIGNAL);
+}
+
+static void gst_object_init(GstObject *object) {
+  object->lock = g_mutex_new();
+#ifdef HAVE_ATOMIC_H
+  atomic_set(&(object->refcount),1);
+#else
+  object->refcount++;
+#endif
+  object->parent = NULL;
+}
+
+/**
+ * gst_object_new:
+ *
+ * Create a new object with
+ *
+ * Returns: new object
+ */
+GstObject *gst_object_new() {
+  return GST_OBJECT(gtk_type_new(gst_object_get_type()));
+}
+
+/**
+ * gst_object_set_parent:
+ * @object: GstObject to set parent of
+ * @parent: new parent of object
+ *
+ * Set the parent of the object.  The object's reference count is
+ * incremented.
+ */
+void gst_object_set_parent(GstObject *object,GstObject *parent) {
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+  g_return_if_fail(object->parent == NULL);
+  g_return_if_fail(parent != NULL);
+  g_return_if_fail(GST_IS_OBJECT(parent));
+  g_return_if_fail(object != parent);
+
+  gst_object_ref(object);
+  gst_object_sink(object);
+  object->parent = parent;
+
+  gtk_signal_emit(GTK_OBJECT(object),gst_object_signals[PARENT_SET],parent);
+}
+
+/**
+ * gst_object_get_parent:
+ * @object: GstObject to get parent of
+ *
+ * Return the parent of the object.
+ *
+ * Returns: parent of the object
+ */
+GstObject *gst_object_get_parent(GstObject *object) {
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+
+  return object->parent;
+}
+
+/**
+ * gst_object_unparent:
+ * @object: GstObject to unparent
+ *
+ * Clear the parent of the object, removing the associated reference.
+ */
+void gst_object_unparent(GstObject *object) {
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+  if (object->parent == NULL)
+    return;
+
+  object->parent = NULL;
+  gst_object_unref(object);
+}
+
+#ifndef gst_object_ref
+void gst_object_ref (GstObject *object) {
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+
+#ifdef HAVE_ATOMIC_H
+  g_return_if_fail(atomic_read(&(object->refcount)) > 0);
+  atomic_inc(&(object->refcount))
+#else
+  g_return_if_fail(object->refcount > 0);
+  GST_LOCK(object);
+  object->refcount++;
+  GST_UNLOCK(object);
+#endif
+}
+#endif /* gst_object_ref */
+
+#ifndef gst_object_unref
+void gst_object_unref (GstObject *object) {
+  int reftest;
+
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+
+#ifdef HAVE_ATOMIC_H
+  g_return_if_fail(atomic_read(&(object->refcount)) > 0);
+  reftest = atomic_dec_and_test(&(object->refcount))
+#else
+  g_return_if_fail(object->refcount > 0);
+  GST_LOCK(object);
+  object->refcount--;
+  reftest = (object->refcount == 0);
+  GST_UNLOCK(object);
+#endif
+
+  /* if we ended up with the refcount at zero */
+  if (reftest) {
+    /* get the count to 1 for gtk_object_destroy() */
+#ifdef HAVE_ATOMIC_T
+    atomic_set(&(object->refcount),1);
+#else
+    object->refcount = 1;
+#endif
+    /* destroy it */
+    gtk_object_destroy(GTK_OBJECT(object));
+    /* drop the refcount back to zero */
+#ifdef HAVE_ATOMIC_T
+    atomic_set(&(object->refcount),0);
+#else
+    object->refcount = 0;
+#endif
+    /* finalize the object */
+    // FIXME this is an evil hack that should be killed
+// FIXMEFIXMEFIXMEFIXME
+//    gtk_object_finalize(GTK_OBJECT(object));
+  }
+}
+#endif /* gst_object_unref */
+
+#ifndef gst_object_sink
+void gst_object_sink(GstObject *object) {
+  g_return_if_fail(object != NULL);
+  g_return_if_fail(GST_IS_OBJECT(object));
+
+  if (GTK_OBJECT_FLOATING(object)) {
+    GTK_OBJECT_UNSET_FLAGS(object, GTK_FLOATING);
+    gst_object_unref(object);
+  }
+}
+#endif /* gst_object_sink */
+

gst/gstobject.h

@@ -0,0 +1,117 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_OBJECT_H__
+#define __GST_OBJECT_H__
+
+
+#include <gtk/gtk.h>
+#include <gst/gsttrace.h>
+#include "config.h"
+
+#ifdef HAVE_ATOMIC_H
+#include <asm/atomic.h>
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_OBJECT \
+  (gst_object_get_type())
+#define GST_OBJECT(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_OBJECT,GstObject))
+#define GST_OBJECT_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_OBJECT,GstObjectClass))
+#define GST_IS_OBJECT(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_OBJECT))
+#define GST_IS_OBJECT_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_OBJECT)))
+
+typedef struct _GstObject GstObject;
+typedef struct _GstObjectClass GstObjectClass;
+
+struct _GstObject {
+  GtkObject object;
+
+  /* have to have a refcount for the object */
+#ifdef HAVE_ATOMIC_H
+  atomic_t refcount;
+#else
+  int refcount;
+#endif
+
+  /* locking for all sorts of things (like the refcount) */
+  GMutex *lock;
+
+  /* this objects parent */
+  GstObject *parent;
+};
+
+struct _GstObjectClass {
+  GtkObjectClass parent_class;
+
+  /* signals */
+  void (*parent_set) (GstObject *object,GstObject *parent);
+
+  /* functions go here */
+};
+
+
+#define GST_FLAGS(obj)			GTK_OBJECT_FLAGS(obj)
+#define GST_FLAG_IS_SET(obj,flag)	(GST_FLAGS (obj) & (flag))
+#define GST_FLAG_SET(obj,flag)		G_STMT_START{ (GST_FLAGS (obj) |= (flag)); }G_STMT_END
+#define GST_FLAG_UNSET(obj,flag)	G_STMT_START{ (GST_FLAGS (obj) &= ~(flag)); }G_STMT_END
+
+#define GST_LOCK(obj)		(g_mutex_lock(GST_OBJECT(obj)->lock))
+#define GST_TRYLOCK(obj)	(g_mutex_trylock(GST_OBJECT(obj)->lock))
+#define GST_UNLOCK(obj)		(g_mutex_unlock(GST_OBJECT(obj)->lock))
+
+
+/* normal GtkObject stuff */
+GtkType gst_object_get_type(void);
+GstObject* gst_object_new(void);
+
+/* parentage routines */
+void gst_object_set_parent(GstObject *object,GstObject *parent);
+GstObject *gst_object_get_parent(GstObject *object);
+void gst_object_unparent(GstObject *object);
+
+/* refcounting */
+//void gst_object_ref(GstObject *object);
+#define gst_object_ref(obj) gtk_object_ref(GTK_OBJECT(obj));
+//void gst_object_unref(GstObject *object);
+#define gst_object_unref(obj) gtk_object_unref(GTK_OBJECT(obj));
+//void gst_object_sink(GstObject *object);
+#define gst_object_sink(obj) gtk_object_sink(GTK_OBJECT(obj));
+
+/* destroying an object */
+#define gst_object_destroy(obj) gtk_object_destroy(GTK_OBJECT(obj))
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_OBJECT_H__ */     
+

gst/gstpad.c

@@ -0,0 +1,340 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstpad.h>
+#include <gst/gstelement.h>
+#include <gst/gsttype.h>
+
+
+/* Pad signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_pad_class_init(GstPadClass *klass);
+static void gst_pad_init(GstPad *pad);
+static void gst_pad_real_destroy(GtkObject *object);
+
+
+static GstObject *parent_class = NULL;
+static guint gst_pad_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_pad_get_type(void) {
+  static GtkType pad_type = 0;
+
+  if (!pad_type) {
+    static const GtkTypeInfo pad_info = {
+      "GstPad",
+      sizeof(GstPad),
+      sizeof(GstPadClass),
+      (GtkClassInitFunc)gst_pad_class_init,
+      (GtkObjectInitFunc)gst_pad_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    pad_type = gtk_type_unique(GST_TYPE_OBJECT,&pad_info);
+  }
+  return pad_type;
+}
+
+static void
+gst_pad_class_init(GstPadClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_OBJECT);
+
+  gtkobject_class->destroy = gst_pad_real_destroy;
+}
+
+static void gst_pad_init(GstPad *pad) {
+  pad->type = 0;
+  pad->direction = GST_PAD_UNKNOWN;
+  pad->peer = NULL;
+  pad->chain = NULL;
+  pad->parent = NULL;
+  pad->ghostparents = NULL;
+}
+
+/**
+ * gst_pad_new:
+ * @name: name of new pad
+ * @direction: either GST_PAD_SRC or GST_PAD_SINK
+ *
+ * Create a new pad with given name.
+ *
+ * Returns: new pad
+ */
+GstPad *gst_pad_new(gchar *name,GstPadDirection direction) {
+  GstPad *pad;
+
+  g_return_if_fail(name != NULL);
+  g_return_if_fail(direction != GST_PAD_UNKNOWN);
+
+  pad = GST_PAD(gtk_type_new(gst_pad_get_type()));
+  pad->name = g_strdup(name);
+  pad->direction = direction;
+  return pad;
+}
+
+GstPadDirection gst_pad_get_direction(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->direction;
+}
+
+void gst_pad_set_name(GstPad *pad,gchar *name) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  if (pad->name != NULL)
+    g_free(pad->name);
+
+  pad->name = g_strdup(name);
+}
+
+gchar *gst_pad_get_name(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->name;
+}
+
+void gst_pad_set_chain_function(GstPad *pad,GstPadChainFunction chain) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  
+  pad->chain = chain;
+}
+
+void gst_pad_push(GstPad *pad,GstBuffer *buffer) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buffer != NULL);
+
+  gst_trace_add_entry(NULL,0,buffer,"push buffer");
+  // if the chain function exists for the pad, call it directly
+  if (pad->chain)
+    (pad->chain)(pad->peer,buffer);
+  // else we're likely going to have to coroutine it
+  else {
+    pad->peer->bufpen = buffer;
+    g_print("would switch to a coroutine here...\n");
+    if (!GST_IS_ELEMENT(pad->peer->parent))
+      g_print("eek, this isn't an element!\n");
+    if (GST_ELEMENT(pad->peer->parent)->threadstate != NULL)
+      cothread_switch(GST_ELEMENT(pad->peer->parent)->threadstate);
+  }
+}
+
+GstBuffer *gst_pad_pull(GstPad *pad) {
+  GstBuffer *buf;
+  GstElement *peerparent;
+  cothread_state *state;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  if (pad->bufpen == NULL) {
+    g_print("no buffer available, will have to do something about it\n");
+    peerparent = GST_ELEMENT(pad->peer->parent);
+    // if they're a cothread too, we can just switch to them
+    if (peerparent->threadstate != NULL) {
+      cothread_switch(peerparent->threadstate);
+    // otherwise we have to switch to the main thread
+    } else {
+      state = cothread_main(GST_ELEMENT(pad->parent)->threadstate->ctx);
+      g_print("switching to supposed 0th thread at %p\n",state);
+      cothread_switch(state);
+    }
+  } else {
+    g_print("buffer available, pulling\n");
+    buf = pad->bufpen;
+    pad->bufpen = NULL;
+    return buf;
+  }
+}
+
+void gst_pad_chain(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(pad->peer != NULL);
+  g_return_if_fail(pad->chain != NULL);
+
+  if (pad->bufpen)
+    (pad->chain)(pad,pad->bufpen);
+}
+
+void gst_pad_connect(GstPad *srcpad,GstPad *sinkpad) {
+  GstPad *temppad;
+
+  /* generic checks */
+  g_return_if_fail(srcpad != NULL);
+  g_return_if_fail(GST_IS_PAD(srcpad));
+  g_return_if_fail(srcpad->peer == NULL);
+  g_return_if_fail(sinkpad != NULL);
+  g_return_if_fail(GST_IS_PAD(sinkpad));
+  g_return_if_fail(sinkpad->peer == NULL);
+//  g_return_if_fail(sinkpad->chain != NULL);
+
+  /* check for reversed directions and swap if necessary */
+  if ((srcpad->direction == GST_PAD_SINK) &&
+      (sinkpad->direction == GST_PAD_SRC)) {
+    temppad = srcpad;
+    srcpad = sinkpad;
+    sinkpad = temppad;
+  }
+  g_return_if_fail((srcpad->direction == GST_PAD_SRC) &&
+                   (sinkpad->direction == GST_PAD_SINK));
+
+  /* first set peers */
+  srcpad->peer = sinkpad;
+  sinkpad->peer = srcpad;
+
+  /* now copy the chain pointer from sink to src */
+  srcpad->chain = sinkpad->chain;
+
+  /* set the connected flag */
+  /* FIXME: set connected flag */
+}
+
+void gst_pad_set_parent(GstPad *pad,GstObject *parent) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(pad->parent == NULL);
+  g_return_if_fail(parent != NULL);
+  g_return_if_fail(GTK_IS_OBJECT(parent));
+  g_return_if_fail((gpointer)pad != (gpointer)parent);
+
+  pad->parent = parent;
+}
+
+void gst_pad_add_ghost_parent(GstPad *pad,GstObject *parent) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(parent != NULL);
+  g_return_if_fail(GTK_IS_OBJECT(parent));
+
+  pad->ghostparents = g_list_prepend(pad->ghostparents,parent);
+}
+
+
+void gst_pad_remove_ghost_parent(GstPad *pad,GstObject *parent) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(parent != NULL);
+  g_return_if_fail(GTK_IS_OBJECT(parent));
+
+  pad->ghostparents = g_list_remove(pad->ghostparents,parent);
+}
+
+GstObject *gst_pad_get_parent(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->parent;
+}
+
+GList *gst_pad_get_ghost_parents(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->ghostparents;
+}
+
+guint32 gst_pad_get_type_id(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->type;
+}
+
+void gst_pad_set_type_id(GstPad *pad,guint16 id) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(gst_type_find_by_id(id) != NULL);
+
+  pad->type = id;
+}
+
+GstPad *gst_pad_get_peer(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->peer;
+}
+
+GstPadDirection gst_pad_get_directory(GstPad *pad) {
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+
+  return pad->direction;
+}
+
+static void gst_pad_real_destroy(GtkObject *object) {
+  GstPad *pad = GST_PAD(object);
+
+//  g_print("in gst_pad_real_destroy()\n");
+
+  if (pad->name)
+    g_free(pad->name);
+  g_list_free(pad->ghostparents);
+}
+
+xmlNodePtr gst_pad_save_thyself(GstPad *pad,xmlNodePtr parent) {
+  xmlNodePtr self;
+  GstPad *peer;
+
+  self = xmlNewChild(parent,NULL,"pad",NULL);
+  xmlNewChild(self,NULL,"name",pad->name);
+  if (pad->peer != NULL) {
+    peer = pad->peer;
+    // first check to see if the peer's parent's parent is the same
+    if (pad->parent->parent == peer->parent->parent)
+      // we just save it off
+      xmlNewChild(self,NULL,"peer",g_strdup_printf("%s.%s",
+                    GST_ELEMENT(peer->parent)->name,peer->name));
+  } else
+    xmlNewChild(self,NULL,"peer","");
+
+  return self;
+}
+
+xmlNodePtr gst_pad_ghost_save_thyself(GstPad *pad,GstElement *bin,xmlNodePtr parent) {
+  xmlNodePtr self;
+  GstPad *peer;
+
+  self = xmlNewChild(parent,NULL,"ghostpad",NULL);
+  xmlNewChild(self,NULL,"name",pad->name);
+  xmlNewChild(self,NULL,"parent",GST_ELEMENT(pad->parent)->name);
+
+  return self;
+}

gst/gstpad.h

@@ -0,0 +1,127 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_PAD_H__
+#define __GST_PAD_H__
+
+
+#include <gnome-xml/parser.h>
+#include <gst/gstobject.h>
+#include <gst/gstbuffer.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_PAD \
+  (gst_pad_get_type())
+#define GST_PAD(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_PAD,GstPad))
+#define GST_PAD_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PAD,GstPadClass))
+#define GST_IS_PAD(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_PAD))
+#define GST_IS_PAD_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PAD)))
+
+// quick test to see if the pad is connected
+#define GST_PAD_CONNECTED(pad) ((pad)->peer != NULL)
+
+typedef struct _GstPad GstPad;
+typedef struct _GstPadClass GstPadClass;
+
+/* this defines the functions used to chain buffers
+ * pad is the sink pad (so the same chain function can be used for N pads)
+ * buf is the buffer being passed */
+typedef void (*GstPadChainFunction) (GstPad *pad,GstBuffer *buf);
+typedef void (*GstPadPushFunction) (GstPad *pad);
+
+typedef enum {
+  GST_PAD_UNKNOWN,
+  GST_PAD_SRC,
+  GST_PAD_SINK,
+} GstPadDirection;
+
+//typedef enum {
+//} GstPadFlags;
+
+struct _GstPad {
+  GstObject object;
+
+  gchar *name;
+  guint16 type;
+
+  GstPadDirection direction;
+
+  GstPad *peer;
+
+  GstBuffer *bufpen;
+
+  GstPadChainFunction chain;
+
+  GstObject *parent;
+  GList *ghostparents;
+};
+
+struct _GstPadClass {
+  GstObjectClass parent_class;
+};
+
+GtkType gst_pad_get_type(void);
+GstPad *gst_pad_new(gchar *name,GstPadDirection direction);
+void gst_pad_destroy(GstPad *pad);
+
+GstPadDirection gst_pad_get_direction(GstPad *pad);
+void gst_pad_set_chain_function(GstPad *pad,GstPadChainFunction chain);
+
+guint32 gst_pad_get_type_id(GstPad *pad);
+void gst_pad_set_type_id(GstPad *pad,guint16 id);
+
+void gst_pad_set_name(GstPad *pad,gchar *name);
+gchar *gst_pad_get_name(GstPad *pad);
+#define gst_pad_destroy(pad) gst_object_destroy(GST_OBJECT(pad))
+
+GstPadDirection gst_pad_get_directory(GstPad *pad);
+
+void gst_pad_set_parent(GstPad *pad,GstObject *parent);
+void gst_pad_add_ghost_parent(GstPad *pad,GstObject *parent);
+void gst_pad_remove_ghost_parent(GstPad *pad,GstObject *parent);
+GstObject *gst_pad_get_parent(GstPad *pad);
+GList *gst_pad_get_ghost_parents(GstPad *pad);
+
+GstPad *gst_pad_get_peer(GstPad *pad);
+
+void gst_pad_connect(GstPad *srcpad,GstPad *sinkpad);
+
+void gst_pad_push(GstPad *pad,GstBuffer *buffer);
+GstBuffer *gst_pad_pull(GstPad *pad);
+
+xmlNodePtr gst_pad_save_thyself(GstPad *pad,xmlNodePtr parent);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_PAD_H__ */     
+

gst/gstpipeline.c

@@ -0,0 +1,134 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstpipeline.h>
+
+GstElementDetails gst_pipeline_details = {
+  "Pipeline object",
+  "Bin",
+  "Complete pipeline object",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* Pipeline signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_pipeline_class_init(GstPipelineClass *klass);
+static void gst_pipeline_init(GstPipeline *pipeline);
+
+static gboolean gst_pipeline_change_state(GstElement *element,
+                                          GstElementState state);
+
+static void gst_pipeline_prepare(GstPipeline *pipeline);
+
+
+static GstBin *parent_class = NULL;
+static guint gst_pipeline_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_pipeline_get_type(void) {
+  static GtkType pipeline_type = 0;
+
+  if (!pipeline_type) {
+    static const GtkTypeInfo pipeline_info = {
+      "GstPipeline",
+      sizeof(GstPipeline),
+      sizeof(GstPipelineClass),
+      (GtkClassInitFunc)gst_pipeline_class_init,
+      (GtkObjectInitFunc)gst_pipeline_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    pipeline_type = gtk_type_unique(gst_bin_get_type(),&pipeline_info);
+  }
+  return pipeline_type;
+}
+
+static void
+gst_pipeline_class_init(GstPipelineClass *klass) {
+  GstElementClass *gstelement_class;
+
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = gtk_type_class(gst_bin_get_type());
+
+  gstelement_class->change_state = gst_pipeline_change_state;
+}
+
+static void gst_pipeline_init(GstPipeline *pipeline) {
+}
+
+GstPipeline *gst_pipeline_new(guchar *name) {
+  GstPipeline *pipeline;
+
+  pipeline = gtk_type_new(gst_pipeline_get_type());
+  gst_element_set_name(GST_ELEMENT(pipeline),name);
+  return pipeline;
+}
+
+static void gst_pipeline_prepare(GstPipeline *pipeline) {
+  g_print("preparing pipeline for playing\n");
+}
+
+
+static gboolean gst_pipeline_change_state(GstElement *element,
+                                          GstElementState state) {
+  GstPipeline *pipeline;
+
+  g_return_if_fail(GST_IS_PIPELINE(element));
+  pipeline = GST_PIPELINE(element);
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      /* we need to set up internal state */
+      g_print("preparing pipeline \"%s\" for iterations:\n",
+              gst_element_get_name(GST_ELEMENT(element)));
+      gst_pipeline_prepare(pipeline);
+      break;
+    case ~GST_STATE_RUNNING:
+      /* tear down the internal state */
+      g_print("tearing down pipelines's iteration state\n");
+      break;
+    default:
+      break;
+  }
+    
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}
+
+
+void gst_pipeline_iterate(GstPipeline *pipeline) {
+  g_return_if_fail(pipeline != NULL);
+  g_return_if_fail(GST_IS_PIPELINE(pipeline));
+}

gst/gstpipeline.h

@@ -0,0 +1,69 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_PIPELINE_H__
+#define __GST_PIPELINE_H__
+
+
+#include <gst/gstbin.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+GstElementDetails gst_pipeline_details;
+
+
+#define GST_TYPE_PIPELINE \
+  (gst_pipeline_get_type())
+#define GST_PIPELINE(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_PIPELINE,GstPipeline))
+#define GST_PIPELINE_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PIPELINE,GstPipelineClass))
+#define GST_IS_PIPELINE(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_PIPELINE))
+#define GST_IS_PIPELINE_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PIPELINE)))
+
+typedef struct _GstPipeline GstPipeline;
+typedef struct _GstPipelineClass GstPipelineClass;
+
+struct _GstPipeline {
+  GstBin bin;
+};
+
+struct _GstPipelineClass {
+  GstBinClass parent_class;
+};
+
+GtkType gst_pipeline_get_type(void);
+GstPipeline *gst_pipeline_new(guchar *name);
+#define gst_pipeline_destroy(pipeline) gst_object_destroy(GST_OBJECT(pipeline))
+
+void gst_pipeline_iterate(GstPipeline *pipeline);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_PIPELINE_H__ */     
+

gst/gstplugin.c

@@ -0,0 +1,297 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#include <gst/gstplugin.h>
+
+
+/* list of loaded modules and its sequence number */
+GList *_gst_modules;
+gint _gst_modules_seqno;
+/* global list of plugins and its sequence number */
+GList *_gst_plugins;
+gint _gst_plugins_seqno;
+/* list of paths to check for plugins */
+GList *_gst_plugin_paths;
+
+/* whether or not to spew library load issues */
+gboolean _gst_plugin_spew = FALSE;
+
+
+void _gst_plugin_initialize() {
+  _gst_modules = NULL;
+  _gst_modules_seqno = 0;
+  _gst_plugins = NULL;
+  _gst_plugins_seqno = 0;
+  _gst_plugin_paths = NULL;
+
+  /* add the main (installed) library path */
+  _gst_plugin_paths = g_list_prepend(_gst_plugin_paths,PLUGINS_DIR);
+
+  /* if this is set, we add build-directory paths to the list */
+#ifdef PLUGINS_USE_SRCDIR
+  /* the catch-all plugins directory */
+  _gst_plugin_paths = g_list_prepend(_gst_plugin_paths,
+                                     PLUGINS_SRCDIR "/plugins");
+  /* location libgstelements.so */
+  _gst_plugin_paths = g_list_prepend(_gst_plugin_paths,
+                                     PLUGINS_SRCDIR "/gst/elements");
+  _gst_plugin_paths = g_list_prepend(_gst_plugin_paths,
+                                     PLUGINS_SRCDIR "/gst/types");
+#endif /* PLUGINS_USE_SRCDIR */
+}
+
+static gboolean gst_plugin_load_recurse(gchar *directory,gchar *name) {
+  DIR *dir;
+  struct dirent *dirent;
+  gboolean loaded = FALSE;
+
+  dir = opendir(directory);
+  if (dir) {
+    while (dirent = readdir(dir)) {
+      /* don't want to recurse in place or backwards */
+      if (strcmp(dirent->d_name,".") && strcmp(dirent->d_name,"..")) {
+        gst_plugin_load_recurse(g_strjoin("/",directory,dirent->d_name,
+                                              NULL),name);
+      }
+    }
+    closedir(dir);
+  } else {
+    if (strstr(directory,".so")) {
+      gchar *temp;
+      if (name) {
+        if ((temp = strstr(directory,name)) && 
+            (!strcmp(temp,name))) {
+          gst_plugin_load_absolute(directory);
+          return TRUE;
+        }
+      } else if ((temp = strstr(directory,".so")) &&
+                 (!strcmp(temp,".so"))) {
+        gst_plugin_load_absolute(directory);
+        loaded = TRUE;
+      }
+    }
+  }
+  return loaded;
+}
+
+/**
+ * gst_plugin_load_all:
+ *
+ * Load all plugins in the path.
+ */
+void gst_plugin_load_all() {
+  GList *path;
+
+  path = _gst_plugin_paths;
+  while (path != NULL) {
+    gst_plugin_load_recurse(path->data,NULL);
+    path = g_list_next(path);
+  }
+}
+
+/**
+ * gst_plugin_load:
+ * @name: name of plugin to load
+ *
+ * Load the named plugin.  Name should be given as
+ * &quot;libplugin.so&quot;.
+ *
+ * Returns: whether the plugin was loaded or not
+ */
+gboolean gst_plugin_load(gchar *name) {
+  GList *path;
+  gchar *libspath;
+
+//  g_print("attempting to load plugin '%s'\n",name);
+
+  path = _gst_plugin_paths;
+  while (path != NULL) {
+    if (gst_plugin_load_absolute(g_module_build_path(path->data,name)))
+      return TRUE;
+    libspath = g_strconcat(path->data,"/.libs",NULL);
+//    g_print("trying to load '%s'\n",g_module_build_path(libspath,name));
+    if (gst_plugin_load_absolute(g_module_build_path(libspath,name))) {
+      g_free(libspath);
+      return TRUE;
+    }
+    g_free(libspath);
+//    g_print("trying to load '%s' from '%s'\n",name,path->data);
+    if (gst_plugin_load_recurse(path->data,name)) {
+      return TRUE;
+    }
+    path = g_list_next(path);
+  }
+  return FALSE;
+}
+
+/**
+ * gst_plugin_load_absolute:
+ * @name: name of plugin to load
+ *
+ * Returns: whether or not the plugin loaded
+ */
+gboolean gst_plugin_load_absolute(gchar *name) {
+  GModule *module;
+  GstPluginInitFunc initfunc;
+  GstPlugin *plugin;
+
+//  g_print("trying to load '%s\n",name);
+
+  if (g_module_supported() == FALSE) {
+    g_print("wow, you built this on a platform without dynamic loading???\n");
+    return;
+  }
+
+  module = g_module_open(name,0);
+  if (module != NULL) {
+    if (g_module_symbol(module,"plugin_init",(gpointer *)&initfunc)) {
+      if (plugin = (initfunc)(module)) {
+        GList *factories;
+        plugin->filename = g_strdup(name);
+        _gst_modules = g_list_append(_gst_modules,module);
+        _gst_modules_seqno++;
+        _gst_plugins = g_list_append(_gst_plugins,plugin);
+        _gst_plugins_seqno++;
+        factories = plugin->elements;
+        while (factories) {
+          gst_elementfactory_register((GstElementFactory*)(factories->data));
+          factories = g_list_next(factories);
+        }
+        return TRUE;
+      }
+    }
+  } else if (_gst_plugin_spew) {
+//    if (strstr(g_module_error(),"No such") == NULL)
+      gst_info("error loading plugin: %s\n",g_module_error());
+  }
+
+  return FALSE;
+}
+
+/**
+ * gst_plugin_new:
+ * @name: name of new plugin
+ *
+ * Create a new plugin with given name.
+ *
+ * Returns: new plugin
+ */
+GstPlugin *gst_plugin_new(gchar *name) {
+  GstPlugin *plugin = (GstPlugin *)malloc(sizeof(GstPlugin));
+
+  plugin->name = g_strdup(name);
+  plugin->longname = NULL;
+  plugin->types = NULL;
+  plugin->elements = NULL;
+
+  return plugin;
+}
+
+/**
+ * gst_plugin_set_longname:
+ * @plugin: plugin to set long name of
+ * @longname: new long name
+ *
+ * Sets the long name (should be descriptive) of the plugin.
+ */
+void gst_plugin_set_longname(GstPlugin *plugin,gchar *longname) {
+  g_return_if_fail(plugin != NULL);
+
+  if (plugin->longname) g_free(plugin->longname);
+  plugin->longname = g_strdup(longname);
+}
+
+/**
+ * gst_plugin_find:
+ * @name: name of plugin to find
+ *
+ * Search the list of registered plugins for one of the given name
+ *
+ * Returns: pointer to the #GstPlugin if found, NULL otherwise
+ */
+GstPlugin *gst_plugin_find(gchar *name) {
+  GList *plugins = _gst_plugins;
+
+  g_return_if_fail(name != NULL);
+
+  while (plugins) {
+    GstPlugin *plugin = (GstPlugin *)plugins->data;
+//    g_print("plugin name is '%s'\n",plugin->name);
+    if (plugin->name) {
+      if (!strcmp(plugin->name,name))
+        return plugin;
+    }
+    plugins = g_list_next(plugins);
+  }
+  return NULL;
+}
+
+/** 
+ * gst_plugin_find_elementfactory:
+ * @name: name of elementfactory to find
+ *
+ * Find a registered elementfactory by name.
+ *
+ * Returns: @GstElementFactory if found, NULL if not
+ */
+GstElementFactory *gst_plugin_find_elementfactory(gchar *name) {
+  GList *plugins, *factories;
+  GstElementFactory *factory;
+
+  g_return_if_fail(name != NULL);
+
+  plugins = _gst_plugins;
+  while (plugins) {
+    factories = ((GstPlugin *)(plugins->data))->elements;
+    while (factories) {
+      factory = (GstElementFactory*)(factories->data);
+      if (!strcmp(gst_element_get_name(GST_ELEMENT(factory)),name))
+        return (GstElementFactory*)(factory);
+      factories = g_list_next(factories);
+    }
+    plugins = g_list_next(plugins);
+  }
+
+  return NULL;
+}
+
+/**
+ * gst_plugin_add_factory:
+ * @plugin: plugin to add factory to
+ * @factory: factory to add
+ *
+ * Add factory to the list of those provided by the element.
+ */
+void gst_plugin_add_factory(GstPlugin *plugin,GstElementFactory *factory) {
+  g_return_if_fail(plugin != NULL);
+  g_return_if_fail(factory != NULL);
+
+//  g_print("adding factory to plugin\n");
+  plugin->elements = g_list_append(plugin->elements,factory);
+}
+
+GList *gst_plugin_get_list() {
+  return _gst_plugins;
+}

gst/gstplugin.h

@@ -0,0 +1,63 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_PLUGIN_H__
+#define __GST_PLUGIN_H__
+
+
+#include <gmodule.h>
+
+#include <gst/gsttype.h>
+#include <gst/gstelement.h>
+
+#include "config.h"
+
+
+typedef struct _GstPlugin GstPlugin;
+typedef struct _GstPluginElement GstPluginElement;
+
+struct _GstPlugin {
+  gchar *name;			/* name of the plugin */
+  gchar *longname;		/* long name of plugin */
+  gchar *filename;		/* filename it came from */
+
+  GList *types;			/* list of types provided */
+  GList *elements;		/* list of elements provided */
+  GList *identifiers;		/* list of identifiers */
+};
+
+
+typedef GstPlugin * (*GstPluginInitFunc) (GModule *module);
+
+GstPlugin *gst_plugin_new(gchar *name);
+void gst_plugin_set_longname(GstPlugin *plugin,gchar *longname);
+
+void gst_plugin_init();
+void gst_plugin_load_all();
+gboolean gst_plugin_load(gchar *name);
+gboolean gst_plugin_load_absolute(gchar *name);
+
+void gst_plugin_add_factory(GstPlugin *plugin,GstElementFactory *factory);
+
+GstPlugin *gst_plugin_find(gchar *name);
+GList *gst_plugin_get_list();
+GstElementFactory *gst_plugin_find_elementfactory(gchar *name);
+
+#endif /* __GST_PLUGIN_H__ */

gst/gstsink.c

@@ -0,0 +1,79 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstsink.h>
+
+
+/* Sink signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_sink_class_init(GstSinkClass *klass);
+static void gst_sink_init(GstSink *sink);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_sink_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_sink_get_type(void) {
+  static GtkType sink_type = 0;
+
+  if (!sink_type) {
+    static const GtkTypeInfo sink_info = {
+      "GstSink",
+      sizeof(GstSink),
+      sizeof(GstSinkClass),
+      (GtkClassInitFunc)gst_sink_class_init,
+      (GtkObjectInitFunc)gst_sink_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    sink_type = gtk_type_unique(GST_TYPE_ELEMENT,&sink_info);
+  }
+  return sink_type;
+}
+
+static void
+gst_sink_class_init(GstSinkClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+}
+
+static void gst_sink_init(GstSink *sink) {
+}
+
+GstObject *gst_sink_new(gchar *name) {
+  GstObject *sink = GST_OBJECT(gtk_type_new(GST_TYPE_SINK));
+  gst_element_set_name(GST_ELEMENT(sink),name);
+  return sink;
+}

gst/gstsink.h

@@ -0,0 +1,64 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_SINK_H__
+#define __GST_SINK_H__
+
+
+#include <gst/gstelement.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SINK \
+  (gst_sink_get_type())
+#define GST_SINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_SINK,GstSink))
+#define GST_SINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINK,GstSinkClass))
+#define GST_IS_SINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_SINK))
+#define GST_IS_SINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINK)))
+
+typedef struct _GstSink GstSink;
+typedef struct _GstSinkClass GstSinkClass;
+
+struct _GstSink {
+  GstElement element;
+};
+
+struct _GstSinkClass {
+  GstElementClass parent_class;
+};
+
+GtkType gst_sink_get_type(void);
+GstObject *gst_sink_new(gchar *name);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SINK_H__ */

gst/gstsrc.c

@@ -0,0 +1,122 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gst.h>
+
+
+/* Src signals and args */
+enum {
+  EOS,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_src_class_init(GstSrcClass *klass);
+static void gst_src_init(GstSrc *src);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_src_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_src_get_type(void) {
+  static GtkType src_type = 0;
+
+  if (!src_type) {
+    static const GtkTypeInfo src_info = {
+      "GstSrc",
+      sizeof(GstSrc),
+      sizeof(GstSrcClass),
+      (GtkClassInitFunc)gst_src_class_init,
+      (GtkObjectInitFunc)gst_src_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    src_type = gtk_type_unique(GST_TYPE_ELEMENT,&src_info);
+  }
+  return src_type;
+}
+
+static void
+gst_src_class_init(GstSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+
+  gst_src_signals[EOS] =
+    gtk_signal_new("eos",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstSrcClass,eos),
+                   gtk_marshal_NONE__POINTER,GTK_TYPE_NONE,1,
+                   GTK_TYPE_POINTER);
+  gtk_object_class_add_signals(gtkobject_class,gst_src_signals,LAST_SIGNAL);
+}
+
+static void gst_src_init(GstSrc *src) {
+  src->flags = 0;
+}
+
+void gst_src_signal_eos(GstSrc *src) {
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_SRC(src));
+
+  gtk_signal_emit(GTK_OBJECT(src),gst_src_signals[EOS],src);
+}
+
+void gst_src_push(GstSrc *src) {
+  GstSrcClass *oclass;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_SRC(src));
+
+  oclass = (GstSrcClass *)(GTK_OBJECT(src)->klass);
+
+  g_return_if_fail(oclass->push != NULL);
+
+  (oclass->push)(src);
+}
+
+/**
+ * gst_src_push_region:
+ * @src: source to trigger the push of
+ * @offset: offset in source
+ * @size: number of bytes to push
+ *
+ * Push a buffer of a given size from the source.
+ */
+void gst_src_push_region(GstSrc *src,gulong offset,gulong size) {
+  GstSrcClass *oclass;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_SRC(src));
+
+  oclass = (GstSrcClass *)(GTK_OBJECT(src)->klass);
+
+  g_return_if_fail(oclass->push_region != NULL);
+
+  (oclass->push_region)(src,offset,size);
+}
+

gst/gstsrc.h

@@ -0,0 +1,86 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_SRC_H__
+#define __GST_SRC_H__
+
+
+#include <gst/gstelement.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SRC \
+  (gst_src_get_type())
+#define GST_SRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_SRC,GstSrc))
+#define GST_SRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SRC,GstSrcClass))
+#define GST_IS_SRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_SRC))
+#define GST_IS_SRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SRC)))
+
+typedef enum {
+  GST_SRC_ASYNC		= 1 << 0,
+} GstSrcFlags;
+
+#define GST_SRC_FLAGS(obj)	(GST_SRC(obj)->flags)
+#define GST_SRC_ASYNC(obj)	((GST_SRC_FLAGS(obj) & GST_SRC_ASYNC)
+
+typedef struct _GstSrc GstSrc;
+typedef struct _GstSrcClass GstSrcClass;
+
+struct _GstSrc {
+  GstElement element;
+  gint32 flags;
+};
+
+struct _GstSrcClass {
+  GstElementClass parent_class;
+
+  /* subclass functions */
+  void (*push) (GstSrc *src);
+  void (*push_region) (GstSrc *src,gulong offset,gulong size);
+
+  /* signals */
+  void (*eos) (GstSrc *src);
+};
+
+#define GST_SRC_SET_FLAGS(src,flag)   G_STMT_START{ (GST_SRC_FLAGS (src) |= (flag)); }G_STMT_END
+#define GST_SRC_UNSET_FLAGS(src,flag)  G_STMT_START{ (GST_SRC_FLAGS (src) &= ~(flag)); }G_STMT_END
+
+
+GtkType gst_src_get_type(void);
+
+void gst_src_signal_eos(GstSrc *src);
+
+void gst_src_push(GstSrc *src);
+void gst_src_push_region(GstSrc *src,gulong offset,gulong size);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SRC_H__ */

gst/gsttee.c

@@ -0,0 +1,130 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gsttee.h>
+
+
+GstElementDetails gst_tee_details = {
+  "Tee pipe fitting",
+  "Tee",
+  "1ot-N pipe fitting",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+/* Tee signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_tee_class_init(GstTeeClass *klass);
+static void gst_tee_init(GstTee *tee);
+
+static xmlNodePtr gst_tee_save_thyself(GstElement *element,xmlNodePtr parent);
+
+
+static GstFilterClass *parent_class = NULL;
+static guint gst_tee_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_tee_get_type(void) {
+  static GtkType tee_type = 0;
+
+  if (!tee_type) {
+    static const GtkTypeInfo tee_info = {
+      "GstTee",
+      sizeof(GstTee),
+      sizeof(GstTeeClass),
+      (GtkClassInitFunc)gst_tee_class_init,
+      (GtkObjectInitFunc)gst_tee_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    tee_type = gtk_type_unique(GST_TYPE_FILTER,&tee_info);
+  }
+  return tee_type;
+}
+
+static void
+gst_tee_class_init(GstTeeClass *klass) {
+  GstFilterClass *gstfilter_class;
+
+  gstfilter_class = (GstFilterClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_FILTER);
+}
+
+static void gst_tee_init(GstTee *tee) {
+  tee->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(tee),tee->sinkpad);
+  gst_pad_set_chain_function(tee->sinkpad,gst_tee_chain);
+
+  tee->numsrcpads = 0;
+  tee->srcpads = NULL;
+}
+
+GstElement *gst_tee_new(gchar *name) {
+  GstElement *tee = GST_ELEMENT(gtk_type_new(GST_TYPE_TEE));
+  gst_element_set_name(GST_ELEMENT(tee),name);
+  return tee;
+}
+
+gchar *gst_tee_new_pad(GstTee *tee) {
+  gchar *name;
+  GstPad *srcpad;
+
+  g_return_if_fail(tee != NULL);
+  g_return_if_fail(GST_IS_TEE(tee));
+
+  name = g_strdup_printf("src%d",tee->numsrcpads);
+  srcpad = gst_pad_new(name,GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(tee),srcpad);
+  tee->srcpads = g_slist_prepend(tee->srcpads,srcpad);
+  tee->numsrcpads++;
+  return name;
+}
+
+void gst_tee_chain(GstPad *pad,GstBuffer *buf) {
+  GstTee *tee;
+  GSList *srcpads;
+  int i;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  tee = GST_TEE(pad->parent);
+  gst_trace_add_entry(NULL,0,buf,"tee buffer");
+  for (i=0;i<tee->numsrcpads-1;i++)
+    gst_buffer_ref(buf);
+  srcpads = tee->srcpads;
+  while (srcpads) {
+    gst_pad_push(GST_PAD(srcpads->data),buf);
+    srcpads = g_slist_next(srcpads);
+  }
+}

gst/gsttee.h

@@ -0,0 +1,70 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_TEE_H__
+#define __GST_TEE_H__
+
+
+#include <gst/gstfilter.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_TEE \
+  (gst_tee_get_type())
+#define GST_TEE(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_TEE,GstTee))
+#define GST_TEE_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_TEE,GstTeeClass))
+#define GST_IS_TEE(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_TEE))
+#define GST_IS_TEE_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_TEE)))
+
+typedef struct _GstTee GstTee;
+typedef struct _GstTeeClass GstTeeClass;
+
+struct _GstTee {
+  GstFilter filter;
+
+  GstPad *sinkpad;
+
+  gint numsrcpads;
+  GSList *srcpads;
+};
+
+struct _GstTeeClass {
+  GstFilterClass parent_class;
+};
+
+GtkType gst_tee_get_type(void);
+GstElement *gst_tee_new(gchar *name);
+void gst_tee_chain(GstPad *pad,GstBuffer *buf);
+gchar *gst_tee_new_pad(GstTee *tee);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_TEE_H__ */

gst/gstthread.c

@@ -0,0 +1,332 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstthread.h>
+
+GstElementDetails gst_thread_details = {
+  "Threaded container",
+  "Bin",
+  "Container that creates/manages a thread",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* Thread signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_CREATE_THREAD,
+};
+
+
+static void gst_thread_class_init(GstThreadClass *klass);
+static void gst_thread_init(GstThread *thread);
+
+static void gst_thread_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_thread_get_arg(GtkObject *object,GtkArg *arg,guint id);
+static gboolean gst_thread_change_state(GstElement *element,
+                                        GstElementState state);
+
+static xmlNodePtr gst_thread_save_thyself(GstElement *element,xmlNodePtr parent);
+
+static void gst_thread_prepare(GstThread *thread);
+static void gst_thread_signal_thread(GstThread *thread);
+
+
+static GstBin *parent_class = NULL;
+static guint gst_thread_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_thread_get_type(void) {
+  static GtkType thread_type = 0;
+
+  if (!thread_type) {
+    static const GtkTypeInfo thread_info = {
+      "GstThread",
+      sizeof(GstThread),
+      sizeof(GstThreadClass),
+      (GtkClassInitFunc)gst_thread_class_init,
+      (GtkObjectInitFunc)gst_thread_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    thread_type = gtk_type_unique(gst_bin_get_type(),&thread_info);
+  }
+  return thread_type;
+}
+
+static void
+gst_thread_class_init(GstThreadClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstObjectClass *gstobject_class;
+  GstElementClass *gstelement_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstobject_class = (GstObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = gtk_type_class(gst_bin_get_type());
+
+  gtk_object_add_arg_type("GstThread::create_thread", GTK_TYPE_BOOL,
+                          GTK_ARG_READWRITE, ARG_CREATE_THREAD);
+
+  gstelement_class->change_state = gst_thread_change_state;
+//  gstelement_class->save_thyself = gst_thread_save_thyself;
+
+  gtkobject_class->set_arg = gst_thread_set_arg;
+  gtkobject_class->get_arg = gst_thread_get_arg;
+}
+
+static void gst_thread_init(GstThread *thread) {
+  GST_FLAG_SET(thread,GST_THREAD_CREATE);
+
+  thread->entries = NULL;
+  thread->numentries = 0;
+
+  thread->lock = g_mutex_new();
+  thread->cond = g_cond_new();
+}
+
+static void gst_thread_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_THREAD(object));
+
+  switch(id) {
+    case ARG_CREATE_THREAD:
+      if (GTK_VALUE_BOOL(*arg)) {
+        gst_info("turning ON the creation of the thread\n");
+        GST_FLAG_SET(object,GST_THREAD_CREATE);
+        gst_info("flags are 0x%08x\n",GST_FLAGS(object));
+      } else {
+        gst_info("turning OFF the creation of the thread\n");
+        GST_FLAG_UNSET(object,GST_THREAD_CREATE);
+        gst_info("flags are 0x%08x\n",GST_FLAGS(object));
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_thread_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_THREAD(object));
+
+  switch(id) {
+    case ARG_CREATE_THREAD:
+      GTK_VALUE_BOOL(*arg) = GST_FLAG_IS_SET(object,GST_THREAD_CREATE);
+      break;
+    default:
+      break;
+  }
+}
+
+
+GstElement *gst_thread_new(guchar *name) {
+  GstThread *thread;
+
+  thread = gtk_type_new(gst_thread_get_type());
+  gst_element_set_name(GST_ELEMENT(thread),name);
+  return GST_ELEMENT(thread);
+}
+
+
+static void gst_thread_prepare(GstThread *thread) {
+  GList *elements;
+  GstElement *element;
+  GList *pads;
+  GstPad *pad, *peer;
+  GstElement *outside;
+
+  thread->numentries = 0;
+
+  /* first we need to find all the entry points into the thread */
+  elements = GST_BIN(thread)->children;
+  while (elements) {
+    element = GST_ELEMENT(elements->data);
+    if (GST_IS_SRC(element)) {
+      gst_info("element \"%s\" is a source entry point for the thread\n",
+               gst_element_get_name(GST_ELEMENT(element)));
+      thread->entries = g_list_prepend(thread->entries,element);
+      thread->numentries++;
+    } else {
+      /* go through the list of pads to see if there's a Connection */
+      pads = gst_element_get_pad_list(element);
+      while (pads) {
+        pad = GST_PAD(pads->data);
+        /* we only worry about sink pads */
+        if (gst_pad_get_direction(pad) == GST_PAD_SINK) {
+          /* get the pad's peer */
+          peer = gst_pad_get_peer(pad);
+          if (!peer) break;
+          /* get the parent of the peer of the pad */
+          outside = GST_ELEMENT(gst_pad_get_parent(peer));
+          if (!outside) break;
+          /* if it's a connection and it's not ours... */
+          if (GST_IS_CONNECTION(outside) &&
+              (gst_object_get_parent(GST_OBJECT(outside)) != GST_OBJECT(thread))) {
+            gst_info("element \"%s\" is the external source Connection \
+for internal element \"%s\"\n",
+                    gst_element_get_name(GST_ELEMENT(outside)),
+                    gst_element_get_name(GST_ELEMENT(element)));
+            thread->entries = g_list_prepend(thread->entries,outside);
+            thread->numentries++;
+          }
+        }
+        pads = g_list_next(pads);
+      }
+    }
+    elements = g_list_next(elements);
+  }
+  gst_info("have %d entries into thread\n",thread->numentries);
+}
+
+
+static gboolean gst_thread_change_state(GstElement *element,
+                                        GstElementState state) {
+  GstThread *thread;
+  gboolean stateset = TRUE;
+
+  g_return_if_fail(GST_IS_THREAD(element));
+  thread = GST_THREAD(element);
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    stateset = GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!stateset) return FALSE;
+      /* we want to prepare our internal state for doing the iterations */
+      gst_info("preparing thread \"%s\" for iterations:\n",
+               gst_element_get_name(GST_ELEMENT(element)));
+      gst_thread_prepare(thread);
+      if (thread->numentries == 0)
+        return FALSE;
+      /* set the state to idle */
+      GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
+      /* create the thread if that's what we're supposed to do */
+      gst_info("flags are 0x%08x\n",GST_FLAGS(thread));
+      if (GST_FLAG_IS_SET(thread,GST_THREAD_CREATE)) {
+        gst_info("starting thread \"%s\"\n",
+                 gst_element_get_name(GST_ELEMENT(element)));
+        pthread_create(&thread->thread_id,NULL,
+                       gst_thread_main_loop,thread);
+      } else {
+        gst_info("NOT starting thread \"%s\"\n",
+                gst_element_get_name(GST_ELEMENT(element)));
+      }
+      return TRUE;
+      break;
+    case ~GST_STATE_RUNNING:
+      /* stop, reap, and join the thread */
+      GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
+      GST_FLAG_SET(thread,GST_THREAD_STATE_REAPING);
+      gst_thread_signal_thread(thread);
+      pthread_join(thread->thread_id,0);
+      /* tear down the internal state */
+      gst_info("tearing down thread's iteration state\n");
+      /* FIXME do stuff */
+      break;
+    case GST_STATE_PLAYING:
+      if (!stateset) return FALSE;
+      gst_info("starting thread \"%s\"\n",
+              gst_element_get_name(GST_ELEMENT(element)));
+      GST_FLAG_SET(thread,GST_THREAD_STATE_SPINNING);
+      gst_thread_signal_thread(thread);
+      return TRUE;
+      break;  
+    case ~GST_STATE_PLAYING:
+      gst_info("stopping thread \"%s\"\n",
+              gst_element_get_name(GST_ELEMENT(element)));
+      GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
+      gst_thread_signal_thread(thread);
+      break;
+    default:
+      break;
+  }
+
+  return stateset;
+}
+
+
+void *gst_thread_main_loop(void *arg) {
+  GstThread *thread = GST_THREAD(arg);
+
+  gst_info("HI, IN MAIN THREAD LOOP!\n");
+
+  while(!GST_FLAG_IS_SET(thread,GST_THREAD_STATE_REAPING)) {
+    if (GST_FLAG_IS_SET(thread,GST_THREAD_STATE_SPINNING))
+      gst_thread_iterate(thread);
+    else {
+      g_mutex_lock(thread->lock);
+      g_cond_wait(thread->cond,thread->lock);
+      g_mutex_unlock(thread->lock);
+    }
+  }
+
+  GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
+
+  gst_info("GOODBYE, LEAVING MAIN THREAD LOOP!\n");
+  return NULL;
+}
+
+void gst_thread_iterate(GstThread *thread) {
+  GList *entries;
+  GstElement *entry;
+
+  g_return_if_fail(thread != NULL);
+  g_return_if_fail(GST_IS_THREAD(thread));
+//  g_return_if_fail(GST_FLAG_IS_SET(thread,GST_STATE_RUNNING));
+  g_return_if_fail(thread->numentries > 0);
+
+  entries = thread->entries;
+
+  while (entries) {
+    entry = GST_ELEMENT(entries->data);
+    if (GST_IS_SRC(entry))
+      gst_src_push(GST_SRC(entry));
+    else if (GST_IS_CONNECTION(entry))
+      gst_connection_push(GST_CONNECTION(entry));
+    else
+      g_assert_not_reached();
+    entries = g_list_next(entries);
+  }
+//  g_print(",");
+}
+
+static void gst_thread_signal_thread(GstThread *thread) {
+  g_mutex_lock(thread->lock);
+  g_cond_signal(thread->cond);
+  g_mutex_unlock(thread->lock);
+}
+
+static xmlNodePtr gst_thread_save_thyself(GstElement *element,xmlNodePtr parent) {
+  GstThread *thread = GST_THREAD(element);
+  xmlNewChild(parent,NULL,"type","thread");
+
+  if (GST_ELEMENT_CLASS(parent_class)->save_thyself)
+    GST_ELEMENT_CLASS(parent_class)->save_thyself(element,parent);
+}

gst/gstthread.h

@@ -0,0 +1,84 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_THREAD_H__
+#define __GST_THREAD_H__
+
+
+#include <gst/gstbin.h>
+#include <pthread.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+GstElementDetails gst_thread_details;
+
+
+typedef enum {
+  GST_THREAD_CREATE		= (1 << 16),
+  GST_THREAD_STATE_SPINNING	= (1 << 17),
+  GST_THREAD_STATE_REAPING	= (1 << 18),
+} GstThreadState;
+
+
+#define GST_TYPE_THREAD \
+  (gst_thread_get_type())
+#define GST_THREAD(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_THREAD,GstThread))
+#define GST_THREAD_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_THREAD,GstThreadClass))
+#define GST_IS_THREAD(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_THREAD))
+#define GST_IS_THREAD_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_THREAD)))
+
+typedef struct _GstThread GstThread;
+typedef struct _GstThreadClass GstThreadClass;
+
+struct _GstThread {
+  GstBin bin;
+
+  GList *entries;		/* used to determine iterate behavior */
+  gint numentries;		/* number of above entry points */
+
+  pthread_t thread_id;		/* id of the thread, if any */
+  GMutex *lock;			/* thread lock/condititon pair... */
+  GCond *cond;			/* used to control the thread */
+};
+
+struct _GstThreadClass {
+  GstBinClass parent_class;
+};
+
+GtkType gst_thread_get_type(void);
+GstElement *gst_thread_new(guchar *name);
+
+void *gst_thread_main_loop(void *arg);
+void gst_thread_iterate(GstThread *thread);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_THREAD_H__ */     
+

gst/gsttrace.c

@@ -0,0 +1,103 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <glib.h>
+#include <gst/gsttrace.h>
+
+__inline__ void read_tsc(guint64 *dst) {
+  __asm__ __volatile__
+    ("rdtsc"
+     : "=a" (*(guint32 *)dst), "=d" (*(((guint32 *)dst) + 1))
+     :
+     : "eax", "edx");
+}
+
+void gst_trace_read_tsc(guint64 *dst) {
+  read_tsc(dst);
+}
+
+GstTrace *_gst_trace_default = NULL;
+gint _gst_trace_on = 1;
+
+GstTrace *gst_trace_new(guchar *filename,gint size) {
+  GstTrace *trace = g_malloc(sizeof(GstTrace));
+
+  g_return_val_if_fail(trace != NULL,NULL);
+  trace->filename = g_strdup(filename);
+  g_print("opening '%s'\n",trace->filename);
+  trace->fd = open(trace->filename,O_RDWR|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
+  perror("opening trace file");
+  g_return_val_if_fail(trace->fd > 0,NULL);
+  trace->buf = g_malloc(size * sizeof(GstTraceEntry));
+  g_return_val_if_fail(trace->buf != NULL,NULL);
+  trace->bufsize = size;
+  trace->bufoffset = 0;
+
+  return trace;
+}
+
+void gst_trace_destroy(GstTrace *trace) {
+  g_return_if_fail(trace != NULL);
+  g_return_if_fail(trace->buf != NULL);
+
+  if (gst_trace_get_remaining(trace) > 0)
+    gst_trace_flush(trace);
+  close(trace->fd);
+  g_free(trace->buf);
+  g_free(trace);
+}
+
+void gst_trace_flush(GstTrace *trace) {
+  if (!trace) {
+    trace = _gst_trace_default;
+    if (!trace ) return;
+  }
+
+  write(trace->fd,trace->buf,trace->bufoffset * sizeof(GstTraceEntry));
+  trace->bufoffset = 0;
+}
+
+void gst_trace_set_default(GstTrace *trace) {
+  g_return_if_fail(trace != NULL);
+  _gst_trace_default = trace;
+}
+
+void _gst_trace_add_entry(GstTrace *trace,guint32 seq,guint32 data,gchar *msg) {
+  GstTraceEntry *entry;
+  if (!trace) {
+    trace = _gst_trace_default;
+    if (!trace ) return;
+  }
+
+  entry = trace->buf + trace->bufoffset;
+  read_tsc(&(entry->timestamp));
+  entry->sequence = seq;
+  entry->data = data;
+  strncpy(entry->message,msg,112);
+  trace->bufoffset++;
+
+  gst_trace_flush(trace);
+}

gst/gsttrace.h

@@ -0,0 +1,69 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_TRACE_H__
+#define __GST_TRACE_H__
+
+void gst_trace_read_tsc(guint64 *dst);
+
+typedef struct _GstTrace GstTrace;
+typedef struct _GstTraceEntry GstTraceEntry;
+
+struct _GstTrace {
+  /* where this trace is going */
+  gchar *filename;
+  int fd;
+
+  /* current buffer, size, head offset */
+  GstTraceEntry *buf;
+  gint bufsize;
+  gint bufoffset;
+};
+
+struct _GstTraceEntry {
+  guint64 timestamp;
+  guint32 sequence;
+  guint32 data;
+  gchar message[112];
+};
+
+GstTrace *gst_trace_new(guchar *filename,gint size);
+void gst_trace_destroy(GstTrace *trace);
+void gst_trace_flush(GstTrace *trace);
+#define gst_trace_get_size(trace) ((trace)->bufsize)
+#define gst_trace_get_offset(trace) ((trace)->bufoffset)
+#define gst_trace_get_remaining(trace) ((trace)->bufsize - (trace)->bufoffset)
+void gst_trace_set_default(GstTrace *trace);
+
+void _gst_trace_add_entry(GstTrace *trace,guint32 seq,guint32 data,gchar *msg);
+
+#define TRACE_ENABLE
+
+#ifdef TRACE_ENABLE
+extern gint _gst_trace_on;
+#define gst_trace_add_entry(trace,seq,data,msg) \
+  if (_gst_trace_on) { \
+    _gst_trace_add_entry(trace,(guint32)seq,(guint32)data,msg); \
+  }
+#else
+#define gst_trace_add_entry(trace,seq,data,msg)
+#endif
+
+#endif /* __GST_TRACE_H__ */

gst/gsttype.c

@@ -0,0 +1,160 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* TODO:
+ * probably should set up a hash table for the type id's, since currently
+ * it's a rather pathetic linear search.  Eventually there may be dozens
+ * of id's, but in reality there are only so many instances of lookup, so
+ * I'm not overly worried yet...
+ */
+
+
+#include <gst/gst.h>
+
+
+/* global list of registered types */
+GList *_gst_types;
+guint16 _gst_maxtype;
+
+
+void _gst_type_initialize() {
+  _gst_types = NULL;
+  _gst_maxtype = 1;		/* type 0 is undefined */
+
+//  gst_type_audio_register();
+}
+
+guint16 gst_type_register(GstTypeFactory *factory) {
+  guint16 id;
+  GstType *type;
+
+  g_return_if_fail(factory != NULL);
+
+//  id = gst_type_find_by_mime(factory->mime);
+  id = 0;
+  if (!id) {
+    type = (GstType *)malloc(sizeof(GstType));
+
+    type->id = _gst_maxtype++;
+    type->mime = factory->mime;
+    type->exts = factory->exts;
+    type->typefindfunc = factory->typefindfunc;
+    type->srcs = NULL;
+    type->sinks = NULL;
+    _gst_types = g_list_prepend(_gst_types,type);
+
+    id = type->id;
+  } else {
+    type = gst_type_find_by_id(id);
+    /* now we want to try to merge the types and return the original */
+
+    /* FIXME: do extension merging here, not that easy */
+
+    /* if there is no existing typefind function, try to use new one  */
+    if (!type->typefindfunc && factory->typefindfunc)
+      type->typefindfunc = factory->typefindfunc;
+  }
+
+  return id;
+}
+
+guint16 gst_type_find_by_mime(gchar *mime) {
+  GList *walk = _gst_types;
+  GstType *type;
+  gint typelen,mimelen;
+  gchar *search, *found;
+
+//  DEBUG("searching for '%s'\n",mime);
+  mimelen = strlen(mime);
+  while (walk) {
+    type = (GstType *)walk->data;
+    search = type->mime;
+//    DEBUG("checking against '%s'\n",search);
+    typelen = strlen(search);
+    while ((search - type->mime) < typelen) {
+      found = strstr(search,mime);
+      /* if the requested mime is in the list */
+      if (found) {
+        if ((*(found + mimelen) == ' ') ||
+            (*(found + mimelen) == ',') ||
+            (*(found + mimelen) == '\0')) {
+          return type->id;
+        } else {
+          search = found + mimelen;
+        }
+      } else
+        search += mimelen;
+    }
+    walk = g_list_next(walk);
+  }
+
+  return 0;
+}
+
+GstType *gst_type_find_by_id(guint16 id) {
+  GList *walk = _gst_types;
+  GstType *type;
+
+  while (walk) {
+    type = (GstType *)walk->data;
+    if (type->id == id)
+      return type;
+    walk = g_list_next(walk);
+  }
+
+  return NULL;
+}
+
+void gst_type_add_src(guint16 id,GstElementFactory *src) {
+  GstType *type = gst_type_find_by_id(id);
+
+  g_return_if_fail(type != NULL);
+  g_return_if_fail(src != NULL);
+
+  type->srcs = g_list_prepend(type->srcs,src);
+}
+
+void gst_type_add_sink(guint16 id,GstElementFactory *sink) {
+  GstType *type = gst_type_find_by_id(id);
+
+  g_return_if_fail(type != NULL);
+  g_return_if_fail(sink != NULL);
+
+  type->sinks = g_list_prepend(type->sinks,sink);
+}
+
+GList *gst_type_get_srcs(guint16 id) {
+  GstType *type = gst_type_find_by_id(id);
+
+  g_return_if_fail(type != NULL);
+
+  return type->srcs;
+}
+
+GList *gst_type_get_sinks(guint16 id) {
+  GstType *type = gst_type_find_by_id(id);
+
+  g_return_if_fail(type != 0);
+
+  return type->sinks;
+}
+
+GList *gst_type_get_list() {
+  return _gst_types;
+}

gst/gsttype.h

@@ -0,0 +1,76 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_TYPE_H__
+#define __GST_TYPE_H__
+
+
+#include <gst/gstbuffer.h>
+#include <gst/gstelement.h>
+
+
+/* type of function used to check a stream for equality with type */
+typedef gboolean (*GstTypeFindFunc) (GstBuffer *buf,gpointer *private);
+
+typedef struct _GstType GstType;
+typedef struct _GstTypeFactory GstTypeFactory;
+
+struct _GstType {
+  guint16 id;			/* type id (assigned) */
+
+  gchar *mime;			/* MIME type */
+  gchar *exts;			/* space-delimited list of extensions */
+
+  GstTypeFindFunc typefindfunc;	/* typefind function */
+
+  GList *srcs;			/* list of src objects for this type */
+  GList *sinks;			/* list of sink objects for type */
+};
+
+struct _GstTypeFactory {
+  gchar *mime;
+  gchar *exts;
+  GstTypeFindFunc typefindfunc;
+};
+
+
+/* initialize the subsystem */
+void gst_type_initialize();
+
+/* create a new type, or find/merge an existing one */
+guint16 gst_type_register(GstTypeFactory *factory);
+
+/* look up a type by mime or extension */
+guint16 gst_type_find_by_mime(gchar *mime);
+guint16 gst_type_find_by_ext(gchar *ext);
+
+/* add src or sink object */
+void gst_type_add_src(guint16 id,GstElementFactory *src);
+void gst_type_add_sink(guint16 id,GstElementFactory *sink);
+/* get list of src or sink objects */
+GList *gst_type_get_srcs(guint16 id);
+GList *gst_type_get_sinks(guint16 id);
+
+/* get GstType by id */
+GstType *gst_type_find_by_id(guint16 id);
+/* get the list of registered types (returns list of GstType!) */
+GList *gst_type_get_list();
+
+#endif /* __GST_TYPE_H__ */

gst/gsttypefind.c

@@ -0,0 +1,79 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gsttypefind.h>
+
+
+/* TypeFind signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_typefind_class_init(GstTypeFindClass *klass);
+static void gst_typefind_init(GstTypeFind *typefind);
+
+
+static GstElementClass *parent_class = NULL;
+static guint gst_typefind_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_typefind_get_type(void) {
+  static GtkType typefind_type = 0;
+
+  if (!typefind_type) {
+    static const GtkTypeInfo typefind_info = {
+      "GstTypeFind",
+      sizeof(GstTypeFind),
+      sizeof(GstTypeFindClass),
+      (GtkClassInitFunc)gst_typefind_class_init,
+      (GtkObjectInitFunc)gst_typefind_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    typefind_type = gtk_type_unique(GST_TYPE_ELEMENT,&typefind_info);
+  }
+  return typefind_type;
+}
+
+static void
+gst_typefind_class_init(GstTypeFindClass *klass) {
+  GtkObjectClass *gtkobject_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_ELEMENT);
+}
+
+static void gst_typefind_init(GstTypeFind *typefind) {
+}
+
+GstObject *gst_typefind_new(gchar *name) {
+  GstObject *typefind = GST_OBJECT(gtk_type_new(GST_TYPE_TYPEFIND));
+  gst_element_set_name(GST_ELEMENT(typefind),name);
+  return typefind;
+}

gst/gsttypefind.h

@@ -0,0 +1,68 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_TYPEFIND_H__
+#define __GST_TYPEFIND_H__
+
+
+#include <gst/gstelement.h>
+#include <gst/gstpad.h>
+#include <gst/gsttype.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_TYPEFIND \
+  (gst_typefind_get_type())
+#define GST_TYPEFIND(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_TYPEFIND,GstTypeFind))
+#define GST_TYPEFIND_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_TYPEFIND,GstTypeFindClass))
+#define GST_IS_TYPEFIND(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_TYPEFIND))
+#define GST_IS_TYPEFIND_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_TYPEFIND)))
+
+typedef struct _GstTypeFind GstTypeFind;
+typedef struct _GstTypeFindClass GstTypeFindClass;
+
+struct _GstTypeFind {
+  GstElement element;
+
+  GstPad *sinkpad;
+};
+
+struct _GstTypeFindClass {
+  GstElementClass parent_class;
+};
+
+GtkType gst_typefind_get_type(void);
+GstObject *gst_typefind_new(gchar *name);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_TYPEFIND_H__ */

gst/gstutils.c

@@ -0,0 +1,77 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gtk/gtk.h>
+
+gint gst_util_get_int_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_INT(arg);
+}
+
+glong gst_util_get_long_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_LONG(arg);
+}
+
+gfloat gst_util_get_float_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_FLOAT(arg);
+}
+
+gdouble gst_util_get_double_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_DOUBLE(arg);
+}
+
+guchar *gst_util_get_string_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_STRING(arg);
+}
+
+gpointer gst_util_get_pointer_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_VALUE_POINTER(arg);
+}
+
+GtkWidget *gst_util_get_widget_arg(GtkObject *object,guchar *argname) {
+  GtkArg arg;
+
+  arg.name = argname;
+  gtk_object_getv(GTK_OBJECT(object),1,&arg);
+  return GTK_WIDGET(GTK_VALUE_OBJECT(arg));
+}

gst/gstutils.h

@@ -0,0 +1,35 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_UTILS_H__
+#define __GST_UTILS_H__
+
+#include <gtk/gtk.h>
+
+gint gst_util_get_int_arg(GtkObject *object,guchar *argname);
+glong gst_util_get_long_arg(GtkObject *object,guchar *argname);
+gfloat gst_util_get_float_arg(GtkObject *object,guchar *argname);
+gdouble gst_util_get_double_arg(GtkObject *object,guchar *argname);
+guchar *gst_util_get_string_arg(GtkObject *object,guchar *argname);
+gpointer gst_util_get_pointer_arg(GtkObject *object,guchar *argname);
+GtkWidget *gst_util_get_widget_arg(GtkObject *object,guchar *argname);
+
+
+#endif /* __GST_UTILS_H__ */

gst/gstxml.c

@@ -0,0 +1,31 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gstxml.h>
+
+xmlDocPtr gst_xml_write(GstElement *element) {
+  xmlDocPtr doc;
+
+  doc = xmlNewDoc("1.0");
+  doc->root = xmlNewDocNode(doc,NULL,"GST-Pipeline",NULL);
+
+  gst_element_save_thyself(element,doc->root);
+
+  return doc;
+}

gst/gstxml.h

@@ -0,0 +1,30 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_XML_H__
+#define __GST_XML_H__
+
+#include <gst/gst.h>
+#include <gnome-xml/parser.h>
+
+/* create an XML document out of a pipeline */
+xmlDocPtr gst_xml_write(GstElement *element);
+
+#endif /* __GST_XML_H__ */

gst/meta/Makefile.am

@@ -0,0 +1,3 @@
+metaincludedir = $(includedir)/gst/meta
+metainclude_HEADERS =	\
+	audioraw.h

gst/meta/audioraw.h

@@ -0,0 +1,40 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_META_AUDIORAW_H__
+#define __GST_META_AUDIORAW_H__
+
+#include <gst/gstmeta.h>
+#include <sys/soundcard.h>
+
+typedef struct _MetaAudioRaw MetaAudioRaw;
+
+struct _MetaAudioRaw {
+  GstMeta meta;
+
+  /* formatting information */
+  gint format;
+  gint channels;
+  gint frequency;
+  gint bps;
+};
+
+#endif /* __GST_META_AUDIORAW_H__ */
+

gst/meta/spectrum.h

@@ -0,0 +1,38 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gst/gstmeta.h>
+
+typedef struct _MetaAudioSpectrum MetaAudioSpectrum;
+
+struct _MetaAudioSpectrum {
+  GstMeta meta;
+
+  /* data representation */
+  gint16 bands;			/* how many bands are represented */
+  gint8 channels;		/* how many audio channels are there? */
+  gboolean interleaved;		/* are the channels interleaved? */
+
+  /* spectrum details */
+  gint16 lowfreq;
+  gint16 highfreq;
+  gint16 steps;
+};
+

gst/plugin.c

@@ -0,0 +1,139 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+
+/* list of paths to check for plugins */
+GList *_plugin_paths;
+
+/* whether or not to spew library load issues */
+gboolean _plugin_spew = FALSE;
+
+
+void plugin_initialize() {
+  _plugin_paths = NULL;
+
+  /* add the main (installed) library path */
+  _plugin_paths = g_list_prepend(_plugin_paths,PLUGINS_DIR);
+
+  /* if this is set, we add build-directory paths to the list */
+#ifdef PLUGINS_USE_SRCDIR
+  _plugin_paths = g_list_prepend(_plugin_paths,PLUGINS_SRCDIR);
+#endif /* PLUGINS_USE_SRCDIR */
+}
+
+static GModule *plugin_load_recurse(gchar *directory,gchar *name) {
+  DIR *dir;
+  struct dirent *dirent;
+  GModule *mod;
+
+  dir = opendir(directory);
+  if (dir) {
+    while (dirent = readdir(dir)) {
+      /* don't want to recurse in place or backwards */
+      if (strcmp(dirent->d_name,".") && strcmp(dirent->d_name,"..")) {
+        mod = plugin_load_recurse(g_strjoin("/",directory,dirent->d_name,
+                                            NULL),name);
+        if (mod != NULL) {
+          closedir(dir);
+          return mod;
+        }
+      }
+    }
+    closedir(dir);
+  } else {
+    if (strstr(directory,".so")) {
+      gchar *temp;
+      if (name) {
+        if ((temp = strstr(directory,name)) && 
+            (!strcmp(temp,name))) {
+          mod = plugin_load_absolute(directory);
+          if (mod != NULL) return mod;
+        }
+      } else if ((temp = strstr(directory,".so")) &&
+                 (!strcmp(temp,".so"))) {
+        mod = plugin_load_absolute(directory);
+        if (mod != NULL) return mod;
+      }
+    }
+  }
+  return NULL;
+}
+
+/**
+ * plugin_load_all:
+ *
+ * Load all plugins in the path.
+ */
+void plugin_load_all() {
+  GList *path;
+
+  path = _plugin_paths;
+  while (path != NULL) {
+    plugin_load_recurse(path->data,NULL);
+    path = g_list_next(path);
+  }
+}
+
+/**
+ * plugin_load:
+ * @name: name of plugin to load
+ *
+ * Load the named plugin.  Name should be given as
+ * &quot;libplugin.so&quot;.
+ *
+ * Returns: whether the plugin was loaded or not
+ */
+GModule *plugin_load(gchar *name) {
+  GList *path;
+  gchar *libspath;
+  GModule *mod;
+
+//  g_print("attempting to load plugin '%s'\n",name);
+
+  path = _plugin_paths;
+  while (path != NULL) {
+    mod = plugin_load_absolute(g_module_build_path(path->data,name));
+    if (mod != NULL) return mod;
+    libspath = g_strconcat(path->data,"/.libs",NULL);
+//    g_print("trying to load '%s'\n",g_module_build_path(libspath,name));
+    mod = plugin_load_absolute(g_module_build_path(libspath,name));
+    if (mod != NULL) {
+      g_free(libspath);
+      return mod;
+    }
+    g_free(libspath);
+//    g_print("trying to load '%s' from '%s'\n",name,path->data);
+    mod = plugin_load_recurse(path->data,name);
+    if (mod != NULL) return mod;
+    path = g_list_next(path);
+  }
+  return NULL;
+}
+
+/**
+ * plugin_load_absolute:
+ * @name: name of plugin to load
+ *
+ * Returns: whether or not the plugin loaded
+ */
+GModule *plugin_load_absolute(gchar *name) {
+  GModule *mod;
+
+//  g_print("trying to load '%s\n",name);
+
+  if (g_module_supported() == FALSE) {
+    g_print("wow, you built this on a platform without dynamic loading???\n");
+    return;
+  }
+
+  mod = g_module_open(name,0);
+  if (mod != NULL) {
+    return mod;
+  } else if (_gst_plugin_spew) {
+//    if (strstr(g_module_error(),"No such") == NULL)
+      g_print("error loading plugin: %s\n",g_module_error());
+  }
+
+  return NULL;
+}

gst/plugin.h

@@ -0,0 +1,4 @@
+void plugin_initialize();
+void plugin_load_all();
+GModule *plugin_load(gchar *name);
+GModule *plugin_load_absolute(gchar *name);

gst/types/Makefile.am

@@ -0,0 +1,10 @@
+lib_LTLIBRARIES = libgsttypes.la
+
+libgsttypes_la_DEPENDENCIES = ../libgst.la
+libgsttypes_la_SOURCES =	\
+	gsttypes.c
+
+#noinst_HEADERS =
+
+libgsttypes_la_LIBADD = $(GLIB_LIBS) $(GTK_LIBS) $(top_srcdir)/gst/libgst.la
+libgsttypes_la_LDFLAGS = -version-info $(STREAMER_CURRENT):$(STREAMER_REVISION):$(STREAMER_AGE)

gst/types/gsttypes.c

@@ -0,0 +1,85 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gtk/gtk.h>
+#include <gst/gst.h>
+
+gint mp3_typefind(GstBuffer *buf,gpointer *private);
+gint wav_typefind(GstBuffer *buf,gpointer *private);
+
+GstTypeFactory _factories[] = {
+  { "audio/raw", ".raw", NULL },
+  { "audio/mpeg audio/mp3", ".mp2 .mp3 .mpa .mpega", mp3_typefind },
+  { "audio/wav", ".wav", wav_typefind },
+  { "audio/ac3", ".ac3", NULL },
+  { NULL, NULL, NULL },
+};
+
+
+/* check to see if a buffer indicates the presence of an mp3 frame
+ * NOTE that this only checks for a potentially valid mp3 frame header
+ * and doesn't guarantee that it's a fully valid mp3 audio stream */
+gboolean mp3_typefind(GstBuffer *buf,gpointer *private) {
+  gulong head = GULONG_FROM_BE(*((gulong *)GST_BUFFER_DATA(buf)));
+
+  if ((head & 0xffe00000) != 0xffe00000)
+    return FALSE;
+  if (!((head >> 17) & 3))
+    return FALSE;
+  if (((head >> 12) & 0xf) == 0xf)
+    return FALSE;
+  if (!((head >> 12) & 0xf))
+    return FALSE;
+  if (((head >> 10) & 0x3) == 0x3)
+    return FALSE;
+
+  return TRUE;
+}
+
+gboolean wav_typefind(GstBuffer *buf,gpointer *private) {
+  gulong *data = (gulong *)GST_BUFFER_DATA(buf);
+
+  if (data[0] != "RIFF") return FALSE;
+  if (data[2] != "WAVE") return FALSE;
+
+  return TRUE;
+}
+
+
+GstPlugin *plugin_init(GModule *module) {
+  GstPlugin *plugin;
+  int i = 0;
+
+  if (gst_plugin_find("gsttypes") != NULL)
+    return NULL;
+
+  plugin = gst_plugin_new("gsttypes");
+  g_return_val_if_fail(plugin != NULL,NULL);
+
+  while (_factories[i].mime) {
+    gst_type_register(&_factories[i]);
+//    DEBUG("added factory #%d '%s'\n",i,_factories[i].mime);
+    i++;
+  }
+
+  gst_info("gsttypes: loaded %d standard types\n",i);
+
+  return plugin;
+}

install-sh

@@ -0,0 +1,251 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.  It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+		chmodcmd=""
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0

missing

@@ -0,0 +1,190 @@
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+# Franc,ois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# 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, 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., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+case "$1" in
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]"
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing - GNU libit 0.0"
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+  aclocal)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acinclude.m4' or \`configure.in'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`configure.in'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acconfig.h' or \`configure.in'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' configure.in`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case "$f" in
+      *:*) touch_files="$touch_files "`echo "$f" |
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`configure.in'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+	   sed 's/\.am$/.in/' |
+	   while read f; do touch "$f"; done
+    ;;
+
+  bison|yacc)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.y)
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.c
+	    fi
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.h
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f y.tab.h ]; then
+	echo >y.tab.h
+    fi
+    if [ ! -f y.tab.c ]; then
+	echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex|flex)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.l)
+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" lex.yy.c
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f lex.yy.c ]; then
+	echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  makeinfo)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
+    if test -z "$file"; then
+      file=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $file`
+    fi
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and you do not seem to have it handy on your
+         system.  You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequirements for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0

mkinstalldirs

@@ -0,0 +1,40 @@
+#! /bin/sh
+# mkinstalldirs --- make directory hierarchy
+# Author: Noah Friedman <friedman@prep.ai.mit.edu>
+# Created: 1993-05-16
+# Public domain
+
+# $Id$
+
+errstatus=0
+
+for file
+do
+   set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
+   shift
+
+   pathcomp=
+   for d
+   do
+     pathcomp="$pathcomp$d"
+     case "$pathcomp" in
+       -* ) pathcomp=./$pathcomp ;;
+     esac
+
+     if test ! -d "$pathcomp"; then
+        echo "mkdir $pathcomp"
+
+        mkdir "$pathcomp" || lasterr=$?
+
+        if test ! -d "$pathcomp"; then
+  	  errstatus=$lasterr
+        fi
+     fi
+
+     pathcomp="$pathcomp/"
+   done
+done
+
+exit $errstatus
+
+# mkinstalldirs ends here

plugins/elements/Makefile.am

@@ -0,0 +1,35 @@
+lib_LTLIBRARIES = libgstelements.la
+
+libgstelements_la_DEPENDENCIES = ../libgst.la
+libgstelements_la_SOURCES =	\
+	gstelements.c		\
+	gstfakesrc.c		\
+	gstidentity.c		\
+	gstfakesink.c		\
+	gstdisksrc.c		\
+	gstasyncdisksrc.c	\
+	gstfdsrc.c		\
+	gsthttpsrc.c		\
+	gstaudiosink.c		\
+	gstaudiosrc.c		\
+	gstfdsink.c		\
+	gstqueue.c		\
+	gstsinesrc.c
+
+noinst_HEADERS =		\
+	gstfakesrc.h		\
+	gstidentity.h		\
+	gstfakesink.h		\
+	gstdisksrc.h		\
+	gstasyncdisksrc.h	\
+	gstfdsrc.h		\
+	gsthttpsrc.h		\
+	gstaudiosink.h		\
+	gstaudiosrc.h		\
+	gstfdsink.h		\
+	gstqueue.h		\
+	gstsinesrc.h
+
+libgstelements_la_LIBADD = $(GLIB_LIBS) $(GTK_LIBS) \
+			   $(top_srcdir)/gst/libgst.la
+libgstelements_la_LDFLAGS = -version-info $(STREAMER_CURRENT):$(STREAMER_REVISION):$(STREAMER_AGE)

plugins/elements/gstasyncdisksrc.c

@@ -0,0 +1,346 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <gstasyncdisksrc.h>
+
+
+GstElementDetails gst_asyncdisksrc_details = {
+  "Asynchronous Disk Source",
+  "Source/File",
+  "Read from arbitrary point in a file",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* AsyncDiskSrc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_BYTESPERREAD,
+  ARG_LENGTH,
+  ARG_OFFSET,
+};
+
+
+static void gst_asyncdisksrc_class_init(GstAsyncDiskSrcClass *klass);
+static void gst_asyncdisksrc_init(GstAsyncDiskSrc *asyncdisksrc);
+static void gst_asyncdisksrc_set_arg(GtkObject *object,GtkArg *arg,guint id);
+static void gst_asyncdisksrc_get_arg(GtkObject *object,GtkArg *arg,guint id);
+
+static void gst_asyncdisksrc_push(GstSrc *src);
+static void gst_asyncdisksrc_push_region(GstSrc *src,gulong offset,
+                                         gulong size);
+static gboolean gst_asyncdisksrc_change_state(GstElement *element,
+                                              GstElementState state);
+
+
+static GstSrcClass *parent_class = NULL;
+static guint gst_asyncdisksrc_signals[LAST_SIGNAL] = { 0 };
+
+GtkType
+gst_asyncdisksrc_get_type(void) {
+  static GtkType asyncdisksrc_type = 0;
+
+  if (!asyncdisksrc_type) {
+    static const GtkTypeInfo asyncdisksrc_info = {
+      "GstAsyncDiskSrc",
+      sizeof(GstAsyncDiskSrc),
+      sizeof(GstAsyncDiskSrcClass),
+      (GtkClassInitFunc)gst_asyncdisksrc_class_init,
+      (GtkObjectInitFunc)gst_asyncdisksrc_init,
+      (GtkArgSetFunc)gst_asyncdisksrc_set_arg,
+      (GtkArgGetFunc)gst_asyncdisksrc_get_arg,
+      (GtkClassInitFunc)NULL,
+    };
+    asyncdisksrc_type = gtk_type_unique(GST_TYPE_SRC,&asyncdisksrc_info);
+  }
+  return asyncdisksrc_type;
+}
+
+static void
+gst_asyncdisksrc_class_init(GstAsyncDiskSrcClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+  GstSrcClass *gstsrc_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+  gstsrc_class = (GstSrcClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_SRC);
+
+  gtk_object_add_arg_type("GstAsyncDiskSrc::location", GTK_TYPE_STRING,
+                          GTK_ARG_READWRITE, ARG_LOCATION);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::bytesperread", GTK_TYPE_INT,
+                          GTK_ARG_READWRITE, ARG_BYTESPERREAD);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::length", GTK_TYPE_LONG,
+                          GTK_ARG_READABLE, ARG_LENGTH);
+  gtk_object_add_arg_type("GstAsyncDiskSrc::offset", GTK_TYPE_LONG,
+                          GTK_ARG_READWRITE, ARG_OFFSET);
+
+  gtkobject_class->set_arg = gst_asyncdisksrc_set_arg;
+  gtkobject_class->get_arg = gst_asyncdisksrc_get_arg;
+
+  gstelement_class->change_state = gst_asyncdisksrc_change_state;
+
+  gstsrc_class->push = gst_asyncdisksrc_push;
+  gstsrc_class->push_region = gst_asyncdisksrc_push_region;
+}
+
+static void gst_asyncdisksrc_init(GstAsyncDiskSrc *asyncdisksrc) {
+  GST_SRC_SET_FLAGS(asyncdisksrc,GST_SRC_ASYNC);
+
+  asyncdisksrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(asyncdisksrc),asyncdisksrc->srcpad);
+
+  asyncdisksrc->filename = NULL;
+  asyncdisksrc->fd = 0;
+  asyncdisksrc->size = 0;
+  asyncdisksrc->map = NULL;
+  asyncdisksrc->curoffset = 0;
+  asyncdisksrc->bytes_per_read = 4096;
+  asyncdisksrc->seq = 0;
+}
+
+
+static void gst_asyncdisksrc_set_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAsyncDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(object));
+  src = GST_ASYNCDISKSRC(object);
+
+  switch(id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->filename) g_free(src->filename);
+      /* clear the filename if we get a NULL (is that possible?) */
+      if (GTK_VALUE_STRING(*arg) == NULL) {
+        src->filename = NULL;
+        gst_element_set_state(GST_ELEMENT(object),~GST_STATE_COMPLETE);
+      /* otherwise set the new filename */
+      } else {
+        src->filename = g_strdup(GTK_VALUE_STRING(*arg));
+        gst_element_set_state(GST_ELEMENT(object),GST_STATE_COMPLETE);
+      }
+      break;
+    case ARG_BYTESPERREAD:
+      src->bytes_per_read = GTK_VALUE_INT(*arg);
+      break;
+    case ARG_OFFSET:
+      src->curoffset = GTK_VALUE_LONG(*arg);
+      break;
+    default:
+      break;
+  }
+}
+
+static void gst_asyncdisksrc_get_arg(GtkObject *object,GtkArg *arg,guint id) {
+  GstAsyncDiskSrc *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(object));
+  src = GST_ASYNCDISKSRC(object);
+
+  switch (id) {
+    case ARG_LOCATION:
+      GTK_VALUE_STRING(*arg) = src->filename;
+      break;
+    case ARG_BYTESPERREAD:
+      GTK_VALUE_INT(*arg) = src->bytes_per_read;
+      break;
+    case ARG_LENGTH:
+      GTK_VALUE_LONG(*arg) = src->size;
+      break;
+    case ARG_OFFSET:
+      GTK_VALUE_LONG(*arg) = src->curoffset;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+  }
+}
+
+/**
+ * gst_asyncdisksrc_push:
+ * @src: #GstSrc to push a buffer from
+ *
+ * Push a new buffer from the asyncdisksrc at the current offset.
+ */
+void gst_asyncdisksrc_push(GstSrc *src) {
+  GstAsyncDiskSrc *asyncdisksrc;
+  GstBuffer *buf;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(src));
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+  asyncdisksrc = GST_ASYNCDISKSRC(src);
+
+  /* deal with EOF state */
+  if (asyncdisksrc->curoffset >= asyncdisksrc->size) {
+    gst_src_signal_eos(GST_SRC(asyncdisksrc));
+    return;
+  }
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = GST_BUFFER(gst_buffer_new());
+  g_return_if_fail(buf != NULL);
+
+  /* simply set the buffer to point to the correct region of the file */
+  GST_BUFFER_DATA(buf) = asyncdisksrc->map + asyncdisksrc->curoffset;
+  GST_BUFFER_OFFSET(buf) = asyncdisksrc->curoffset;
+
+  if ((asyncdisksrc->curoffset + asyncdisksrc->bytes_per_read) >
+      asyncdisksrc->size) {
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->size - asyncdisksrc->curoffset;
+    // FIXME: set the buffer's EOF bit here
+  } else
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->bytes_per_read;
+  asyncdisksrc->curoffset += GST_BUFFER_SIZE(buf);
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(asyncdisksrc->srcpad,buf);
+}
+
+/**
+ * gst_asyncdisksrc_push_region:
+ * @src: #GstSrc to push a buffer from
+ * @offset: offset in file
+ * @size: number of bytes
+ *
+ * Push a new buffer from the asyncdisksrc of given size at given offset.
+ */
+void gst_asyncdisksrc_push_region(GstSrc *src,gulong offset,gulong size) {
+  GstAsyncDiskSrc *asyncdisksrc;
+  GstBuffer *buf;
+
+  g_return_if_fail(src != NULL);
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(src));
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+  asyncdisksrc = GST_ASYNCDISKSRC(src);
+
+  /* deal with EOF state */
+  if (offset >= asyncdisksrc->size) {
+    gst_src_signal_eos(GST_SRC(asyncdisksrc));
+    return;
+  }
+
+  /* create the buffer */
+  // FIXME: should eventually use a bufferpool for this
+  buf = gst_buffer_new();
+  g_return_if_fail(buf);
+
+  /* simply set the buffer to point to the correct region of the file */
+  GST_BUFFER_DATA(buf) = asyncdisksrc->map + offset;
+  GST_BUFFER_OFFSET(buf) = asyncdisksrc->curoffset;
+
+  if ((offset + size) > asyncdisksrc->size) {
+    GST_BUFFER_SIZE(buf) = asyncdisksrc->size - offset;
+    // FIXME: set the buffer's EOF bit here
+  } else
+    GST_BUFFER_SIZE(buf) = size;
+  asyncdisksrc->curoffset += GST_BUFFER_SIZE(buf);
+
+  /* we're done, push the buffer off now */
+  gst_pad_push(asyncdisksrc->srcpad,buf);
+}
+
+
+/* open the file and mmap it, necessary to go to RUNNING state */
+static gboolean gst_asyncdisksrc_open_file(GstAsyncDiskSrc *src) {
+  g_return_if_fail(!GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+
+  /* open the file */
+  src->fd = open(src->filename,O_RDONLY);
+  if (src->fd < 0) {
+    gst_element_error(GST_ELEMENT(src),"opening file");
+    return FALSE;
+  } else {
+    /* find the file length */
+    src->size = lseek(src->fd,0,SEEK_END);
+    lseek(src->fd,0,SEEK_SET);
+    /* map the file into memory */
+    src->map = mmap(NULL,src->size,PROT_READ,MAP_SHARED,src->fd,0);
+    /* collapse state if that failed */
+    if (src->map == NULL) {
+      close(src->fd);
+      gst_element_error(GST_ELEMENT(src),"mmapping file");
+      return FALSE;
+    }
+    GST_FLAG_SET(src,GST_ASYNCDISKSRC_OPEN);
+  }
+  return TRUE;
+}
+
+/* unmap and close the file */
+static void gst_asyncdisksrc_close_file(GstAsyncDiskSrc *src) {
+  g_return_if_fail(GST_FLAG_IS_SET(src,GST_ASYNCDISKSRC_OPEN));
+
+  /* unmap the file from memory */
+  munmap(src->map,src->size);
+  /* close the file */
+  close(src->fd);
+
+  /* zero out a lot of our state */
+  src->fd = 0;
+  src->size = 0;
+  src->map = NULL;
+  src->curoffset = 0;
+  src->seq = 0;
+
+  GST_FLAG_UNSET(src,GST_ASYNCDISKSRC_OPEN);
+}
+
+
+static gboolean gst_asyncdisksrc_change_state(GstElement *element,
+                                              GstElementState state) {
+  g_return_if_fail(GST_IS_ASYNCDISKSRC(element));
+
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_asyncdisksrc_open_file(GST_ASYNCDISKSRC(element)))
+        return FALSE;
+      break;
+    case ~GST_STATE_RUNNING:
+      gst_asyncdisksrc_close_file(GST_ASYNCDISKSRC(element));
+      break;
+    default:
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}

plugins/elements/gstasyncdisksrc.h

@@ -0,0 +1,88 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_ASYNCDISKSRC_H__
+#define __GST_ASYNCDISKSRC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_asyncdisksrc_details;
+
+
+#define GST_TYPE_ASYNCDISKSRC \
+  (gst_asyncdisksrc_get_type())
+#define GST_ASYNCDISKSRC(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
+#define GST_ASYNCDISKSRC_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
+#define GST_IS_ASYNCDISKSRC(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
+#define GST_IS_ASYNCDISKSRC_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC)))
+
+// NOTE: per-element flags start with 16 for now
+typedef enum {
+  GST_ASYNCDISKSRC_OPEN	= (1 << 16),
+} GstAsyncDiskSrcFlags;
+
+typedef struct _GstAsyncDiskSrc GstAsyncDiskSrc;
+typedef struct _GstAsyncDiskSrcClass GstAsyncDiskSrcClass;
+
+struct _GstAsyncDiskSrc {
+  GstSrc src;
+  /* pads */
+  GstPad *srcpad;
+
+  /* filename */
+  gchar *filename;
+  /* fd */
+  gint fd;
+
+  /* mapping parameters */
+  gulong size;				/* how long is the file? */
+  guchar *map;				/* where the file is mapped to */
+
+  /* details for fallback synchronous read */
+  gulong curoffset;			/* current offset in file */
+  gulong bytes_per_read;		/* bytes per read */
+
+  gulong seq;				/* buffer sequence number */
+};
+
+struct _GstAsyncDiskSrcClass {
+  GstSrcClass parent_class;
+};
+
+GtkType gst_asyncdisksrc_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_ASYNCDISKSRC_H__ */

plugins/elements/gstaudiosink.c

@@ -0,0 +1,291 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+
+#include <gstaudiosink.h>
+#include <gst/meta/audioraw.h>
+
+
+GstElementDetails gst_audiosink_details = {  
+  "Audio Sink (OSS)",
+  "Sink/Audio",
+  "Output to a sound card via OSS",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+static gboolean gst_audiosink_open_audio(GstAudioSink *sink);
+static void gst_audiosink_close_audio(GstAudioSink *sink);
+static gboolean gst_audiosink_start(GstElement *element,
+                                    GstElementState state);
+static gboolean gst_audiosink_stop(GstElement *element);
+static gboolean gst_audiosink_change_state(GstElement *element,
+                                           GstElementState state);
+
+
+/* AudioSink signals and args */
+enum {
+  HANDOFF,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+
+static void gst_audiosink_class_init(GstAudioSinkClass *klass);
+static void gst_audiosink_init(GstAudioSink *audiosink);
+
+
+static GstFilterClass *parent_class = NULL;
+static guint gst_audiosink_signals[LAST_SIGNAL] = { 0 };
+
+static guint16 gst_audiosink_type_audio = 0;
+
+GtkType
+gst_audiosink_get_type(void) {
+  static GtkType audiosink_type = 0;
+
+  if (!audiosink_type) {
+    static const GtkTypeInfo audiosink_info = {
+      "GstAudioSink",
+      sizeof(GstAudioSink),
+      sizeof(GstAudioSinkClass),
+      (GtkClassInitFunc)gst_audiosink_class_init,
+      (GtkObjectInitFunc)gst_audiosink_init,
+      (GtkArgSetFunc)NULL,
+      (GtkArgGetFunc)NULL,
+      (GtkClassInitFunc)NULL,
+    };
+    audiosink_type = gtk_type_unique(GST_TYPE_FILTER,&audiosink_info);
+  }
+
+  if (!gst_audiosink_type_audio)
+    gst_audiosink_type_audio = gst_type_find_by_mime("audio/raw");
+
+  return audiosink_type;
+}
+
+static void
+gst_audiosink_class_init(GstAudioSinkClass *klass) {
+  GtkObjectClass *gtkobject_class;
+  GstElementClass *gstelement_class;
+
+  gtkobject_class = (GtkObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = gtk_type_class(GST_TYPE_FILTER);
+
+  gst_audiosink_signals[HANDOFF] =
+    gtk_signal_new("handoff",GTK_RUN_LAST,gtkobject_class->type,
+                   GTK_SIGNAL_OFFSET(GstAudioSinkClass,handoff),
+                   gtk_marshal_NONE__POINTER_POINTER,GTK_TYPE_NONE,2,
+                   GTK_TYPE_POINTER,GTK_TYPE_POINTER);
+  gtk_object_class_add_signals(gtkobject_class,gst_audiosink_signals,
+                               LAST_SIGNAL);
+
+  gstelement_class->start = gst_audiosink_start;
+  gstelement_class->stop = gst_audiosink_stop;
+  gstelement_class->change_state = gst_audiosink_change_state;
+}
+
+static void gst_audiosink_init(GstAudioSink *audiosink) {
+  audiosink->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(audiosink),audiosink->sinkpad);
+  if (!gst_audiosink_type_audio)
+    gst_audiosink_type_audio = gst_type_find_by_mime("audio/raw");
+  gst_pad_set_type_id(audiosink->sinkpad,gst_audiosink_type_audio);
+  gst_pad_set_chain_function(audiosink->sinkpad,gst_audiosink_chain);
+
+  audiosink->fd = -1;
+
+  gst_element_set_state(GST_ELEMENT(audiosink),GST_STATE_COMPLETE);
+}
+
+void gst_audiosink_sync_parms(GstAudioSink *audiosink) {
+  audio_buf_info ospace;
+
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+  g_return_if_fail(audiosink->fd > 0);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_RESET,0);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_SETFMT,&audiosink->format);
+  ioctl(audiosink->fd,SNDCTL_DSP_CHANNELS,&audiosink->channels);
+  ioctl(audiosink->fd,SNDCTL_DSP_SPEED,&audiosink->frequency);
+
+  ioctl(audiosink->fd,SNDCTL_DSP_GETOSPACE,&ospace);
+
+  g_print("setting sound card to %dKHz %d bit %s (%d bytes buffer)\n",
+          audiosink->frequency,audiosink->format,
+          (audiosink->channels == 2) ? "stereo" : "mono",ospace.bytes);
+}
+
+GstElement *gst_audiosink_new(gchar *name) {
+  GstElement *audiosink = GST_ELEMENT(gtk_type_new(GST_TYPE_AUDIOSINK));
+  gst_element_set_name(GST_ELEMENT(audiosink),name);
+  return audiosink;
+}
+
+void gst_audiosink_chain(GstPad *pad,GstBuffer *buf) {
+  GstAudioSink *audiosink;
+  MetaAudioRaw *meta;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  /* this has to be an audio buffer */
+//  g_return_if_fail(((GstMeta *)buf->meta)->type !=
+//gst_audiosink_type_audio);
+  audiosink = GST_AUDIOSINK(pad->parent);
+//  g_return_if_fail(GST_FLAG_IS_SET(audiosink,GST_STATE_RUNNING));
+
+  meta = (MetaAudioRaw *)gst_buffer_get_first_meta(buf);
+  if (meta != NULL) {
+    if ((meta->format != audiosink->format) ||
+        (meta->channels != audiosink->channels) ||
+        (meta->frequency != audiosink->frequency)) {
+      audiosink->format = meta->format;
+      audiosink->channels = meta->channels;
+      audiosink->frequency = meta->frequency;
+      gst_audiosink_sync_parms(audiosink);
+      g_print("sound device set to format %d, %d channels, %dHz\n",
+              audiosink->format,audiosink->channels,audiosink->frequency);
+    }
+  }
+
+  gtk_signal_emit(GTK_OBJECT(audiosink),gst_audiosink_signals[HANDOFF],
+                  audiosink);
+  if (GST_BUFFER_DATA(buf) != NULL) {
+    gst_trace_add_entry(NULL,0,buf,"audiosink: writing to soundcard");
+    if (audiosink->fd > 2)
+      write(audiosink->fd,GST_BUFFER_DATA(buf),GST_BUFFER_SIZE(buf));
+  }
+
+  gst_buffer_unref(buf);
+//  g_print("a");
+}
+
+void gst_audiosink_set_format(GstAudioSink *audiosink,gint format) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->format = format;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+void gst_audiosink_set_channels(GstAudioSink *audiosink,gint channels) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->channels = channels;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+void gst_audiosink_set_frequency(GstAudioSink *audiosink,gint frequency) {
+  g_return_if_fail(audiosink != NULL);
+  g_return_if_fail(GST_IS_AUDIOSINK(audiosink));
+
+  audiosink->frequency = frequency;
+  
+  gst_audiosink_sync_parms(audiosink);
+}
+
+static gboolean gst_audiosink_open_audio(GstAudioSink *sink) {
+  g_return_if_fail(sink->fd == -1);
+
+  g_print("attempting to open sound device\n");
+
+  /* first try to open the sound card */
+  sink->fd = open("/dev/dsp",O_RDWR);
+
+  /* if we have it, set the default parameters and go have fun */
+  if (sink->fd > 0) {
+    /* set card state */
+    sink->format = AFMT_S16_LE;
+    sink->channels = 2; /* stereo */
+    sink->frequency = 44100;
+    gst_audiosink_sync_parms(sink);
+    g_print("opened audio\n");
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+static void gst_audiosink_close_audio(GstAudioSink *sink) {
+  if (sink->fd < 0) return;
+
+  close(sink->fd);
+  sink->fd = -1;
+  g_print("closed sound device\n");
+}
+
+static gboolean gst_audiosink_start(GstElement *element,
+                                    GstElementState state) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+
+  if (gst_audiosink_open_audio(GST_AUDIOSINK(element)) == TRUE) {
+    gst_element_set_state(element,GST_STATE_RUNNING | state);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+static gboolean gst_audiosink_stop(GstElement *element) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+
+  gst_audiosink_close_audio(GST_AUDIOSINK(element));
+  gst_element_set_state(element,~GST_STATE_RUNNING);
+  return TRUE;
+}
+
+static gboolean gst_audiosink_change_state(GstElement *element,
+                                           GstElementState state) {
+  g_return_if_fail(GST_IS_AUDIOSINK(element));
+      
+  switch (state) {
+    case GST_STATE_RUNNING:
+      if (!gst_audiosink_open_audio(GST_AUDIOSINK(element)))
+        return FALSE;
+      break;  
+    case ~GST_STATE_RUNNING:
+      gst_audiosink_close_audio(GST_AUDIOSINK(element));
+      break;
+    default:
+      break;
+  }     
+      
+  if (GST_ELEMENT_CLASS(parent_class)->change_state)
+    return GST_ELEMENT_CLASS(parent_class)->change_state(element,state);
+  return TRUE;
+}

plugins/elements/gstaudiosink.h

@@ -0,0 +1,85 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_AUDIOSINK_H__
+#define __GST_AUDIOSINK_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+GstElementDetails gst_audiosink_details;
+
+
+#define GST_TYPE_AUDIOSINK \
+  (gst_audiosink_get_type())
+#define GST_AUDIOSINK(obj) \
+  (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSINK,GstAudioSink))
+#define GST_AUDIOSINK_CLASS(klass) \
+  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSINK,GstAudioSinkClass))
+#define GST_IS_AUDIOSINK(obj) \
+  (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSINK))
+#define GST_IS_AUDIOSINK_CLASS(obj) \
+  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSINK)))
+
+typedef struct _GstAudioSink GstAudioSink;
+typedef struct _GstAudioSinkClass GstAudioSinkClass;
+
+struct _GstAudioSink {
+  GstFilter filter;
+
+  GstPad *sinkpad;
+
+  /* soundcard state */
+  int fd;
+  gint format;
+  gint channels;
+  gint frequency;
+};
+
+struct _GstAudioSinkClass {
+  GstFilterClass parent_class;
+
+  /* signals */
+  void (*handoff) (GstElement *element,GstPad *pad);
+};
+
+GtkType gst_audiosink_get_type(void);
+GstElement *gst_audiosink_new(gchar *name);
+void gst_audiosink_chain(GstPad *pad,GstBuffer *buf);
+
+void gst_audiosink_sync_parms(GstAudioSink *audiosink);
+
+void gst_audiosink_set_format(GstAudioSink *audiosink,gint format);
+void gst_audiosink_set_channels(GstAudioSink *audiosink,gint channels);
+void gst_audiosink_set_frequency(GstAudioSink *audiosink,gint frequency);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_AUDIOSINK_H__ */