diff -Nru gst-plugins-good0.10-0.10.25/debian/changelog gst-plugins-good0.10-0.10.25/debian/changelog --- gst-plugins-good0.10-0.10.25/debian/changelog 2010-12-10 13:01:22.000000000 +0000 +++ gst-plugins-good0.10-0.10.25/debian/changelog 2010-12-13 02:22:32.000000000 +0000 @@ -1,4 +1,4 @@ -gst-plugins-good0.10 (0.10.25-4ubuntu3~diwic1) maverick; urgency=low +gst-plugins-good0.10 (0.10.25-4ubuntu3~diwic2) maverick; urgency=low * Fighting rewinds test diff -Nru gst-plugins-good0.10-0.10.25/debian/patches/debian-changes-0.10.25-4ubuntu3~diwic2 gst-plugins-good0.10-0.10.25/debian/patches/debian-changes-0.10.25-4ubuntu3~diwic2 --- gst-plugins-good0.10-0.10.25/debian/patches/debian-changes-0.10.25-4ubuntu3~diwic2 1970-01-01 00:00:00.000000000 +0000 +++ gst-plugins-good0.10-0.10.25/debian/patches/debian-changes-0.10.25-4ubuntu3~diwic2 2010-12-13 03:24:44.000000000 +0000 @@ -0,0 +1,19007 @@ +Description: Upstream changes introduced in version 0.10.25-4ubuntu3~diwic2 + This patch has been created by dpkg-source during the package build. + Here's the last changelog entry, hopefully it gives details on why + those changes were made: + . + gst-plugins-good0.10 (0.10.25-4ubuntu3~diwic2) maverick; urgency=low + . + * Fighting rewinds test + . + The person named in the Author field signed this changelog entry. +Author: David Henningsson + +--- +The information above should follow the Patch Tagging Guidelines, please +checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here +are templates for supplementary fields that you might want to add: + +Origin: , +Bug: +Bug-Debian: http://bugs.debian.org/ +Bug-Ubuntu: https://launchpad.net/bugs/ +Forwarded: +Reviewed-By: +Last-Update: + +--- /dev/null ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins.args.new +@@ -0,0 +1,4540 @@ ++ ++GstVideoCrop::bottom ++gint ++>= 0 ++rw ++Bottom ++Pixels to crop at bottom. ++0 ++ ++ ++ ++GstVideoCrop::left ++gint ++>= 0 ++rw ++Left ++Pixels to crop at left. ++0 ++ ++ ++ ++GstVideoCrop::right ++gint ++>= 0 ++rw ++Right ++Pixels to crop at right. ++0 ++ ++ ++ ++GstVideoCrop::top ++gint ++>= 0 ++rw ++Top ++Pixels to crop at top. ++0 ++ ++ ++ ++GstAspectRatioCrop::aspect-ratio ++GstFraction ++ ++rw ++aspect-ratio ++Target aspect-ratio of video. ++ ++ ++ ++ ++GstMultiFileSrc::caps ++GstCaps* ++ ++rw ++Caps ++Caps describing the format of the data. ++ ++ ++ ++ ++GstMultiFileSrc::index ++gint ++>= 0 ++rw ++File Index ++Index to use with location property to create file names. The index is incremented by one for each buffer read. ++0 ++ ++ ++ ++GstMultiFileSrc::location ++gchar* ++ ++rw ++File Location ++Pattern to create file names of input files. File names are created by calling sprintf() with the pattern and the current index. ++"%05d" ++ ++ ++ ++GstMultiFileSink::index ++gint ++>= 0 ++rw ++Index ++Index to use with location property to create file names. The index is incremented by one for each buffer written. ++0 ++ ++ ++ ++GstMultiFileSink::location ++gchar* ++ ++rw ++File Location ++Location of the file to write. ++NULL ++ ++ ++ ++GstMultiFileSink::next-file ++GstMultiFileSinkNext ++ ++rw ++Next File ++When to start a new file. ++New file for each buffer ++ ++ ++ ++GstMultiFileSink::post-messages ++gboolean ++ ++rw ++Post Messages ++Post a message for each file with information of the buffer. ++FALSE ++ ++ ++ ++GstAlpha::alpha ++gdouble ++[0,1] ++rw ++Alpha ++The value for the alpha channel. ++1 ++ ++ ++ ++GstAlpha::angle ++gfloat ++[0,90] ++rw ++Angle ++Size of the colorcube to change. ++20 ++ ++ ++ ++GstAlpha::black-sensitivity ++guint ++<= 128 ++rw ++Black Sensitivity ++Sensitivity to dark colors. ++100 ++ ++ ++ ++GstAlpha::method ++GstAlphaMethod ++ ++rw ++Method ++How the alpha channels should be created. ++Set/adjust alpha channel ++ ++ ++ ++GstAlpha::noise-level ++gfloat ++[0,64] ++rw ++Noise Level ++Size of noise radius. ++2 ++ ++ ++ ++GstAlpha::prefer-passthrough ++gboolean ++ ++rw ++Prefer Passthrough ++Don't do any processing for alpha=1.0 if possible. ++FALSE ++ ++ ++ ++GstAlpha::target-b ++guint ++<= 255 ++rw ++Target Blue ++The Blue target. ++0 ++ ++ ++ ++GstAlpha::target-g ++guint ++<= 255 ++rw ++Target Green ++The Green target. ++255 ++ ++ ++ ++GstAlpha::target-r ++guint ++<= 255 ++rw ++Target Red ++The Red target. ++0 ++ ++ ++ ++GstAlpha::white-sensitivity ++guint ++<= 128 ++rw ++Sensitivity ++Sensitivity to bright colors. ++100 ++ ++ ++ ++GstFlvMux::streamable ++gboolean ++ ++rw ++streamable ++If set to true, the output should be as if it is to be streamed and hence no indexes written or duration written. ++FALSE ++ ++ ++ ++GstVideoFlip::method ++GstVideoFlipMethod ++ ++rw ++method ++method. ++Identity (no rotation) ++ ++ ++ ++GstVideoBalance::brightness ++gdouble ++[-1,1] ++rw ++Brightness ++brightness. ++0 ++ ++ ++ ++GstVideoBalance::contrast ++gdouble ++[0,2] ++rw ++Contrast ++contrast. ++1 ++ ++ ++ ++GstVideoBalance::hue ++gdouble ++[-1,1] ++rw ++Hue ++hue. ++0 ++ ++ ++ ++GstVideoBalance::saturation ++gdouble ++[0,2] ++rw ++Saturation ++saturation. ++1 ++ ++ ++ ++GstGamma::gamma ++gdouble ++[0.01,10] ++rw ++Gamma ++gamma. ++1 ++ ++ ++ ++GstSpectrum::bands ++guint ++ ++rw ++Bands ++Number of frequency bands. ++128 ++ ++ ++ ++GstSpectrum::interval ++guint64 ++>= 1 ++rw ++Interval ++Interval of time between message posts (in nanoseconds). ++100000000 ++ ++ ++ ++GstSpectrum::message ++gboolean ++ ++rw ++Message ++Whether to post a 'spectrum' element message on the bus for each passed interval (deprecated, use post-messages). ++TRUE ++ ++ ++ ++GstSpectrum::message-magnitude ++gboolean ++ ++rw ++Magnitude ++Whether to add a 'magnitude' field to the structure of any 'spectrum' element messages posted on the bus. ++TRUE ++ ++ ++ ++GstSpectrum::message-phase ++gboolean ++ ++rw ++Phase ++Whether to add a 'phase' field to the structure of any 'spectrum' element messages posted on the bus. ++FALSE ++ ++ ++ ++GstSpectrum::post-messages ++gboolean ++ ++rw ++Post Messages ++Whether to post a 'spectrum' element message on the bus for each passed interval. ++TRUE ++ ++ ++ ++GstSpectrum::threshold ++gint ++<= 0 ++rw ++Threshold ++dB threshold for result. All lower values will be set to this. ++-60 ++ ++ ++ ++GstIirEqualizerNBands::num-bands ++guint ++[1,64] ++rwx ++num-bands ++number of different bands to use. ++10 ++ ++ ++ ++GstIirEqualizer3Bands::band0 ++gdouble ++[-24,12] ++rw ++110 Hz ++gain for the frequency band 100 Hz, ranging from -24.0 to +12.0. ++0 ++ ++ ++ ++GstIirEqualizer3Bands::band1 ++gdouble ++[-24,12] ++rw ++1100 Hz ++gain for the frequency band 1100 Hz, ranging from -24.0 to +12.0. ++0 ++ ++ ++ ++GstIirEqualizer3Bands::band2 ++gdouble ++[-24,12] ++rw ++11 kHz ++gain for the frequency band 11 kHz, ranging from -24.0 to +12.0. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band0 ++gdouble ++[-24,12] ++rw ++29 Hz ++gain for the frequency band 29 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band1 ++gdouble ++[-24,12] ++rw ++59 Hz ++gain for the frequency band 59 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band2 ++gdouble ++[-24,12] ++rw ++119 Hz ++gain for the frequency band 119 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band3 ++gdouble ++[-24,12] ++rw ++237 Hz ++gain for the frequency band 237 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band4 ++gdouble ++[-24,12] ++rw ++474 Hz ++gain for the frequency band 474 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band5 ++gdouble ++[-24,12] ++rw ++947 Hz ++gain for the frequency band 947 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band6 ++gdouble ++[-24,12] ++rw ++1889 Hz ++gain for the frequency band 1889 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band7 ++gdouble ++[-24,12] ++rw ++3770 Hz ++gain for the frequency band 3770 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band8 ++gdouble ++[-24,12] ++rw ++7523 Hz ++gain for the frequency band 7523 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstIirEqualizer10Bands::band9 ++gdouble ++[-24,12] ++rw ++15011 Hz ++gain for the frequency band 15011 Hz, ranging from -24 dB to +12 dB. ++0 ++ ++ ++ ++GstUDPSrc::auto-multicast ++gboolean ++ ++rw ++Auto Multicast ++Automatically join/leave multicast groups. ++TRUE ++ ++ ++ ++GstUDPSrc::buffer-size ++gint ++>= 0 ++rw ++Buffer Size ++Size of the kernel receive buffer in bytes, 0=default. ++0 ++ ++ ++ ++GstUDPSrc::caps ++GstCaps* ++ ++rw ++Caps ++The caps of the source pad. ++ ++ ++ ++ ++GstUDPSrc::closefd ++gboolean ++ ++rw ++Close sockfd ++Close sockfd if passed as property on state change. ++TRUE ++ ++ ++ ++GstUDPSrc::multicast-group ++gchar* ++ ++rw ++Multicast Group ++The Address of multicast group to join. ++"0.0.0.0" ++ ++ ++ ++GstUDPSrc::multicast-iface ++gchar* ++ ++rw ++Multicast Interface ++The network interface on which to join the multicast group. ++NULL ++ ++ ++ ++GstUDPSrc::port ++gint ++[0,65535] ++rw ++Port ++The port to receive the packets from, 0=allocate. ++4951 ++ ++ ++ ++GstUDPSrc::reuse ++gboolean ++ ++rw ++Reuse ++Enable reuse of the port. ++TRUE ++ ++ ++ ++GstUDPSrc::skip-first-bytes ++gint ++>= 0 ++rw ++Skip first bytes ++number of bytes to skip for each udp packet. ++0 ++ ++ ++ ++GstUDPSrc::sock ++gint ++>= G_MAXULONG ++r ++Socket Handle ++Socket currently in use for UDP reception. (-1 = no socket). ++-1 ++ ++ ++ ++GstUDPSrc::sockfd ++gint ++>= G_MAXULONG ++rw ++Socket Handle ++Socket to use for UDP reception. (-1 == allocate). ++-1 ++ ++ ++ ++GstUDPSrc::timeout ++guint64 ++ ++rw ++Timeout ++Post a message after timeout microseconds (0 = disabled). ++0 ++ ++ ++ ++GstUDPSrc::uri ++gchar* ++ ++rw ++URI ++URI in the form of udp://multicast_group:port. ++"udp://0.0.0.0:4951" ++ ++ ++ ++GstUDPSink::host ++gchar* ++ ++rw ++host ++The host/IP/Multicast group to send the packets to. ++"localhost" ++ ++ ++ ++GstUDPSink::port ++gint ++[0,65535] ++rw ++port ++The port to send the packets to. ++4951 ++ ++ ++ ++GstMultiUDPSink::auto-multicast ++gboolean ++ ++rw ++Automatically join/leave multicast groups ++Automatically join/leave the multicast groups, FALSE means user has to do it himself. ++TRUE ++ ++ ++ ++GstMultiUDPSink::bytes-served ++guint64 ++ ++r ++Bytes served ++Total number of bytes send to all clients. ++0 ++ ++ ++ ++GstMultiUDPSink::bytes-to-serve ++guint64 ++ ++r ++Bytes to serve ++Number of bytes received to serve to clients. ++0 ++ ++ ++ ++GstMultiUDPSink::clients ++gchar* ++ ++rw ++Clients ++A comma separated list of host:port pairs with destinations. ++NULL ++ ++ ++ ++GstMultiUDPSink::closefd ++gboolean ++ ++rw ++Close sockfd ++Close sockfd if passed as property on state change. ++TRUE ++ ++ ++ ++GstMultiUDPSink::loop ++gboolean ++ ++rw ++Multicast Loopback ++Used for setting the multicast loop parameter. TRUE = enable, FALSE = disable. ++TRUE ++ ++ ++ ++GstMultiUDPSink::qos-dscp ++gint ++[G_MAXULONG,63] ++rw ++QoS diff srv code point ++Quality of Service, differentiated services code point (-1 default). ++-1 ++ ++ ++ ++GstMultiUDPSink::sock ++gint ++>= G_MAXULONG ++r ++Socket Handle ++Socket currently in use for UDP sending. (-1 == no socket). ++-1 ++ ++ ++ ++GstMultiUDPSink::sockfd ++gint ++>= G_MAXULONG ++rw ++Socket Handle ++Socket to use for UDP sending. (-1 == allocate). ++-1 ++ ++ ++ ++GstMultiUDPSink::ttl ++gint ++[0,255] ++rw ++Unicast TTL ++Used for setting the unicast TTL parameter. ++64 ++ ++ ++ ++GstMultiUDPSink::ttl-mc ++gint ++[0,255] ++rw ++Multicast TTL ++Used for setting the multicast TTL parameter. ++1 ++ ++ ++ ++GstDynUDPSink::closefd ++gboolean ++ ++rw ++Close sockfd ++Close sockfd if passed as property on state change. ++TRUE ++ ++ ++ ++GstDynUDPSink::sockfd ++gint ++[G_MAXULONG,32767] ++rw ++socket handle ++Socket to use for UDP sending. (-1 == allocate). ++-1 ++ ++ ++ ++GstVideoMixer::background ++GstVideoMixerBackground ++ ++rw ++Background ++Background type. ++Checker pattern ++ ++ ++ ++GstRgVolume::album-mode ++gboolean ++ ++rw ++Album mode ++Prefer album over track gain. ++TRUE ++ ++ ++ ++GstRgVolume::fallback-gain ++gdouble ++[-60,60] ++rw ++Fallback gain ++Gain for streams missing tags [dB]. ++0 ++ ++ ++ ++GstRgVolume::headroom ++gdouble ++[0,60] ++rw ++Headroom ++Extra headroom [dB]. ++0 ++ ++ ++ ++GstRgVolume::pre-amp ++gdouble ++[-60,60] ++rw ++Pre-amp ++Extra gain [dB]. ++0 ++ ++ ++ ++GstRgVolume::result-gain ++gdouble ++[-120,120] ++r ++Result-gain ++Applied gain [dB]. ++0 ++ ++ ++ ++GstRgVolume::target-gain ++gdouble ++[-120,120] ++r ++Target-gain ++Applicable gain [dB]. ++0 ++ ++ ++ ++GstRgLimiter::enabled ++gboolean ++ ++rw ++Enabled ++Enable processing. ++TRUE ++ ++ ++ ++GstRgAnalysis::forced ++gboolean ++ ++rw ++Forced ++Analyze even if ReplayGain tags exist. ++TRUE ++ ++ ++ ++GstRgAnalysis::message ++gboolean ++ ++rwx ++Message ++Post statics messages. ++FALSE ++ ++ ++ ++GstRgAnalysis::num-tracks ++gint ++>= 0 ++rw ++Number of album tracks ++Number of remaining album tracks. ++0 ++ ++ ++ ++GstRgAnalysis::reference-level ++gdouble ++[0,150] ++rw ++Reference level ++Reference level [dB]. ++89 ++ ++ ++ ++GstRtpTheoraPay::config-interval ++guint ++<= 3600 ++rw ++Config Send Interval ++Send Config Insertion Interval in seconds (configuration headers will be multiplexed in the data stream when detected.) (0 = disabled). ++0 ++ ++ ++ ++GstRtpMP4VPay::buffer-list ++gboolean ++ ++rw ++Buffer Array ++Use Buffer Arrays. ++FALSE ++ ++ ++ ++GstRtpMP4VPay::config-interval ++guint ++<= 3600 ++rw ++Config Send Interval ++Send Config Insertion Interval in seconds (configuration headers will be multiplexed in the data stream when detected.) (0 = disabled). ++0 ++ ++ ++ ++GstRtpMP4VPay::send-config ++gboolean ++ ++rw ++Send Config ++Send the config parameters in RTP packets as well. ++FALSE ++ ++ ++ ++GstRtpMP2TDepay::skip-first-bytes ++guint ++ ++rw ++Skip first bytes ++The amount of bytes that need to be skipped at the beginning of the payload. ++0 ++ ++ ++ ++GstRtpJPEGPay::buffer-list ++gboolean ++ ++rw ++Buffer List ++Use Buffer Lists. ++FALSE ++ ++ ++ ++GstRtpJPEGPay::quality ++gint ++[0,255] ++rw ++Quality ++Quality factor on JPEG data (unused). ++255 ++ ++ ++ ++GstRtpJPEGPay::type ++gint ++[0,255] ++rw ++Type ++Default JPEG Type, overwritten by SOF when present. ++1 ++ ++ ++ ++GstRTPiLBCDepay::mode ++iLBCMode ++ ++rw ++Mode ++iLBC frame mode. ++30ms frames ++ ++ ++ ++GstRtpH264Pay::buffer-list ++gboolean ++ ++rw ++Buffer List ++Use Buffer Lists. ++FALSE ++ ++ ++ ++GstRtpH264Pay::config-interval ++guint ++<= 3600 ++rw ++SPS PPS Send Interval ++Send SPS and PPS Insertion Interval in seconds (sprop parameter sets will be multiplexed in the data stream when detected.) (0 = disabled). ++0 ++ ++ ++ ++GstRtpH264Pay::profile-level-id ++gchar* ++ ++rw ++profile-level-id ++The base64 profile-level-id to set in the sink caps (deprecated). ++NULL ++ ++ ++ ++GstRtpH264Pay::scan-mode ++GstH264PayScanMode ++ ++rw ++Scan Mode ++How to scan the input buffers for NAL units. Performance can be increased when certain assumptions are made about the input buffers. ++Buffers contain multiple complete NALUs ++ ++ ++ ++GstRtpH264Pay::sprop-parameter-sets ++gchar* ++ ++rw ++sprop-parameter-sets ++The base64 sprop-parameter-sets to set in out caps (set to NULL to extract from stream). ++NULL ++ ++ ++ ++GstRtpH264Depay::access-unit ++gboolean ++ ++rw ++Access Unit ++Merge NALU into AU (picture). ++FALSE ++ ++ ++ ++GstRtpH264Depay::byte-stream ++gboolean ++ ++rw ++Byte Stream ++Generate byte stream format of NALU. ++TRUE ++ ++ ++ ++GstRtpH263PPay::fragmentation-mode ++GstFragmentationMode ++ ++rw ++Fragmentation Mode ++Packet Fragmentation Mode. ++Normal ++ ++ ++ ++GstRtpH263Pay::modea-only ++gboolean ++ ++rw ++Fragment packets in mode A Only ++Disable packetization modes B and C. ++FALSE ++ ++ ++ ++GstRtpG726Pay::force-aal2 ++gboolean ++ ++rw ++Force AAL2 ++Force AAL2 encoding for compatibility with bad depayloaders. ++TRUE ++ ++ ++ ++GstRtpG726Depay::force-aal2 ++gboolean ++ ++rw ++Force AAL2 ++Force AAL2 decoding for compatibility with bad payloaders. ++TRUE ++ ++ ++ ++GstRTPDVPay::mode ++GstDVPayMode ++ ++rw ++Mode ++The payload mode of payloading. ++Video only ++ ++ ++ ++GstCutter::leaky ++gboolean ++ ++rw ++Leaky ++do we leak buffers when below threshold ?. ++FALSE ++ ++ ++ ++GstCutter::pre-length ++guint64 ++ ++rw ++Pre-recording buffer length ++Length of pre-recording buffer (in nanoseconds). ++0 ++ ++ ++ ++GstCutter::run-length ++guint64 ++ ++rw ++Run length ++Length of drop below threshold before cut_stop (in nanoseconds). ++0 ++ ++ ++ ++GstCutter::threshold ++gdouble ++ ++rw ++Threshold ++Volume threshold before trigger. ++0 ++ ++ ++ ++GstCutter::threshold-dB ++gdouble ++ ++rw ++Threshold (dB) ++Volume threshold before trigger (in dB). ++0 ++ ++ ++ ++GstVideoBox::alpha ++gdouble ++[0,1] ++rw ++Alpha ++Alpha value picture. ++1 ++ ++ ++ ++GstVideoBox::autocrop ++gboolean ++ ++rw ++Auto crop ++Auto crop. ++FALSE ++ ++ ++ ++GstVideoBox::border-alpha ++gdouble ++[0,1] ++rw ++Border Alpha ++Alpha value of the border. ++1 ++ ++ ++ ++GstVideoBox::bottom ++gint ++ ++rw ++Bottom ++Pixels to box at bottom (<0 = add a border). ++0 ++ ++ ++ ++GstVideoBox::fill ++GstVideoBoxFill ++ ++rw ++Fill ++How to fill the borders. ++Black ++ ++ ++ ++GstVideoBox::left ++gint ++ ++rw ++Left ++Pixels to box at left (<0 = add a border). ++0 ++ ++ ++ ++GstVideoBox::right ++gint ++ ++rw ++Right ++Pixels to box at right (<0 = add a border). ++0 ++ ++ ++ ++GstVideoBox::top ++gint ++ ++rw ++Top ++Pixels to box at top (<0 = add a border). ++0 ++ ++ ++ ++GstEFence::fence-top ++gboolean ++ ++rw ++Fence Top ++Align buffers with top of fenced region. ++TRUE ++ ++ ++ ++GstTest::allowed-timestamp-deviation ++gint64 ++>= G_MAXULONG ++rwx ++allowed timestamp deviation ++allowed average difference in usec between timestamp of next buffer and expected timestamp from analyzing last buffer. ++-1 ++ ++ ++ ++GstTest::buffer-count ++gint64 ++>= G_MAXULONG ++r ++buffer count ++number of buffers in stream. ++-1 ++ ++ ++ ++GstTest::expected-buffer-count ++gint64 ++>= G_MAXULONG ++rwx ++expected buffer count ++expected number of buffers in stream. ++-1 ++ ++ ++ ++GstTest::expected-length ++gint64 ++>= G_MAXULONG ++rwx ++expected length ++expected length of stream. ++-1 ++ ++ ++ ++GstTest::expected-md5 ++gchar* ++ ++rwx ++expected md5 ++expected md5 of processing the whole data. ++"---" ++ ++ ++ ++GstTest::length ++gint64 ++>= G_MAXULONG ++r ++length ++length of stream. ++-1 ++ ++ ++ ++GstTest::md5 ++gchar* ++ ++r ++md5 ++md5 of processing the whole data. ++"---" ++ ++ ++ ++GstTest::timestamp-deviation ++gint64 ++>= G_MAXULONG ++r ++timestamp deviation ++average difference in usec between timestamp of next buffer and expected timestamp from analyzing last buffer. ++-1 ++ ++ ++ ++GstTagInject::tags ++gchar* ++ ++w ++taglist ++List of tags to inject into the target file. ++NULL ++ ++ ++ ++GstRndBufferSize::max ++glong ++[1,G_MAXINT] ++rwx ++maximum ++maximum buffer size. ++8192 ++ ++ ++ ++GstRndBufferSize::min ++glong ++[0,G_MAXINT] ++rwx ++mininum ++mininum buffer size. ++1 ++ ++ ++ ++GstRndBufferSize::seed ++gulong ++<= G_MAXUINT ++rwx ++random number seed ++seed for randomness (initialized when going from READY to PAUSED). ++ ++ ++ ++ ++GstProgressReport::format ++gchar* ++ ++rw ++format ++Format to use for the querying. ++"auto" ++ ++ ++ ++GstProgressReport::silent ++gboolean ++ ++rw ++Do not print output to stdout ++Do not print output to stdout. ++FALSE ++ ++ ++ ++GstProgressReport::update-freq ++gint ++>= 1 ++rw ++Update Frequency ++Number of seconds between reports when data is flowing. ++5 ++ ++ ++ ++GstNavSeek::seek-offset ++gdouble ++>= 0 ++rw ++Seek Offset ++Time in seconds to seek by. ++5 ++ ++ ++ ++GstCapsSetter::caps ++GstCaps* ++ ++rw ++Merge caps ++Merge these caps (thereby overwriting) in the stream. ++ ++ ++ ++ ++GstCapsSetter::join ++gboolean ++ ++rw ++Join ++Match incoming caps' mime-type to mime-type of provided caps. ++TRUE ++ ++ ++ ++GstCapsSetter::replace ++gboolean ++ ++rw ++Replace ++Drop fields of incoming caps. ++FALSE ++ ++ ++ ++GstBreakMyData::probability ++gdouble ++[0,1] ++rwx ++probability ++probability for each byte in the buffer to be changed. ++0 ++ ++ ++ ++GstBreakMyData::seed ++guint ++ ++rwx ++seed ++seed for randomness (initialized when going from READY to PAUSED). ++0 ++ ++ ++ ++GstBreakMyData::set-to ++gint ++[G_MAXULONG,255] ++rwx ++set-to ++set changed bytes to this value (-1 means random value. ++-1 ++ ++ ++ ++GstBreakMyData::skip ++guint ++ ++rwx ++skip ++amount of bytes skipped at the beginning of stream. ++0 ++ ++ ++ ++GstAutoVideoSrc::filter-caps ++GstCaps* ++ ++rw ++Filter caps ++Filter src candidates using these caps. ++ ++ ++ ++ ++GstAutoVideoSink::filter-caps ++GstCaps* ++ ++rw ++Filter caps ++Filter sink candidates using these caps. ++ ++ ++ ++ ++GstAutoAudioSrc::filter-caps ++GstCaps* ++ ++rw ++Filter caps ++Filter sink candidates using these caps. ++ ++ ++ ++ ++GstAutoAudioSink::filter-caps ++GstCaps* ++ ++rw ++Filter caps ++Filter sink candidates using these caps. ++ ++ ++ ++ ++GstRtpSession::bandwidth ++gdouble ++>= 0 ++rw ++Bandwidth ++The bandwidth of the session in bytes per second. ++64000 ++ ++ ++ ++GstRtpSession::internal-session ++RTPSession* ++ ++r ++Internal Session ++The internal RTPSession object. ++ ++ ++ ++ ++GstRtpSession::ntp-ns-base ++guint64 ++ ++rw ++NTP base time ++The NTP base time corresponding to running_time 0 (deprecated). ++0 ++ ++ ++ ++GstRtpSession::num-active-sources ++guint ++ ++r ++Num Active Sources ++The number of active sources in the session. ++0 ++ ++ ++ ++GstRtpSession::num-sources ++guint ++ ++r ++Num Sources ++The number of sources in the session. ++0 ++ ++ ++ ++GstRtpSession::rtcp-fraction ++gdouble ++>= 0 ++rw ++RTCP Fraction ++The RTCP bandwidth of the session in bytes per second. ++3200 ++ ++ ++ ++GstRtpSession::rtcp-rr-bandwidth ++gint ++>= G_MAXULONG ++rw ++RTCP RR bandwidth ++The RTCP bandwidth used for receivers in bytes per second (-1 = default). ++-1 ++ ++ ++ ++GstRtpSession::rtcp-rs-bandwidth ++gint ++>= G_MAXULONG ++rw ++RTCP RS bandwidth ++The RTCP bandwidth used for senders in bytes per second (-1 = default). ++-1 ++ ++ ++ ++GstRtpSession::sdes ++GstStructure* ++ ++rw ++SDES ++The SDES items of this session. ++ ++ ++ ++ ++GstRtpJitterBuffer::do-lost ++gboolean ++ ++rw ++Do Lost ++Send an event downstream when a packet is lost. ++FALSE ++ ++ ++ ++GstRtpJitterBuffer::drop-on-latency ++gboolean ++ ++rw ++Drop buffers when maximum latency is reached ++Tells the jitterbuffer to never exceed the given latency in size. ++FALSE ++ ++ ++ ++GstRtpJitterBuffer::latency ++guint ++ ++rw ++Buffer latency in ms ++Amount of ms to buffer. ++200 ++ ++ ++ ++GstRtpJitterBuffer::mode ++RTPJitterBufferMode ++ ++rw ++Mode ++Control the buffering algorithm in use. ++Slave receiver to sender clock ++ ++ ++ ++GstRtpJitterBuffer::percent ++gint ++[0,100] ++r ++percent ++The buffer filled percent. ++0 ++ ++ ++ ++GstRtpJitterBuffer::ts-offset ++gint64 ++ ++rw ++Timestamp Offset ++Adjust buffer timestamps with offset in nanoseconds. ++0 ++ ++ ++ ++GstRtpBin::autoremove ++gboolean ++ ++rw ++Auto Remove ++Automatically remove timed out sources. ++FALSE ++ ++ ++ ++GstRtpBin::buffer-mode ++RTPJitterBufferMode ++ ++rw ++Buffer Mode ++Control the buffering algorithm in use. ++Slave receiver to sender clock ++ ++ ++ ++GstRtpBin::do-lost ++gboolean ++ ++rw ++Do Lost ++Send an event downstream when a packet is lost. ++FALSE ++ ++ ++ ++GstRtpBin::ignore-pt ++gboolean ++ ++rw ++Ignore PT ++Do not demultiplex based on PT values. ++FALSE ++ ++ ++ ++GstRtpBin::latency ++guint ++ ++rw ++Buffer latency in ms ++Default amount of ms to buffer in the jitterbuffers. ++200 ++ ++ ++ ++GstRtpBin::sdes ++GstStructure* ++ ++rw ++SDES ++The SDES items of this session. ++ ++ ++ ++ ++GstVertigoTV::speed ++gfloat ++[0.01,100] ++rw ++Speed ++Control the speed of movement. ++0.02 ++ ++ ++ ++GstVertigoTV::zoom-speed ++gfloat ++[1.01,1.1] ++rw ++Zoom Speed ++Control the rate of zooming. ++1.01 ++ ++ ++ ++GstStreakTV::feedback ++gboolean ++ ++rw ++Feedback ++Feedback. ++FALSE ++ ++ ++ ++GstRippleTV::mode ++GstRippleTVMode ++ ++rw ++Mode ++Mode. ++Motion Detection ++ ++ ++ ++GstRippleTV::reset ++gboolean ++ ++w ++Reset ++Reset all current ripples. ++FALSE ++ ++ ++ ++GstRevTV::delay ++gint ++[1,100] ++rw ++Delay ++Delay in frames between updates. ++1 ++ ++ ++ ++GstRevTV::gain ++gint ++[1,200] ++rw ++Gain ++Control gain. ++50 ++ ++ ++ ++GstRevTV::linespace ++gint ++[1,100] ++rw ++Linespace ++Control line spacing. ++6 ++ ++ ++ ++GstRadioacTV::color ++GstRadioacTVColor ++ ++rw ++Color ++Color. ++White ++ ++ ++ ++GstRadioacTV::interval ++guint ++<= G_MAXINT ++rw ++Interval ++Snapshot interval (in strobe mode). ++3 ++ ++ ++ ++GstRadioacTV::mode ++GstRadioacTVMode ++ ++rw ++Mode ++Mode. ++Normal ++ ++ ++ ++GstRadioacTV::trigger ++gboolean ++ ++rw ++Trigger ++Trigger (in trigger mode). ++FALSE ++ ++ ++ ++GstQuarkTV::planes ++gint ++[0,64] ++rw ++Planes ++Number of planes. ++16 ++ ++ ++ ++GstOpTV::mode ++GstOpTVMode ++ ++rw ++Mode ++Mode. ++Maelstrom ++ ++ ++ ++GstOpTV::speed ++gint ++ ++rw ++Speed ++Effect speed. ++16 ++ ++ ++ ++GstOpTV::threshold ++guint ++<= G_MAXINT ++rw ++Threshold ++Luma threshold. ++60 ++ ++ ++ ++GstDiceTV::square-bits ++gint ++[0,5] ++rw ++Square Bits ++The size of the Squares. ++4 ++ ++ ++ ++GstAgingTV::color-aging ++gboolean ++ ++rw ++Color Aging ++Color Aging. ++TRUE ++ ++ ++ ++GstAgingTV::dusts ++gboolean ++ ++rw ++Dusts ++Dusts. ++TRUE ++ ++ ++ ++GstAgingTV::pits ++gboolean ++ ++rw ++Pits ++Pits. ++TRUE ++ ++ ++ ++GstAgingTV::scratch-lines ++guint ++<= 20 ++rw ++Scratch Lines ++Number of scratch lines. ++7 ++ ++ ++ ++GstDeinterlace::fields ++GstDeinterlaceFields ++ ++rw ++fields ++Fields to use for deinterlacing. ++All fields ++ ++ ++ ++GstDeinterlace::method ++GstDeinterlaceMethods ++ ++rw ++Method ++Deinterlace Method. ++Motion Adaptive: Advanced Detection ++ ++ ++ ++GstDeinterlace::mode ++GstDeinterlaceModes ++ ++rw ++Mode ++Deinterlace Mode. ++Auto detection ++ ++ ++ ++GstDeinterlace::tff ++GstDeinterlaceFieldLayout ++ ++rw ++tff ++Deinterlace top field first. ++Auto detection ++ ++ ++ ++GstInterleave::channel-positions ++GValueArray* ++ ++rw ++Channel positions ++Channel positions used on the output. ++ ++ ++ ++ ++GstInterleave::channel-positions-from-input ++gboolean ++ ++rw ++Channel positions from input ++Take channel positions from the input. ++TRUE ++ ++ ++ ++GstDeinterleave::keep-positions ++gboolean ++ ++rw ++Keep positions ++Keep the original channel positions on the output buffers. ++FALSE ++ ++ ++ ++GstRTSPSrc::buffer-mode ++GstRTSPSrcBufferMode ++ ++rw ++Buffer Mode ++Control the buffering algorithm in use. ++Slave receiver to sender clock ++ ++ ++ ++GstRTSPSrc::connection-speed ++guint ++<= 2147483 ++rw ++Connection Speed ++Network connection speed in kbps (0 = unknown). ++0 ++ ++ ++ ++GstRTSPSrc::debug ++gboolean ++ ++rw ++Debug ++Dump request and response messages to stdout. ++FALSE ++ ++ ++ ++GstRTSPSrc::do-rtcp ++gboolean ++ ++rw ++Do RTCP ++Send RTCP packets, disable for old incompatible server. ++TRUE ++ ++ ++ ++GstRTSPSrc::latency ++guint ++ ++rw ++Buffer latency in ms ++Amount of ms to buffer. ++2000 ++ ++ ++ ++GstRTSPSrc::location ++gchar* ++ ++rw ++RTSP Location ++Location of the RTSP url to read. ++NULL ++ ++ ++ ++GstRTSPSrc::nat-method ++GstRTSPNatMethod ++ ++rw ++NAT Method ++Method to use for traversing firewalls and NAT. ++Send Dummy packets ++ ++ ++ ++GstRTSPSrc::port-range ++gchar* ++ ++rw ++Port range ++Client port range that can be used to receive RTP and RTCP data, eg. 3000-3005 (NULL = no restrictions). ++NULL ++ ++ ++ ++GstRTSPSrc::protocols ++GstRTSPLowerTrans ++ ++rw ++Protocols ++Allowed lower transport protocols. ++UDP Unicast Mode|UDP Multicast Mode|TCP interleaved mode ++ ++ ++ ++GstRTSPSrc::proxy ++gchar* ++ ++rw ++Proxy ++Proxy settings for HTTP tunneling. Format: [http://][user:passwd@]host[:port]. ++NULL ++ ++ ++ ++GstRTSPSrc::retry ++guint ++<= 65535 ++rw ++Retry ++Max number of retries when allocating RTP ports. ++20 ++ ++ ++ ++GstRTSPSrc::rtp-blocksize ++guint ++<= 65536 ++rw ++RTP Blocksize ++RTP package size to suggest to server (0 = disabled). ++0 ++ ++ ++ ++GstRTSPSrc::tcp-timeout ++guint64 ++ ++rw ++TCP Timeout ++Fail after timeout microseconds on TCP connections (0 = disabled). ++20000000 ++ ++ ++ ++GstRTSPSrc::timeout ++guint64 ++ ++rw ++Timeout ++Retry TCP transport after UDP timeout microseconds (0 = disabled). ++5000000 ++ ++ ++ ++GstRTSPSrc::user-id ++gchar* ++ ++rw ++user-id ++RTSP location URI user id for authentication. ++NULL ++ ++ ++ ++GstRTSPSrc::user-pw ++gchar* ++ ++rw ++user-pw ++RTSP location URI user password for authentication. ++NULL ++ ++ ++ ++GstRTPDec::latency ++guint ++ ++rw ++Buffer latency in ms ++Amount of ms to buffer. ++200 ++ ++ ++ ++GstSMPTEAlpha::border ++gint ++>= 0 ++rw ++Border ++The border width of the transition. ++0 ++ ++ ++ ++GstSMPTEAlpha::depth ++gint ++[1,24] ++rw ++Depth ++Depth of the mask in bits. ++16 ++ ++ ++ ++GstSMPTEAlpha::invert ++gboolean ++ ++rw ++Invert ++Invert transition mask. ++FALSE ++ ++ ++ ++GstSMPTEAlpha::position ++gdouble ++[0,1] ++rw ++Position ++Position of the transition effect. ++0 ++ ++ ++ ++GstSMPTEAlpha::type ++GstSMPTEAlphaTransitionType ++ ++rw ++Type ++The type of transition to use. ++A bar moves from left to right ++ ++ ++ ++GstSMPTE::border ++gint ++>= 0 ++rw ++Border ++The border width of the transition. ++0 ++ ++ ++ ++GstSMPTE::depth ++gint ++[1,24] ++rw ++Depth ++Depth of the mask in bits. ++16 ++ ++ ++ ++GstSMPTE::duration ++guint64 ++ ++rw ++Duration ++Duration of the transition effect in nanoseconds. ++1000000000 ++ ++ ++ ++GstSMPTE::fps ++gfloat ++>= 0 ++rw ++FPS ++Frames per second if no input files are given (deprecated). ++0 ++ ++ ++ ++GstSMPTE::invert ++gboolean ++ ++rw ++Invert ++Invert transition mask. ++FALSE ++ ++ ++ ++GstSMPTE::type ++GstSMPTETransitionType ++ ++rw ++Type ++The type of transition to use. ++A bar moves from left to right ++ ++ ++ ++GstMatroskaMux::min-index-interval ++gint64 ++>= 0 ++rw ++Minimum time between index entries ++An index entry is created every so many nanoseconds. ++0 ++ ++ ++ ++GstMatroskaMux::streamable ++gboolean ++ ++rw ++Determines whether output should be streamable ++If set to true, the output should be as if it is to be streamed and hence no indexes written or duration written. ++FALSE ++ ++ ++ ++GstMatroskaMux::version ++gint ++[1,2] ++rw ++DocType version ++This parameter determines what Matroska features can be used. ++2 ++ ++ ++ ++GstMatroskaMux::writing-app ++gchar* ++ ++rw ++Writing application. ++The name the application that creates the matroska file. ++NULL ++ ++ ++ ++GstShapeWipe::border ++gfloat ++[0,1] ++rw ++Border ++Border of the mask. ++0 ++ ++ ++ ++GstShapeWipe::position ++gfloat ++[0,1] ++rw ++Position ++Position of the mask. ++0 ++ ++ ++ ++GstAudioWSincLimit::cutoff ++gfloat ++[0,100000] ++rw ++Cutoff ++Cut-off Frequency (Hz). ++0 ++ ++ ++ ++GstAudioWSincLimit::length ++gint ++[3,256000] ++rw ++Length ++Filter kernel length, will be rounded to the next odd number. ++101 ++ ++ ++ ++GstAudioWSincLimit::mode ++GstAudioWSincLimitMode ++ ++rw ++Mode ++Low pass or high pass mode. ++Low pass (default) ++ ++ ++ ++GstAudioWSincLimit::window ++GstAudioWSincLimitWindow ++ ++rw ++Window ++Window function to use. ++Hamming window (default) ++ ++ ++ ++GstAudioWSincBand::length ++gint ++[3,256000] ++rw ++Length ++Filter kernel length, will be rounded to the next odd number. ++101 ++ ++ ++ ++GstAudioWSincBand::lower-frequency ++gfloat ++[0,100000] ++rw ++Lower Frequency ++Cut-off lower frequency (Hz). ++0 ++ ++ ++ ++GstAudioWSincBand::mode ++GstAudioWSincBandMode ++ ++rw ++Mode ++Band pass or band reject mode. ++Band pass (default) ++ ++ ++ ++GstAudioWSincBand::upper-frequency ++gfloat ++[0,100000] ++rw ++Upper Frequency ++Cut-off upper frequency (Hz). ++0 ++ ++ ++ ++GstAudioWSincBand::window ++GstAudioWSincBandWindow ++ ++rw ++Window ++Window function to use. ++Hamming window (default) ++ ++ ++ ++GstAudioPanorama::method ++GstAudioPanoramaMethod ++ ++rw ++Panning method ++Psychoacoustic mode keeps same perceived loudness, simple mode just controls volume of one channel. ++Psychoacoustic Panning (default) ++ ++ ++ ++GstAudioPanorama::panorama ++gfloat ++[-1,1] ++rw ++Panorama ++Position in stereo panorama (-1.0 left -> 1.0 right). ++0 ++ ++ ++ ++GstAudioKaraoke::filter-band ++gfloat ++[0,441] ++rw ++Filter Band ++The Frequency band of the filter. ++220 ++ ++ ++ ++GstAudioKaraoke::filter-width ++gfloat ++[0,100] ++rw ++Filter Width ++The Frequency width of the filter. ++100 ++ ++ ++ ++GstAudioKaraoke::level ++gfloat ++[0,1] ++rw ++Level ++Level of the effect (1.0 = full). ++1 ++ ++ ++ ++GstAudioKaraoke::mono-level ++gfloat ++[0,1] ++rw ++Mono Level ++Level of the mono channel (1.0 = full). ++1 ++ ++ ++ ++GstAudioInvert::degree ++gfloat ++[0,1] ++rw ++Degree ++Degree of inversion. ++0 ++ ++ ++ ++GstAudioIIRFilter::a ++GValueArray* ++ ++rw ++A ++Filter coefficients (numerator of transfer function). ++ ++ ++ ++ ++GstAudioIIRFilter::b ++GValueArray* ++ ++rw ++B ++Filter coefficients (denominator of transfer function). ++ ++ ++ ++ ++GstAudioFIRFilter::kernel ++GValueArray* ++ ++rw ++Filter Kernel ++Filter kernel for the FIR filter. ++ ++ ++ ++ ++GstAudioFIRFilter::latency ++guint64 ++ ++rw ++Latecy ++Filter latency in samples. ++0 ++ ++ ++ ++GstAudioEcho::delay ++guint64 ++>= 1 ++rw ++Delay ++Delay of the echo in nanoseconds. ++1 ++ ++ ++ ++GstAudioEcho::feedback ++gfloat ++[0,1] ++rw ++Feedback ++Amount of feedback. ++0 ++ ++ ++ ++GstAudioEcho::intensity ++gfloat ++[0,1] ++rw ++Intensity ++Intensity of the echo. ++0 ++ ++ ++ ++GstAudioEcho::max-delay ++guint64 ++>= 1 ++rw ++Maximum Delay ++Maximum delay of the echo in nanoseconds (can't be changed in PLAYING or PAUSED state). ++1 ++ ++ ++ ++GstAudioDynamic::characteristics ++GstAudioDynamicCharacteristics ++ ++rw ++Characteristics ++Selects whether the ratio should be applied smooth (soft-knee) or hard (hard-knee). ++Hard Knee (default) ++ ++ ++ ++GstAudioDynamic::mode ++GstAudioDynamicMode ++ ++rw ++Mode ++Selects whether the filter should work on loud samples (compressor) orquiet samples (expander). ++Compressor (default) ++ ++ ++ ++GstAudioDynamic::ratio ++gfloat ++>= 0 ++rw ++Ratio ++Ratio that should be applied. ++1 ++ ++ ++ ++GstAudioDynamic::threshold ++gfloat ++[0,1] ++rw ++Threshold ++Threshold until the filter is activated. ++0 ++ ++ ++ ++GstAudioChebLimit::cutoff ++gfloat ++[0,100000] ++rw ++Cutoff ++Cut off frequency (Hz). ++0 ++ ++ ++ ++GstAudioChebLimit::mode ++GstAudioChebLimitMode ++ ++rw ++Mode ++Low pass or high pass mode. ++Low pass (default) ++ ++ ++ ++GstAudioChebLimit::poles ++gint ++[2,32] ++rw ++Poles ++Number of poles to use, will be rounded up to the next even number. ++4 ++ ++ ++ ++GstAudioChebLimit::ripple ++gfloat ++[0,200] ++rw ++Ripple ++Amount of ripple (dB). ++0.25 ++ ++ ++ ++GstAudioChebLimit::type ++gint ++[1,2] ++rw ++Type ++Type of the chebychev filter. ++1 ++ ++ ++ ++GstAudioChebBand::lower-frequency ++gfloat ++[0,100000] ++rw ++Lower frequency ++Start frequency of the band (Hz). ++0 ++ ++ ++ ++GstAudioChebBand::mode ++GstAudioChebBandMode ++ ++rw ++Mode ++Low pass or high pass mode. ++Band pass (default) ++ ++ ++ ++GstAudioChebBand::poles ++gint ++[4,32] ++rw ++Poles ++Number of poles to use, will be rounded up to the next multiply of four. ++4 ++ ++ ++ ++GstAudioChebBand::ripple ++gfloat ++[0,200] ++rw ++Ripple ++Amount of ripple (dB). ++0.25 ++ ++ ++ ++GstAudioChebBand::type ++gint ++[1,2] ++rw ++Type ++Type of the chebychev filter. ++1 ++ ++ ++ ++GstAudioChebBand::upper-frequency ++gfloat ++[0,100000] ++rw ++Upper frequency ++Stop frequency of the band (Hz). ++0 ++ ++ ++ ++GstAudioAmplify::amplification ++gfloat ++ ++rw ++Amplification ++Factor of amplification. ++1 ++ ++ ++ ++GstAudioAmplify::clipping-method ++GstAudioPanoramaClippingMethod ++ ++rw ++Clipping method ++Selects how to handle values higher than the maximum. ++Normal clipping (default) ++ ++ ++ ++GstID3Demux::prefer-v1 ++gboolean ++ ++rwx ++Prefer version 1 tag ++Prefer tags from ID3v1 tag at end of file when both ID3v1 and ID3v2 tags are present. ++FALSE ++ ++ ++ ++GstAviMux::bigfile ++gboolean ++ ++rw ++Bigfile Support (>2GB) ++Support for openDML-2.0 (big) AVI files. ++TRUE ++ ++ ++ ++GstLevel::interval ++guint64 ++>= 1 ++rw ++Interval ++Interval of time between message posts (in nanoseconds). ++100000000 ++ ++ ++ ++GstLevel::message ++gboolean ++ ++rw ++message ++Post a level message for each passed interval. ++TRUE ++ ++ ++ ++GstLevel::peak-falloff ++gdouble ++>= 0 ++rw ++Peak Falloff ++Decay rate of decay peak after TTL (in dB/sec). ++10 ++ ++ ++ ++GstLevel::peak-ttl ++guint64 ++ ++rw ++Peak TTL ++Time To Live of decay peak before it falls back (in nanoseconds). ++300000000 ++ ++ ++ ++GstMultipartMux::boundary ++gchar* ++ ++rw ++Boundary ++Boundary string. ++"ThisRandomString" ++ ++ ++ ++GstMultipartDemux::autoscan ++gboolean ++ ++rw ++autoscan ++Try to autofind the prefix (deprecated unused, see boundary). ++FALSE ++ ++ ++ ++GstMultipartDemux::boundary ++gchar* ++ ++rwx ++Boundary ++The boundary string separating data, automatic if NULL. ++NULL ++ ++ ++ ++GstV4l2Src::always-copy ++gboolean ++ ++rw ++Always Copy ++If the buffer will or not be used directly from mmap. ++TRUE ++ ++ ++ ++GstV4l2Src::device ++gchar* ++ ++rw ++Device ++Device location. ++"/dev/video0" ++ ++ ++ ++GstV4l2Src::device-fd ++gint ++>= G_MAXULONG ++r ++File descriptor ++File descriptor of the device. ++-1 ++ ++ ++ ++GstV4l2Src::device-name ++gchar* ++ ++r ++Device name ++Name of the device. ++NULL ++ ++ ++ ++GstV4l2Src::flags ++GstV4l2DeviceTypeFlags ++ ++r ++Flags ++Device type flags. ++ ++ ++ ++ ++GstV4l2Src::queue-size ++guint ++[1,16] ++rw ++Queue size ++Number of buffers to be enqueud in the driver in streaming mode. ++2 ++ ++ ++ ++GstV4l2Sink::device ++gchar* ++ ++rw ++Device ++Device location. ++"/dev/video1" ++ ++ ++ ++GstV4l2Sink::device-fd ++gint ++>= G_MAXULONG ++r ++File descriptor ++File descriptor of the device. ++-1 ++ ++ ++ ++GstV4l2Sink::device-name ++gchar* ++ ++r ++Device name ++Name of the device. ++NULL ++ ++ ++ ++GstV4l2Sink::flags ++GstV4l2DeviceTypeFlags ++ ++r ++Flags ++Device type flags. ++ ++ ++ ++ ++GstV4l2Sink::overlay-height ++guint ++ ++rw ++Overlay height ++The height of the video overlay; default is equal to negotiated image height. ++0 ++ ++ ++ ++GstV4l2Sink::overlay-left ++gint ++ ++rw ++Overlay left ++The leftmost (x) coordinate of the video overlay; top left corner of screen is 0,0. ++0 ++ ++ ++ ++GstV4l2Sink::overlay-top ++gint ++ ++rw ++Overlay top ++The topmost (y) coordinate of the video overlay; top left corner of screen is 0,0. ++0 ++ ++ ++ ++GstV4l2Sink::overlay-width ++guint ++ ++rw ++Overlay width ++The width of the video overlay; default is equal to negotiated image width. ++0 ++ ++ ++ ++GstV4l2Sink::queue-size ++guint ++[1,16] ++rw ++Queue size ++Number of buffers to be enqueud in the driver in streaming mode. ++8 ++ ++ ++ ++GstXImageSrc::display-name ++gchar* ++ ++rw ++Display ++X Display Name. ++NULL ++ ++ ++ ++GstXImageSrc::endx ++guint ++<= G_MAXINT ++rw ++End X ++X coordinate of bottom right corner of area to be recorded (0 for bottom right of screen). ++0 ++ ++ ++ ++GstXImageSrc::endy ++guint ++<= G_MAXINT ++rw ++End Y ++Y coordinate of bottom right corner of area to be recorded (0 for bottom right of screen). ++0 ++ ++ ++ ++GstXImageSrc::screen-num ++guint ++<= G_MAXINT ++rw ++Screen number ++X Screen Number. ++0 ++ ++ ++ ++GstXImageSrc::show-pointer ++gboolean ++ ++rw ++Show Mouse Pointer ++Show mouse pointer (if XFixes extension enabled). ++TRUE ++ ++ ++ ++GstXImageSrc::startx ++guint ++<= G_MAXINT ++rw ++Start X co-ordinate ++X coordinate of top left corner of area to be recorded (0 for top left of screen). ++0 ++ ++ ++ ++GstXImageSrc::starty ++guint ++<= G_MAXINT ++rw ++Start Y co-ordinate ++Y coordinate of top left corner of area to be recorded (0 for top left of screen). ++0 ++ ++ ++ ++GstXImageSrc::use-damage ++gboolean ++ ++rw ++Use XDamage ++Use XDamage (if XDamage extension enabled). ++TRUE ++ ++ ++ ++GstOss4Source::device ++gchar* ++ ++rw ++Device ++OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) (NULL = use first available device). ++NULL ++ ++ ++ ++GstOss4Source::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstOss4Sink::device ++gchar* ++ ++rw ++Device ++OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) (NULL = use first available playback device). ++NULL ++ ++ ++ ++GstOss4Sink::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstOss4Sink::mute ++gboolean ++ ++rw ++Mute ++Mute state of this stream. ++FALSE ++ ++ ++ ++GstOss4Sink::volume ++gdouble ++[0,10] ++rw ++Volume ++Linear volume of this stream, 1.0=100%. ++1 ++ ++ ++ ++GstOss4Mixer::device ++gchar* ++ ++rw ++Device ++OSS mixer device (e.g. /dev/oss/hdaudio0/mix0 or /dev/mixerN) (NULL = use first mixer device found). ++NULL ++ ++ ++ ++GstOss4Mixer::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstOssSrc::device ++gchar* ++ ++rw ++Device ++OSS device (usually /dev/dspN). ++"/dev/dsp" ++ ++ ++ ++GstOssSrc::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++"" ++ ++ ++ ++GstOssSink::device ++gchar* ++ ++rw ++Device ++OSS device (usually /dev/dspN). ++"/dev/dsp" ++ ++ ++ ++GstOssMixerElement::device ++gchar* ++ ++rw ++Device ++OSS mixer device (usually /dev/mixer). ++"/dev/mixer" ++ ++ ++ ++GstOssMixerElement::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstSoupHTTPSrc::automatic-redirect ++gboolean ++ ++rw ++automatic-redirect ++Automatically follow HTTP redirects (HTTP Status Code 3xx). ++TRUE ++ ++ ++ ++GstSoupHTTPSrc::cookies ++GStrv* ++ ++rw ++Cookies ++HTTP request cookies. ++ ++ ++ ++ ++GstSoupHTTPSrc::extra-headers ++GstStructure* ++ ++rw ++Extra Headers ++Extra headers to append to the HTTP request. ++ ++ ++ ++ ++GstSoupHTTPSrc::iradio-genre ++gchar* ++ ++r ++iradio-genre ++Genre of the stream. ++NULL ++ ++ ++ ++GstSoupHTTPSrc::iradio-mode ++gboolean ++ ++rw ++iradio-mode ++Enable internet radio mode (extraction of shoutcast/icecast metadata). ++FALSE ++ ++ ++ ++GstSoupHTTPSrc::iradio-name ++gchar* ++ ++r ++iradio-name ++Name of the stream. ++NULL ++ ++ ++ ++GstSoupHTTPSrc::iradio-title ++gchar* ++ ++r ++iradio-title ++Name of currently playing song. ++NULL ++ ++ ++ ++GstSoupHTTPSrc::iradio-url ++gchar* ++ ++r ++iradio-url ++Homepage URL for radio stream. ++NULL ++ ++ ++ ++GstSoupHTTPSrc::is-live ++gboolean ++ ++rw ++is-live ++Act like a live source. ++FALSE ++ ++ ++ ++GstSoupHTTPSrc::location ++gchar* ++ ++rw ++Location ++Location to read from. ++"" ++ ++ ++ ++GstSoupHTTPSrc::proxy ++gchar* ++ ++rw ++Proxy ++HTTP proxy server URI. ++"" ++ ++ ++ ++GstSoupHTTPSrc::proxy-id ++gchar* ++ ++rw ++proxy-id ++HTTP proxy URI user id for authentication. ++"" ++ ++ ++ ++GstSoupHTTPSrc::proxy-pw ++gchar* ++ ++rw ++proxy-pw ++HTTP proxy URI user password for authentication. ++"" ++ ++ ++ ++GstSoupHTTPSrc::timeout ++guint ++<= 3600 ++rw ++timeout ++Value in seconds to timeout a blocking I/O (0 = No timeout). ++0 ++ ++ ++ ++GstSoupHTTPSrc::user-agent ++gchar* ++ ++rw ++User-Agent ++Value of the User-Agent HTTP request header field. ++"GStreamer souphttpsrc " ++ ++ ++ ++GstSoupHTTPSrc::user-id ++gchar* ++ ++rw ++user-id ++HTTP location URI user id for authentication. ++"" ++ ++ ++ ++GstSoupHTTPSrc::user-pw ++gchar* ++ ++rw ++user-pw ++HTTP location URI user password for authentication. ++"" ++ ++ ++ ++GstCairoTextOverlay::deltax ++gint ++ ++w ++X position modifier ++Shift X position to the left or to the right. Unit is pixels. ++0 ++ ++ ++ ++GstCairoTextOverlay::deltay ++gint ++ ++w ++Y position modifier ++Shift Y position up or down. Unit is pixels. ++0 ++ ++ ++ ++GstCairoTextOverlay::font-desc ++gchar* ++ ++w ++font description ++Pango font description of font to be used for rendering. See documentation of pango_font_description_from_string for syntax. ++"" ++ ++ ++ ++GstCairoTextOverlay::halign ++gchar* ++ ++w ++horizontal alignment ++Horizontal alignment of the text. Can be either 'left', 'right', or 'center'. ++"center" ++ ++ ++ ++GstCairoTextOverlay::shaded-background ++gboolean ++ ++w ++shaded background ++Whether to shade the background under the text area. ++FALSE ++ ++ ++ ++GstCairoTextOverlay::text ++gchar* ++ ++w ++text ++Text to be display. ++"" ++ ++ ++ ++GstCairoTextOverlay::valign ++gchar* ++ ++w ++vertical alignment ++Vertical alignment of the text. Can be either 'baseline', 'bottom', or 'top'. ++"baseline" ++ ++ ++ ++GstCairoTextOverlay::xpad ++gint ++ ++w ++horizontal paddding ++Horizontal paddding when using left/right alignment. ++25 ++ ++ ++ ++GstCairoTextOverlay::ypad ++gint ++ ++w ++vertical padding ++Vertical padding when using top/bottom alignment. ++25 ++ ++ ++ ++GstGdkPixbufSink::last-pixbuf ++GdkPixbuf* ++ ++r ++Last Pixbuf ++Last GdkPixbuf object rendered. ++ ++ ++ ++ ++GstGdkPixbufSink::post-messages ++gboolean ++ ++rw ++Post Messages ++Whether to post messages containing pixbufs on the bus. ++TRUE ++ ++ ++ ++GstGdkPixbufSink::send-messages ++gboolean ++ ++rw ++Send Messages ++Whether to post messages containing pixbufs on the bus (deprecated, use post-messages). ++TRUE ++ ++ ++ ++GstPixbufScale::method ++GstPixbufScaleMethod ++ ++rw ++method ++method. ++2 ++ ++ ++ ++GstGdkPixbuf::silent ++gboolean ++ ++rw ++Silent ++Produce verbose output ? (deprecated). ++FALSE ++ ++ ++ ++GstWavpackEnc::bitrate ++guint ++<= 9600000 ++rw ++Bitrate ++Try to encode with this average bitrate (bits/sec). This enables lossy encoding, values smaller than 24000 disable it again. ++0 ++ ++ ++ ++GstWavpackEnc::bits-per-sample ++gdouble ++[0,24] ++rw ++Bits per sample ++Try to encode with this amount of bits per sample. This enables lossy encoding, values smaller than 2.0 disable it again. ++0 ++ ++ ++ ++GstWavpackEnc::correction-mode ++GstWavpackEncCorrectionMode ++ ++rw ++Correction stream mode ++Use this mode for the correction stream. Only works in lossy mode!. ++Create no correction file ++ ++ ++ ++GstWavpackEnc::extra-processing ++guint ++<= 6 ++rw ++Extra processing ++Use better but slower filters for better compression/quality. ++0 ++ ++ ++ ++GstWavpackEnc::joint-stereo-mode ++GstWavpackEncJSMode ++ ++rw ++Joint-Stereo mode ++Use this joint-stereo mode. ++auto ++ ++ ++ ++GstWavpackEnc::md5 ++gboolean ++ ++rw ++MD5 ++Store MD5 hash of raw samples within the file. ++FALSE ++ ++ ++ ++GstWavpackEnc::mode ++GstWavpackEncMode ++ ++rw ++Encoding mode ++Speed versus compression tradeoff. ++Normal Compression ++ ++ ++ ++GstShout2send::description ++gchar* ++ ++rw ++description ++description. ++"" ++ ++ ++ ++GstShout2send::genre ++gchar* ++ ++rw ++genre ++genre. ++"" ++ ++ ++ ++GstShout2send::ip ++gchar* ++ ++rw ++ip ++ip. ++"127.0.0.1" ++ ++ ++ ++GstShout2send::mount ++gchar* ++ ++rw ++mount ++mount. ++"" ++ ++ ++ ++GstShout2send::password ++gchar* ++ ++rw ++password ++password. ++"hackme" ++ ++ ++ ++GstShout2send::port ++gint ++[1,65535] ++rw ++port ++port. ++8000 ++ ++ ++ ++GstShout2send::protocol ++GstShout2SendProtocol ++ ++rw ++protocol ++Connection Protocol to use. ++Http Protocol (icecast 2.x) ++ ++ ++ ++GstShout2send::public ++gboolean ++ ++rw ++public ++If the stream should be listed on the server's stream directory. ++FALSE ++ ++ ++ ++GstShout2send::streamname ++gchar* ++ ++rw ++streamname ++name of the stream. ++"" ++ ++ ++ ++GstShout2send::url ++gchar* ++ ++rw ++url ++url. ++"" ++ ++ ++ ++GstShout2send::username ++gchar* ++ ++rw ++username ++username. ++"source" ++ ++ ++ ++GstSpeexEnc::abr ++gint ++>= 0 ++rw ++ABR ++Enable average bit-rate (0 = disabled). ++0 ++ ++ ++ ++GstSpeexEnc::bitrate ++gint ++>= 0 ++rw ++Encoding Bit-rate ++Specify an encoding bit-rate (in bps). (0 = automatic). ++0 ++ ++ ++ ++GstSpeexEnc::complexity ++gint ++>= 0 ++rw ++Complexity ++Set encoding complexity. ++3 ++ ++ ++ ++GstSpeexEnc::dtx ++gboolean ++ ++rw ++DTX ++Enable discontinuous transmission. ++FALSE ++ ++ ++ ++GstSpeexEnc::last-message ++gchar* ++ ++r ++last-message ++The last status message. ++NULL ++ ++ ++ ++GstSpeexEnc::mode ++GstSpeexEncMode ++ ++rw ++Mode ++The encoding mode. ++Auto ++ ++ ++ ++GstSpeexEnc::nframes ++gint ++>= 0 ++rw ++NFrames ++Number of frames per buffer. ++1 ++ ++ ++ ++GstSpeexEnc::quality ++gfloat ++[0,10] ++rw ++Quality ++Encoding quality. ++8 ++ ++ ++ ++GstSpeexEnc::vad ++gboolean ++ ++rw ++VAD ++Enable voice activity detection. ++FALSE ++ ++ ++ ++GstSpeexEnc::vbr ++gboolean ++ ++rw ++VBR ++Enable variable bit-rate. ++FALSE ++ ++ ++ ++GstSpeexDec::enh ++gboolean ++ ++rw ++Enh ++Enable perceptual enhancement. ++TRUE ++ ++ ++ ++GstAASink::brightness ++gint ++ ++rw ++brightness ++brightness. ++0 ++ ++ ++ ++GstAASink::contrast ++gint ++ ++rw ++contrast ++contrast. ++0 ++ ++ ++ ++GstAASink::dither ++GstAASinkDitherers ++ ++rw ++dither ++dither. ++no dithering ++ ++ ++ ++GstAASink::driver ++GstAASinkDrivers ++ ++rw ++driver ++driver. ++X11 driver 1.1 ++ ++ ++ ++GstAASink::frame-time ++gint ++ ++r ++frame_time ++frame_time. ++0 ++ ++ ++ ++GstAASink::frames-displayed ++gint ++ ++r ++frames_displayed ++frames_displayed. ++0 ++ ++ ++ ++GstAASink::gamma ++gfloat ++[0,5] ++rw ++gamma ++gamma. ++1 ++ ++ ++ ++GstAASink::height ++gint ++ ++rw ++height ++height. ++0 ++ ++ ++ ++GstAASink::inversion ++gboolean ++ ++rw ++inversion ++inversion. ++TRUE ++ ++ ++ ++GstAASink::randomval ++gint ++ ++rw ++randomval ++randomval. ++0 ++ ++ ++ ++GstAASink::width ++gint ++ ++rw ++width ++width. ++0 ++ ++ ++ ++GstSmokeEnc::keyframe ++gint ++[1,100000] ++rw ++Keyframe ++Insert keyframe every N frames. ++20 ++ ++ ++ ++GstSmokeEnc::qmax ++gint ++[0,100] ++rw ++Qmax ++Maximum quality. ++85 ++ ++ ++ ++GstSmokeEnc::qmin ++gint ++[0,100] ++rw ++Qmin ++Minimum quality. ++10 ++ ++ ++ ++GstSmokeEnc::threshold ++gint ++[0,100000000] ++rw ++Threshold ++Motion estimation threshold. ++3000 ++ ++ ++ ++GstJpegEnc::idct-method ++GstIDCTMethod ++ ++rw ++IDCT Method ++The IDCT algorithm to use. ++Faster, less accurate integer method ++ ++ ++ ++GstJpegEnc::quality ++gint ++[0,100] ++rw ++Quality ++Quality of encoding. ++85 ++ ++ ++ ++GstJpegDec::idct-method ++GstIDCTMethod ++ ++rw ++IDCT Method ++The IDCT algorithm to use. ++Faster, less accurate integer method ++ ++ ++ ++GstFlacEnc::blocksize ++guint ++[16,65535] ++rwx ++Blocksize ++Blocksize in samples. ++4608 ++ ++ ++ ++GstFlacEnc::escape-coding ++gboolean ++ ++rwx ++Do Escape coding ++search for escape codes in the entropy coding stage for slightly better compression. ++FALSE ++ ++ ++ ++GstFlacEnc::exhaustive-model-search ++gboolean ++ ++rwx ++Do exhaustive model search ++do exhaustive search of LP coefficient quantization (expensive!). ++FALSE ++ ++ ++ ++GstFlacEnc::loose-mid-side-stereo ++gboolean ++ ++rwx ++Loose mid side stereo ++Loose mid side stereo. ++FALSE ++ ++ ++ ++GstFlacEnc::max-lpc-order ++guint ++<= 32 ++rwx ++Max LPC order ++Max LPC order; 0 => use only fixed predictors. ++8 ++ ++ ++ ++GstFlacEnc::max-residual-partition-order ++guint ++<= 16 ++rwx ++Max residual partition order ++Max residual partition order (above 4 doesn't usually help much). ++3 ++ ++ ++ ++GstFlacEnc::mid-side-stereo ++gboolean ++ ++rwx ++Do mid side stereo ++Do mid side stereo (only for stereo input). ++TRUE ++ ++ ++ ++GstFlacEnc::min-residual-partition-order ++guint ++<= 16 ++rwx ++Min residual partition order ++Min residual partition order (above 4 doesn't usually help much). ++3 ++ ++ ++ ++GstFlacEnc::padding ++guint ++ ++rwx ++Padding ++Write a PADDING block with this length in bytes. ++0 ++ ++ ++ ++GstFlacEnc::qlp-coeff-prec-search ++gboolean ++ ++rwx ++Do QLP coefficients precision search ++false = use qlp_coeff_precision, true = search around qlp_coeff_precision, take best. ++FALSE ++ ++ ++ ++GstFlacEnc::qlp-coeff-precision ++guint ++<= 32 ++rwx ++QLP coefficients precision ++Precision in bits of quantized linear-predictor coefficients; 0 = automatic. ++0 ++ ++ ++ ++GstFlacEnc::quality ++GstFlacEncQuality ++ ++rwx ++Quality ++Speed versus compression tradeoff. ++5 - Default ++ ++ ++ ++GstFlacEnc::rice-parameter-search-dist ++guint ++<= 15 ++rwx ++rice_parameter_search_dist ++0 = try only calc'd parameter k; else try all [k-dist..k+dist] parameters, use best. ++0 ++ ++ ++ ++GstFlacEnc::seekpoints ++gint ++>= -2147483647 ++rwx ++Seekpoints ++Add SEEKTABLE metadata (if > 0, number of entries, if < 0, interval in sec). ++0 ++ ++ ++ ++GstFlacEnc::streamable-subset ++gboolean ++ ++rwx ++Streamable subset ++true to limit encoder to generating a Subset stream, else false. ++TRUE ++ ++ ++ ++GstPulseSrc::device ++gchar* ++ ++rw ++Device ++The PulseAudio source device to connect to. ++NULL ++ ++ ++ ++GstPulseSrc::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstPulseSrc::server ++gchar* ++ ++rw ++Server ++The PulseAudio server to connect to. ++NULL ++ ++ ++ ++GstPulseSink::device ++gchar* ++ ++rw ++Device ++The PulseAudio sink device to connect to. ++NULL ++ ++ ++ ++GstPulseSink::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstPulseSink::mute ++gboolean ++ ++rw ++Mute ++Mute state of this stream. ++FALSE ++ ++ ++ ++GstPulseSink::server ++gchar* ++ ++rw ++Server ++The PulseAudio server to connect to. ++NULL ++ ++ ++ ++GstPulseSink::volume ++gdouble ++[0,10] ++rw ++Volume ++Linear volume of this stream, 1.0=100%. ++1 ++ ++ ++ ++GstPulseMixer::device ++gchar* ++ ++rw ++Device ++The PulseAudio sink or source to control. ++NULL ++ ++ ++ ++GstPulseMixer::device-name ++gchar* ++ ++r ++Device name ++Human-readable name of the sound device. ++NULL ++ ++ ++ ++GstPulseMixer::server ++gchar* ++ ++rw ++Server ++The PulseAudio server to connect to. ++NULL ++ ++ ++ ++GstPngEnc::compression-level ++guint ++<= 9 ++rw ++compression-level ++PNG compression level. ++6 ++ ++ ++ ++GstPngEnc::snapshot ++gboolean ++ ++rw ++Snapshot ++Send EOS after encoding a frame, useful for snapshots. ++TRUE ++ ++ ++ ++GstDVDec::clamp-chroma ++gboolean ++ ++rw ++Clamp chroma ++Clamp chroma. ++FALSE ++ ++ ++ ++GstDVDec::clamp-luma ++gboolean ++ ++rw ++Clamp luma ++Clamp luma. ++FALSE ++ ++ ++ ++GstDVDec::drop-factor ++gint ++>= 1 ++rw ++Drop Factor ++Only decode Nth frame. ++1 ++ ++ ++ ++GstDVDec::quality ++GstDVDecQualityEnum ++ ++rw ++Quality ++Decoding quality. ++Highest quality colour decoding ++ ++ ++ ++GstGConfAudioSink::profile ++GstGConfProfile ++ ++rw ++Profile ++Profile. ++Sound Events ++ ++ ++ ++GstCmmlEnc::granule-rate-denominator ++gint64 ++>= 0 ++rwx ++Granulerate denominator ++Granulerate denominator. ++1 ++ ++ ++ ++GstCmmlEnc::granule-rate-numerator ++gint64 ++>= 0 ++rwx ++Granulerate numerator ++Granulerate numerator. ++1000 ++ ++ ++ ++GstCmmlEnc::granule-shift ++guchar ++<= 64 ++rwx ++Granuleshift ++The number of lower bits to use for partitioning a granule position. ++32 ++ ++ ++ ++GstCmmlDec::wait-clip-end-time ++gboolean ++ ++rw ++Wait clip end time ++Send a tag for a clip when the clip ends, setting its end-time. Use when you need to know both clip's start-time and end-time. ++FALSE ++ ++ ++ ++GstCACASink::anti-aliasing ++gboolean ++ ++rw ++Anti Aliasing ++Enables Anti-Aliasing. ++TRUE ++ ++ ++ ++GstCACASink::dither ++GstCACASinkDithering ++ ++rw ++Dither Type ++Set type of Dither. ++No dithering ++ ++ ++ ++GstCACASink::screen-height ++gint ++>= 0 ++r ++Screen Height ++The height of the screen. ++25 ++ ++ ++ ++GstCACASink::screen-width ++gint ++>= 0 ++r ++Screen Width ++The width of the screen. ++80 ++ ++ ++ ++GstHDV1394Src::channel ++gint ++[0,64] ++rw ++Channel ++Channel number for listening. ++63 ++ ++ ++ ++GstHDV1394Src::device-name ++gchar* ++ ++r ++device name ++user-friendly name of the device. ++"Default" ++ ++ ++ ++GstHDV1394Src::guid ++guint64 ++ ++rw ++GUID ++select one of multiple DV devices by its GUID. use a hexadecimal like 0xhhhhhhhhhhhhhhhh. (0 = no guid). ++0 ++ ++ ++ ++GstHDV1394Src::port ++gint ++[G_MAXULONG,16] ++rw ++Port ++Port number (-1 automatic). ++-1 ++ ++ ++ ++GstHDV1394Src::use-avc ++gboolean ++ ++rw ++Use AV/C ++Use AV/C VTR control. ++TRUE ++ ++ ++ ++GstDV1394Src::channel ++gint ++[0,64] ++rw ++Channel ++Channel number for listening. ++63 ++ ++ ++ ++GstDV1394Src::consecutive ++gint ++>= 1 ++rw ++consecutive frames ++send n consecutive frames after skipping. ++1 ++ ++ ++ ++GstDV1394Src::device-name ++gchar* ++ ++r ++device name ++user-friendly name of the device. ++"Default" ++ ++ ++ ++GstDV1394Src::drop-incomplete ++gboolean ++ ++rw ++drop_incomplete ++drop incomplete frames. ++TRUE ++ ++ ++ ++GstDV1394Src::guid ++guint64 ++ ++rw ++GUID ++select one of multiple DV devices by its GUID. use a hexadecimal like 0xhhhhhhhhhhhhhhhh. (0 = no guid). ++0 ++ ++ ++ ++GstDV1394Src::port ++gint ++[G_MAXULONG,16] ++rw ++Port ++Port number (-1 automatic). ++-1 ++ ++ ++ ++GstDV1394Src::skip ++gint ++>= 0 ++rw ++skip frames ++skip n frames. ++0 ++ ++ ++ ++GstDV1394Src::use-avc ++gboolean ++ ++rw ++Use AV/C ++Use AV/C VTR control. ++TRUE ++ ++ ++ ++GstEsdSink::host ++gchar* ++ ++rw ++Host ++The host running the esound daemon. ++NULL ++ ++ +--- /dev/null ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins-decl-list.txt +@@ -0,0 +1,2267 @@ ++
++gstaasink ++GstAASink ++GstAASink ++GstAASinkClass ++ ++GST_AASINK ++GST_IS_AASINK ++GST_TYPE_AASINK ++gst_aasink_get_type ++GST_AASINK_CLASS ++GST_IS_AASINK_CLASS ++
++ ++
++gstcmmldec ++GstCmmlDec ++GstCmmlDec ++GstCmmlDecClass ++gst_cmml_dec_plugin_init ++ ++GST_CMML_DEC ++GST_IS_CMML_DEC ++GST_TYPE_CMML_DEC ++gst_cmml_dec_get_type ++GST_CMML_DEC_CLASS ++GST_IS_CMML_DEC_CLASS ++GST_CMML_DEC_GET_CLASS ++
++ ++
++gstcmmlenc ++GstCmmlEnc ++GstCmmlEnc ++GstCmmlEncClass ++gst_cmml_enc_plugin_init ++ ++GST_CMML_ENC ++GST_IS_CMML_ENC ++GST_TYPE_CMML_ENC ++gst_cmml_enc_get_type ++GST_CMML_ENC_CLASS ++GST_IS_CMML_ENC_CLASS ++GST_CMML_ENC_GET_CLASS ++
++ ++
++gsttextoverlay ++GstCairoTextOverlay ++GstCairoTextOverlay ++GstCairoTextOverlayClass ++GstCairoTextOverlayVAlign ++GstCairoTextOverlayHAlign ++ ++GST_CAIRO_TEXT_OVERLAY ++GST_IS_CAIRO_TEXT_OVERLAY ++GST_TYPE_CAIRO_TEXT_OVERLAY ++gst_text_overlay_get_type ++GST_CAIRO_TEXT_OVERLAY_CLASS ++GST_IS_CAIRO_TEXT_OVERLAY_CLASS ++GST_CAIRO_TEXT_OVERLAY_GET_CLASS ++
++ ++
++gsttimeoverlay ++GstCairoTimeOverlay ++GstCairoTimeOverlay ++GstCairoTimeOverlayClass ++ ++GST_CAIRO_TIME_OVERLAY ++GST_IS_CAIRO_TIME_OVERLAY ++GST_TYPE_CAIRO_TIME_OVERLAY ++gst_cairo_time_overlay_get_type ++GST_CAIRO_TIME_OVERLAY_CLASS ++GST_IS_CAIRO_TIME_OVERLAY_CLASS ++
++ ++
++gstdvdec ++GstDVDec ++GstDVDec ++GstDVDecClass ++ ++GST_DVDEC ++GST_IS_DVDEC ++GST_TYPE_DVDEC ++gst_dvdec_get_type ++GST_DVDEC_CLASS ++GST_IS_DVDEC_CLASS ++
++ ++
++gstdvdemux ++GstDVDemux ++GstDVDemux ++GstDVDemuxClass ++GstDVDemuxSeekHandler ++ ++GST_DVDEMUX ++GST_IS_DVDEMUX ++GST_TYPE_DVDEMUX ++gst_dvdemux_get_type ++GST_DVDEMUX_CLASS ++GST_IS_DVDEMUX_CLASS ++
++ ++
++esdsink ++GstEsdSink ++GstEsdSink ++GstEsdSinkClass ++ ++GST_ESDSINK ++GST_IS_ESDSINK ++GST_TYPE_ESDSINK ++gst_esdsink_get_type ++GST_ESDSINK_CLASS ++GST_IS_ESDSINK_CLASS ++
++ ++
++gstflacdec ++GstFlacDec ++GstFlacDec ++GstFlacDecClass ++ ++GST_FLAC_DEC ++GST_IS_FLAC_DEC ++GST_TYPE_FLAC_DEC ++gst_flac_dec_get_type ++GST_FLAC_DEC_CLASS ++GST_IS_FLAC_DEC_CLASS ++
++ ++
++gstflacenc ++GstFlacEnc ++GstFlacEnc ++GstFlacEncClass ++ ++GST_FLAC_ENC ++GST_IS_FLAC_ENC ++GST_TYPE_FLAC_ENC ++gst_flac_enc_get_type ++GST_FLAC_ENC_CLASS ++GST_IS_FLAC_ENC_CLASS ++
++ ++
++gstflactag ++GstFlacTag ++GstFlacTag ++GstFlacTagClass ++GstFlacTagState ++ ++GST_FLAC_TAG ++GST_IS_FLAC_TAG ++GST_TYPE_FLAC_TAG ++gst_flac_tag_get_type ++GST_FLAC_TAG_CLASS ++GST_IS_FLAC_TAG_CLASS ++
++ ++
++gstgconfaudiosrc ++GstGConfAudioSrc ++GstGConfAudioSrc ++GstGConfAudioSrcClass ++ ++GST_GCONF_AUDIO_SRC ++GST_IS_GCONF_AUDIO_SRC ++GST_TYPE_GCONF_AUDIO_SRC ++gst_gconf_audio_src_get_type ++GST_GCONF_AUDIO_SRC_CLASS ++GST_IS_GCONF_AUDIO_SRC_CLASS ++
++ ++
++gstgconfaudiosink ++GstGConfAudioSink ++GstGConfAudioSink ++GstGConfAudioSinkClass ++ ++GST_GCONF_AUDIO_SINK ++GST_IS_GCONF_AUDIO_SINK ++GST_TYPE_GCONF_AUDIO_SINK ++gst_gconf_audio_sink_get_type ++GST_GCONF_AUDIO_SINK_CLASS ++GST_IS_GCONF_AUDIO_SINK_CLASS ++
++ ++
++gstgconfvideosrc ++GstGConfVideoSrc ++GstGConfVideoSrc ++GstGConfVideoSrcClass ++ ++GST_GCONF_VIDEO_SRC ++GST_IS_GCONF_VIDEO_SRC ++GST_TYPE_GCONF_VIDEO_SRC ++gst_gconf_video_src_get_type ++GST_GCONF_VIDEO_SRC_CLASS ++GST_IS_GCONF_VIDEO_SRC_CLASS ++
++ ++
++gstgconfvideosink ++GstGConfVideoSink ++GstGConfVideoSink ++GstGConfVideoSinkClass ++ ++GST_GCONF_VIDEO_SINK ++GST_IS_GCONF_VIDEO_SINK ++GST_TYPE_GCONF_VIDEO_SINK ++gst_gconf_video_sink_get_type ++GST_GCONF_VIDEO_SINK_CLASS ++GST_IS_GCONF_VIDEO_SINK_CLASS ++
++ ++
++gstgdkpixbufsink ++GstGdkPixbufSink ++GstGdkPixbufSink ++GstGdkPixbufSinkClass ++ ++GST_GDK_PIXBUF_SINK ++GST_IS_GDK_PIXBUF_SINK ++GST_TYPE_GDK_PIXBUF_SINK ++gst_gdk_pixbuf_sink_get_type ++GST_GDK_PIXBUF_SINK_CLASS ++GST_IS_GDK_PIXBUF_SINK_CLASS ++
++ ++
++gsthalaudiosink ++GstHalAudioSink ++GstHalAudioSink ++GstHalAudioSinkClass ++ ++GST_HAL_AUDIO_SINK ++GST_IS_HAL_AUDIO_SINK ++GST_TYPE_HAL_AUDIO_SINK ++gst_hal_audio_sink_get_type ++GST_HAL_AUDIO_SINK_CLASS ++GST_IS_HAL_AUDIO_SINK_CLASS ++
++ ++
++gsthalaudiosrc ++GstHalAudioSrc ++GstHalAudioSrc ++GstHalAudioSrcClass ++ ++GST_HAL_AUDIO_SRC ++GST_IS_HAL_AUDIO_SRC ++GST_TYPE_HAL_AUDIO_SRC ++gst_hal_audio_src_get_type ++GST_HAL_AUDIO_SRC_CLASS ++GST_IS_HAL_AUDIO_SRC_CLASS ++
++ ++
++gstjpegdec ++GstJpegDec ++GstJpegDec ++GstJpegDecClass ++ ++GST_JPEG_DEC ++GST_IS_JPEG_DEC ++GST_TYPE_JPEG_DEC ++gst_jpeg_dec_get_type ++GST_JPEG_DEC_CLASS ++GST_IS_JPEG_DEC_CLASS ++
++ ++
++gstjpegenc ++GstJpegEnc ++GstJpegEnc ++GstJpegEncClass ++GST_JPEG_ENC_MAX_COMPONENT ++ ++GST_JPEGENC ++GST_IS_JPEGENC ++GST_TYPE_JPEGENC ++gst_jpegenc_get_type ++GST_JPEGENC_CLASS ++GST_IS_JPEGENC_CLASS ++
++ ++
++gstsmokedec ++GstSmokeDec ++GstSmokeDec ++GstSmokeDecClass ++ ++GST_SMOKEDEC ++GST_IS_SMOKEDEC ++GST_TYPE_SMOKEDEC ++gst_smokedec_get_type ++GST_SMOKEDEC_CLASS ++GST_IS_SMOKEDEC_CLASS ++
++ ++
++gstsmokeenc ++GstSmokeEnc ++GstSmokeEnc ++GstSmokeEncClass ++ ++GST_SMOKEENC ++GST_IS_SMOKEENC ++GST_TYPE_SMOKEENC ++gst_smokeenc_get_type ++GST_SMOKEENC_CLASS ++GST_IS_SMOKEENC_CLASS ++
++ ++
++gstcacasink ++GstCACASink ++GstCACASink ++GstCACASinkClass ++ ++GST_CACASINK ++GST_IS_CACASINK ++GST_TYPE_CACASINK ++gst_cacasink_get_type ++GST_CACASINK_CLASS ++GST_IS_CACASINK_CLASS ++
++ ++
++gstpngdec ++GstPngDec ++GstPngDec ++GstPngDecClass ++ ++GST_PNGDEC ++GST_IS_PNGDEC ++GST_TYPE_PNGDEC ++gst_pngdec_get_type ++GST_PNGDEC_CLASS ++GST_IS_PNGDEC_CLASS ++
++ ++
++gstpngenc ++GstPngEnc ++GstPngEnc ++GstPngEncClass ++ ++GST_PNGENC ++GST_IS_PNGENC ++GST_TYPE_PNGENC ++gst_pngenc_get_type ++GST_PNGENC_CLASS ++GST_IS_PNGENC_CLASS ++
++ ++
++gstdv1394src ++GstDV1394Src ++GstDV1394Src ++GstDV1394SrcClass ++ ++GST_DV1394SRC ++GST_IS_DV1394SRC ++GST_TYPE_DV1394SRC ++gst_dv1394src_get_type ++GST_DV1394SRC_CLASS ++GST_IS_DV1394SRC_CLASS ++
++ ++
++gsthdv1394src ++GstHDV1394Src ++GstHDV1394Src ++GstHDV1394SrcClass ++ ++GST_HDV1394SRC ++GST_IS_HDV1394SRC ++GST_TYPE_HDV1394SRC ++gst_hdv1394src_get_type ++GST_HDV1394SRC_CLASS ++GST_IS_HDV1394SRC_CLASS ++
++ ++
++gstsouphttpsrc ++GstSoupHTTPSrc ++GstSoupHTTPSrc ++GstSoupHTTPSrcClass ++GstSoupHTTPSrcSessionIOStatus ++ ++GST_SOUP_HTTP_SRC ++GST_IS_SOUP_HTTP_SRC ++GST_TYPE_SOUP_HTTP_SRC ++gst_soup_http_src_get_type ++GST_SOUP_HTTP_SRC_CLASS ++GST_IS_SOUP_HTTP_SRC_CLASS ++
++ ++
++gstapev2mux ++GstApev2Mux ++GstApev2Mux ++GstApev2MuxClass ++ ++GST_APEV2_MUX ++GST_IS_APEV2_MUX ++GST_TYPE_APEV2_MUX ++gst_apev2_mux_get_type ++GST_APEV2_MUX_CLASS ++GST_IS_APEV2_MUX_CLASS ++
++ ++
++gstid3v2mux ++GstId3v2Mux ++GstId3v2Mux ++GstId3v2MuxClass ++ ++GST_ID3V2_MUX ++GST_IS_ID3V2_MUX ++GST_TYPE_ID3V2_MUX ++gst_id3v2_mux_get_type ++GST_ID3V2_MUX_CLASS ++GST_IS_ID3V2_MUX_CLASS ++
++ ++
++pulsesink ++GstPulseSink ++GST_PULSESINK_CAST ++GstPulseSink ++GstPulseSinkClass ++ ++GST_PULSESINK ++GST_IS_PULSESINK ++GST_TYPE_PULSESINK ++gst_pulsesink_get_type ++GST_PULSESINK_CLASS ++GST_IS_PULSESINK_CLASS ++
++ ++
++pulsesrc ++GstPulseSrc ++GST_PULSESRC_CAST ++GstPulseSrc ++GstPulseSrcClass ++ ++GST_PULSESRC ++GST_IS_PULSESRC ++GST_TYPE_PULSESRC ++gst_pulsesrc_get_type ++GST_PULSESRC_CLASS ++GST_IS_PULSESRC_CLASS ++
++ ++
++pulsemixer ++GstPulseMixer ++GstPulseMixer ++GstPulseMixerClass ++ ++GST_PULSEMIXER ++GST_IS_PULSEMIXER ++GST_TYPE_PULSEMIXER ++gst_pulsemixer_get_type ++GST_PULSEMIXER_CLASS ++GST_IS_PULSEMIXER_CLASS ++
++ ++
++gstspeexenc ++GstSpeexEnc ++GstSpeexMode ++GstSpeexEnc ++GstSpeexEncClass ++ ++GST_SPEEX_ENC ++GST_IS_SPEEX_ENC ++GST_TYPE_SPEEX_ENC ++gst_speex_enc_get_type ++GST_SPEEX_ENC_CLASS ++GST_IS_SPEEX_ENC_CLASS ++
++ ++
++gstspeexdec ++GstSpeexDec ++GstSpeexDec ++GstSpeexDecClass ++ ++GST_SPEEX_DEC ++GST_IS_SPEEX_DEC ++GST_TYPE_SPEEX_DEC ++gst_speex_dec_get_type ++GST_SPEEX_DEC_CLASS ++GST_IS_SPEEX_DEC_CLASS ++
++ ++
++gstwavpackdec ++GstWavpackDec ++GstWavpackDec ++GstWavpackDecClass ++gst_wavpack_dec_plugin_init ++ ++GST_WAVPACK_DEC ++GST_IS_WAVPACK_DEC ++GST_TYPE_WAVPACK_DEC ++gst_wavpack_dec_get_type ++GST_WAVPACK_DEC_CLASS ++GST_IS_WAVPACK_DEC_CLASS ++
++ ++
++gstwavpackenc ++GstWavpackEnc ++GstWavpackEnc ++GstWavpackEncClass ++gst_wavpack_enc_plugin_init ++ ++GST_WAVPACK_ENC ++GST_IS_WAVPACK_ENC ++GST_TYPE_WAVPACK_ENC ++gst_wavpack_enc_get_type ++GST_WAVPACK_ENC_CLASS ++GST_IS_WAVPACK_ENC_CLASS ++
++ ++
++gstwavpackparse ++GstWavpackParse ++GstWavpackParse ++GstWavpackParseClass ++GstWavpackParseIndexEntry ++gst_wavpack_parse_plugin_init ++ ++GST_WAVPACK_PARSE ++GST_IS_WAVPACK_PARSE ++GST_TYPE_WAVPACK_PARSE ++gst_wavpack_parse_get_type ++GST_WAVPACK_PARSE_CLASS ++GST_IS_WAVPACK_PARSE_CLASS ++
++ ++
++gstalpha ++GstAlpha ++GstAlpha ++GstAlphaClass ++GstAlphaMethod ++GST_CAT_DEFAULT ++ ++GST_ALPHA ++GST_IS_ALPHA ++GST_TYPE_ALPHA ++gst_alpha_get_type ++GST_ALPHA_CLASS ++GST_IS_ALPHA_CLASS ++
++ ++
++gstalphacolor ++GstAlphaColor ++GstAlphaColor ++GstAlphaColorClass ++ ++GST_ALPHA_COLOR ++GST_IS_ALPHA_COLOR ++GST_TYPE_ALPHA_COLOR ++gst_alpha_color_get_type ++GST_ALPHA_COLOR_CLASS ++GST_IS_ALPHA_COLOR_CLASS ++
++ ++
++gstapedemux ++GstApeDemux ++GstApeDemux ++GstApeDemuxClass ++ ++GST_APE_DEMUX ++GST_IS_APE_DEMUX ++GST_TYPE_APE_DEMUX ++gst_ape_demux_get_type ++GST_APE_DEMUX_CLASS ++GST_IS_APE_DEMUX_CLASS ++
++ ++
++audioamplify ++GstAudioAmplify ++GstAudioAmplify ++GstAudioAmplifyClass ++GstAudioAmplifyProcessFunc ++ ++GST_AUDIO_AMPLIFY ++GST_IS_AUDIO_AMPLIFY ++GST_TYPE_AUDIO_AMPLIFY ++gst_audio_amplify_get_type ++GST_AUDIO_AMPLIFY_CLASS ++GST_IS_AUDIO_AMPLIFY_CLASS ++GST_AUDIO_AMPLIFY_GET_CLASS ++
++ ++
++audioecho ++GstAudioEcho ++GstAudioEcho ++GstAudioEchoClass ++GstAudioEchoProcessFunc ++ ++GST_AUDIO_ECHO ++GST_IS_AUDIO_ECHO ++GST_TYPE_AUDIO_ECHO ++gst_audio_echo_get_type ++GST_AUDIO_ECHO_CLASS ++GST_IS_AUDIO_ECHO_CLASS ++GST_AUDIO_ECHO_GET_CLASS ++
++ ++
++audiodynamic ++GstAudioDynamic ++GstAudioDynamic ++GstAudioDynamicClass ++GstAudioDynamicProcessFunc ++ ++GST_AUDIO_DYNAMIC ++GST_IS_AUDIO_DYNAMIC ++GST_TYPE_AUDIO_DYNAMIC ++gst_audio_dynamic_get_type ++GST_AUDIO_DYNAMIC_CLASS ++GST_IS_AUDIO_DYNAMIC_CLASS ++GST_AUDIO_DYNAMIC_GET_CLASS ++
++ ++
++audioinvert ++GstAudioInvert ++GstAudioInvert ++GstAudioInvertClass ++GstAudioInvertProcessFunc ++ ++GST_AUDIO_INVERT ++GST_IS_AUDIO_INVERT ++GST_TYPE_AUDIO_INVERT ++gst_audio_invert_get_type ++GST_AUDIO_INVERT_CLASS ++GST_IS_AUDIO_INVERT_CLASS ++GST_AUDIO_INVERT_GET_CLASS ++
++ ++
++audiokaraoke ++GstAudioKaraoke ++GstAudioKaraoke ++GstAudioKaraokeClass ++GstAudioKaraokeProcessFunc ++ ++GST_AUDIO_KARAOKE ++GST_IS_AUDIO_KARAOKE ++GST_TYPE_AUDIO_KARAOKE ++gst_audio_karaoke_get_type ++GST_AUDIO_KARAOKE_CLASS ++GST_IS_AUDIO_KARAOKE_CLASS ++GST_AUDIO_KARAOKE_GET_CLASS ++
++ ++
++audiopanorama ++GstAudioPanorama ++GstAudioPanorama ++GstAudioPanoramaClass ++GstAudioPanoramaProcessFunc ++ ++GST_AUDIO_PANORAMA ++GST_IS_AUDIO_PANORAMA ++GST_TYPE_AUDIO_PANORAMA ++gst_audio_panorama_get_type ++GST_AUDIO_PANORAMA_CLASS ++GST_IS_AUDIO_PANORAMA_CLASS ++GST_AUDIO_PANORAMA_GET_CLASS ++
++ ++
++audiocheblimit ++GstAudioChebLimit ++GstAudioChebLimit ++GstAudioChebLimitClass ++ ++GST_AUDIO_CHEB_LIMIT ++GST_IS_AUDIO_CHEB_LIMIT ++GST_TYPE_AUDIO_CHEB_LIMIT ++gst_audio_cheb_limit_get_type ++GST_AUDIO_CHEB_LIMIT_CLASS ++GST_IS_AUDIO_CHEB_LIMIT_CLASS ++GST_AUDIO_CHEB_LIMIT_GET_CLASS ++
++ ++
++audiochebband ++GstAudioChebBand ++GstAudioChebBand ++GstAudioChebBandClass ++ ++GST_AUDIO_CHEB_BAND ++GST_IS_AUDIO_CHEB_BAND ++GST_TYPE_AUDIO_CHEB_BAND ++gst_audio_cheb_band_get_type ++GST_AUDIO_CHEB_BAND_CLASS ++GST_IS_AUDIO_CHEB_BAND_CLASS ++GST_AUDIO_CHEB_BAND_GET_CLASS ++
++ ++
++audioiirfilter ++GstAudioIIRFilter ++GstAudioIIRFilter ++GstAudioIIRFilterClass ++ ++GST_AUDIO_IIR_FILTER ++GST_IS_AUDIO_IIR_FILTER ++GST_TYPE_AUDIO_IIR_FILTER ++gst_audio_iir_filter_get_type ++GST_AUDIO_IIR_FILTER_CLASS ++GST_IS_AUDIO_IIR_FILTER_CLASS ++
++ ++
++audiowsincband ++GstAudioWSincBand ++GstAudioWSincBand ++GstAudioWSincBandClass ++ ++GST_AUDIO_WSINC_BAND ++GST_IS_AUDIO_WSINC_BAND ++GST_TYPE_AUDIO_WSINC_BAND ++gst_audio_wsincband_get_type ++GST_AUDIO_WSINC_BAND_CLASS ++GST_IS_AUDIO_WSINC_BAND_CLASS ++
++ ++
++audiowsinclimit ++GstAudioWSincLimit ++GstAudioWSincLimit ++GstAudioWSincLimitClass ++ ++GST_AUDIO_WSINC_LIMIT ++GST_IS_AUDIO_WSINC_LIMIT ++GST_TYPE_AUDIO_WSINC_LIMIT ++gst_audio_wsinclimit_get_type ++GST_AUDIO_WSINC_LIMIT_CLASS ++GST_IS_AUDIO_WSINC_LIMIT_CLASS ++
++ ++
++audiofirfilter ++GstAudioFIRFilter ++GstAudioFIRFilter ++GstAudioFIRFilterClass ++ ++GST_AUDIO_FIR_FILTER ++GST_IS_AUDIO_FIR_FILTER ++GST_TYPE_AUDIO_FIR_FILTER ++gst_audio_fir_filter_get_type ++GST_AUDIO_FIR_FILTER_CLASS ++GST_IS_AUDIO_FIR_FILTER_CLASS ++
++ ++
++gstauparse ++GstAuParse ++GstAuParse ++GstAuParseClass ++ ++GST_AU_PARSE ++GST_IS_AU_PARSE ++GST_TYPE_AU_PARSE ++gst_au_parse_get_type ++GST_AU_PARSE_CLASS ++GST_IS_AU_PARSE_CLASS ++
++ ++
++gstautoaudiosink ++GstAutoAudioSink ++GstAutoAudioSink ++GstAutoAudioSinkClass ++ ++GST_AUTO_AUDIO_SINK ++GST_IS_AUTO_AUDIO_SINK ++GST_TYPE_AUTO_AUDIO_SINK ++gst_auto_audio_sink_get_type ++GST_AUTO_AUDIO_SINK_CLASS ++GST_IS_AUTO_AUDIO_SINK_CLASS ++
++ ++
++gstautoaudiosrc ++GstAutoAudioSrc ++GstAutoAudioSrc ++GstAutoAudioSrcClass ++ ++GST_AUTO_AUDIO_SRC ++GST_IS_AUTO_AUDIO_SRC ++GST_TYPE_AUTO_AUDIO_SRC ++gst_auto_audio_src_get_type ++GST_AUTO_AUDIO_SRC_CLASS ++GST_IS_AUTO_AUDIO_SRC_CLASS ++
++ ++
++gstautovideosink ++GstAutoVideoSink ++GstAutoVideoSink ++GstAutoVideoSinkClass ++ ++GST_AUTO_VIDEO_SINK ++GST_IS_AUTO_VIDEO_SINK ++GST_TYPE_AUTO_VIDEO_SINK ++gst_auto_video_sink_get_type ++GST_AUTO_VIDEO_SINK_CLASS ++GST_IS_AUTO_VIDEO_SINK_CLASS ++
++ ++
++gstautovideosrc ++GstAutoVideoSrc ++GstAutoVideoSrc ++GstAutoVideoSrcClass ++ ++GST_AUTO_VIDEO_SRC ++GST_IS_AUTO_VIDEO_SRC ++GST_TYPE_AUTO_VIDEO_SRC ++gst_auto_video_src_get_type ++GST_AUTO_VIDEO_SRC_CLASS ++GST_IS_AUTO_VIDEO_SRC_CLASS ++
++ ++
++gstavidemux ++GstAviDemux ++GST_AVI_DEMUX_MAX_STREAMS ++CHUNKID_TO_STREAMNR ++GstAviIndexEntry ++GstAviStream ++GstAviDemuxState ++GstAviDemuxHeaderState ++GstAviDemux ++GstAviDemuxClass ++ ++GST_AVI_DEMUX ++GST_IS_AVI_DEMUX ++GST_TYPE_AVI_DEMUX ++gst_avi_demux_get_type ++GST_AVI_DEMUX_CLASS ++GST_IS_AVI_DEMUX_CLASS ++
++ ++
++gstavimux ++GstAviMux ++GST_AVI_INDEX_OF_INDEXES ++GST_AVI_INDEX_OF_CHUNKS ++GST_AVI_SUPERINDEX_COUNT ++GST_AVI_MAX_SIZE ++gst_avi_superindex_entry ++gst_riff_strh_full ++GstAviPad ++GstAviMux ++GstAviMuxClass ++GstAviPadHook ++GstAviVideoPad ++GstAviAudioPad ++GstAviCollectData ++ ++GST_AVI_MUX ++GST_IS_AVI_MUX ++GST_TYPE_AVI_MUX ++gst_avi_mux_get_type ++GST_AVI_MUX_CLASS ++GST_IS_AVI_MUX_CLASS ++
++ ++
++gstavisubtitle ++GstAviSubtitle ++GstAviSubtitle ++GstAviSubtitleClass ++ ++GST_AVI_SUBTITLE ++GST_IS_AVI_SUBTITLE ++GST_TYPE_AVI_SUBTITLE ++gst_avi_subtitle_get_type ++GST_AVI_SUBTITLE_CLASS ++GST_IS_AVI_SUBTITLE_CLASS ++GST_AVI_SUBTITLE_GET_CLASS ++
++ ++
++gstcutter ++GstCutter ++GstCutter ++GstCutterClass ++ ++GST_CUTTER ++GST_IS_CUTTER ++GST_TYPE_CUTTER ++gst_cutter_get_type ++GST_CUTTER_CLASS ++GST_IS_CUTTER_CLASS ++
++ ++
++gstcapssetter ++GstCapsSetter ++GstCapsSetter ++GstCapsSetterClass ++ ++GST_CAPS_SETTER ++GST_IS_CAPS_SETTER ++GST_TYPE_CAPS_SETTER ++gst_caps_setter_get_type ++GST_CAPS_SETTER_CLASS ++GST_IS_CAPS_SETTER_CLASS ++
++ ++
++gsttaginject ++GstTagInject ++GstTagInject ++GstTagInjectClass ++ ++GST_TAG_INJECT ++GST_IS_TAG_INJECT ++GST_TYPE_TAG_INJECT ++gst_tag_inject_get_type ++GST_TAG_INJECT_CLASS ++GST_IS_TAG_INJECT_CLASS ++
++ ++
++progressreport ++GstProgressReport ++GstProgressReport ++GstProgressReportClass ++ ++GST_PROGRESS_REPORT ++GST_IS_PROGRESS_REPORT ++GST_TYPE_PROGRESS_REPORT ++gst_progress_report_get_type ++GST_PROGRESS_REPORT_CLASS ++GST_IS_PROGRESS_REPORT_CLASS ++
++ ++
++gstdeinterlace ++GstDeinterlace ++GstDeinterlace ++GstDeinterlaceClass ++GST_DEINTERLACE_MAX_FIELD_HISTORY ++GstDeinterlaceMethods ++GstDeinterlaceFields ++GstDeinterlaceFieldLayout ++GstDeinterlaceMode ++ ++GST_DEINTERLACE ++GST_IS_DEINTERLACE ++GST_TYPE_DEINTERLACE ++gst_deinterlace_get_type ++GST_DEINTERLACE_CLASS ++GST_IS_DEINTERLACE_CLASS ++
++ ++
++gstaging ++GstAgingTV ++SCRATCH_MAX ++GstAgingTV ++GstAgingTVClass ++ ++GST_AGINGTV ++GST_IS_AGINGTV ++GST_TYPE_AGINGTV ++gst_agingtv_get_type ++GST_AGINGTV_CLASS ++GST_IS_AGINGTV_CLASS ++
++ ++
++gstdice ++GstDiceTV ++GstDiceTV ++GstDiceTVClass ++ ++GST_DICETV ++GST_IS_DICETV ++GST_TYPE_DICETV ++gst_dicetv_get_type ++GST_DICETV_CLASS ++GST_IS_DICETV_CLASS ++
++ ++
++gstedge ++GstEdgeTV ++GstEdgeTV ++GstEdgeTVClass ++ ++GST_EDGETV ++GST_IS_EDGETV ++GST_TYPE_EDGETV ++gst_edgetv_get_type ++GST_EDGETV_CLASS ++GST_IS_EDGETV_CLASS ++
++ ++
++gstquark ++GstQuarkTV ++GstQuarkTV ++GstQuarkTVClass ++ ++GST_QUARKTV ++GST_IS_QUARKTV ++GST_TYPE_QUARKTV ++gst_quarktv_get_type ++GST_QUARKTV_CLASS ++GST_IS_QUARKTV_CLASS ++
++ ++
++gstrev ++GstRevTV ++GstRevTV ++GstRevTVClass ++ ++GST_REVTV ++GST_IS_REVTV ++GST_TYPE_REVTV ++gst_revtv_get_type ++GST_REVTV_CLASS ++GST_IS_REVTV_CLASS ++
++ ++
++gstshagadelic ++GstShagadelicTV ++GstShagadelicTV ++GstShagadelicTVClass ++ ++GST_SHAGADELICTV ++GST_IS_SHAGADELICTV ++GST_TYPE_SHAGADELICTV ++gst_shagadelictv_get_type ++GST_SHAGADELICTV_CLASS ++GST_IS_SHAGADELICTV_CLASS ++
++ ++
++gstvertigo ++GstVertigoTV ++GstVertigoTV ++GstVertigoTVClass ++ ++GST_VERTIGOTV ++GST_IS_VERTIGOTV ++GST_TYPE_VERTIGOTV ++gst_vertigotv_get_type ++GST_VERTIGOTV_CLASS ++GST_IS_VERTIGOTV_CLASS ++
++ ++
++gstwarp ++GstWarpTV ++GstWarpTV ++GstWarpTVClass ++ ++GST_WARPTV ++GST_IS_WARPTV ++GST_TYPE_WARPTV ++gst_warptv_get_type ++GST_WARPTV_CLASS ++GST_IS_WARPTV_CLASS ++
++ ++
++gststreak ++GstStreakTV ++GstStreakTV ++GstStreakTVClass ++PLANES ++ ++GST_STREAKTV ++GST_IS_STREAKTV ++GST_TYPE_STREAKTV ++gst_streaktv_get_type ++GST_STREAKTV_CLASS ++GST_IS_STREAKTV_CLASS ++
++ ++
++gstripple ++GstRippleTV ++GstRippleTV ++GstRippleTVClass ++ ++GST_RIPPLETV ++GST_IS_RIPPLETV ++GST_TYPE_RIPPLETV ++gst_rippletv_get_type ++GST_RIPPLETV_CLASS ++GST_IS_RIPPLETV_CLASS ++
++ ++
++gstop ++GstOpTV ++GstOpTV ++GstOpTVClass ++ ++GST_OPTV ++GST_IS_OPTV ++GST_TYPE_OPTV ++gst_optv_get_type ++GST_OPTV_CLASS ++GST_IS_OPTV_CLASS ++
++ ++
++gstradioac ++GstRadioacTV ++GstRadioacTV ++GstRadioacTVClass ++ ++GST_RADIOACTV ++GST_IS_RADIOACTV ++GST_TYPE_RADIOACTV ++gst_radioactv_get_type ++GST_RADIOACTV_CLASS ++GST_IS_RADIOACTV_CLASS ++
++ ++
++gstiirequalizer ++GstIirEqualizer ++GstIirEqualizer ++GstIirEqualizerClass ++GstIirEqualizerBand ++LOWEST_FREQ ++HIGHEST_FREQ ++ProcessFunc ++gst_iir_equalizer_compute_frequencies ++ ++GST_IIR_EQUALIZER ++GST_IS_IIR_EQUALIZER ++GST_TYPE_IIR_EQUALIZER ++gst_iir_equalizer_get_type ++GST_IIR_EQUALIZER_CLASS ++GST_IS_IIR_EQUALIZER_CLASS ++
++ ++
++gstiirequalizer3bands ++GstIirEqualizer3Bands ++GstIirEqualizer3Bands ++GstIirEqualizer3BandsClass ++ ++GST_IIR_EQUALIZER_3BANDS ++GST_IS_IIR_EQUALIZER_3BANDS ++GST_TYPE_IIR_EQUALIZER_3BANDS ++gst_iir_equalizer_3bands_get_type ++GST_IIR_EQUALIZER_3BANDS_CLASS ++GST_IS_IIR_EQUALIZER_3BANDS_CLASS ++
++ ++
++gstiirequalizer10bands ++GstIirEqualizer10Bands ++GstIirEqualizer10Bands ++GstIirEqualizer10BandsClass ++ ++GST_IIR_EQUALIZER_10BANDS ++GST_IS_IIR_EQUALIZER_10BANDS ++GST_TYPE_IIR_EQUALIZER_10BANDS ++gst_iir_equalizer_10bands_get_type ++GST_IIR_EQUALIZER_10BANDS_CLASS ++GST_IS_IIR_EQUALIZER_10BANDS_CLASS ++
++ ++
++gstiirequalizernbands ++GstIirEqualizerNBands ++GstIirEqualizerNBands ++GstIirEqualizerNBandsClass ++ ++GST_IIR_EQUALIZER_NBANDS ++GST_IS_IIR_EQUALIZER_NBANDS ++GST_TYPE_IIR_EQUALIZER_NBANDS ++gst_iir_equalizer_nbands_get_type ++GST_IIR_EQUALIZER_NBANDS_CLASS ++GST_IS_IIR_EQUALIZER_NBANDS_CLASS ++
++ ++
++gstflvdemux ++GstFlvDemux ++GstFlvDemux ++GstFlvDemuxClass ++GstFlvDemuxState ++ ++GST_FLV_DEMUX ++GST_IS_FLV_DEMUX ++GST_TYPE_FLV_DEMUX ++gst_flv_demux_get_type ++GST_FLV_DEMUX_CLASS ++GST_IS_FLV_DEMUX_CLASS ++
++ ++
++gstflvmux ++GstFlvMux ++GstFlvMuxState ++GstFlvMux ++GstFlvMuxClass ++ ++GST_FLV_MUX ++GST_IS_FLV_MUX ++GST_TYPE_FLV_MUX ++gst_flv_mux_get_type ++GST_FLV_MUX_CLASS ++GST_IS_FLV_MUX_CLASS ++
++ ++
++gstflxdec ++GstFlxDec ++GstFlxDecState ++GstFlxDec ++GstFlxDecClass ++ ++GST_FLXDEC ++GST_IS_FLXDEC ++GST_TYPE_FLXDEC ++gst_flxdec_get_type ++GST_FLXDEC_CLASS ++GST_IS_FLXDEC_CLASS ++
++ ++
++gstgoom ++GstGoom ++GOOM_SAMPLES ++GstGoom ++GstGoomClass ++ ++GST_GOOM ++GST_IS_GOOM ++GST_TYPE_GOOM ++gst_goom_get_type ++GST_GOOM_CLASS ++GST_IS_GOOM_CLASS ++
++ ++
++gstgoom ++GstGoom ++GOOM_SAMPLES ++GstGoom ++GstGoomClass ++ ++GST_GOOM ++GST_IS_GOOM ++GST_TYPE_GOOM ++gst_goom_get_type ++GST_GOOM_CLASS ++GST_IS_GOOM_CLASS ++
++ ++
++alaw-decode ++GstALawDec ++GstALawDec ++GstALawDecClass ++ ++GST_ALAW_DEC ++GST_IS_ALAW_DEC ++GST_TYPE_ALAW_DEC ++gst_alaw_dec_get_type ++GST_ALAW_DEC_CLASS ++GST_IS_ALAW_DEC_CLASS ++
++ ++
++alaw-encode ++GstALawEnc ++GstALawEnc ++GstALawEncClass ++ ++GST_ALAW_ENC ++GST_IS_ALAW_ENC ++GST_TYPE_ALAW_ENC ++gst_alaw_enc_get_type ++GST_ALAW_ENC_CLASS ++GST_IS_ALAW_ENC_CLASS ++
++ ++
++mulaw-decode ++GstMuLawDec ++GstMuLawDec ++GstMuLawDecClass ++ ++GST_MULAWDEC ++GST_IS_MULAWDEC ++GST_TYPE_MULAWDEC ++gst_mulawdec_get_type ++GST_MULAWDEC_CLASS ++GST_IS_MULAWDEC_CLASS ++
++ ++
++mulaw-encode ++GstMuLawEnc ++GstMuLawEnc ++GstMuLawEncClass ++ ++GST_MULAWENC ++GST_IS_MULAWENC ++GST_TYPE_MULAWENC ++gst_mulawenc_get_type ++GST_MULAWENC_CLASS ++GST_IS_MULAWENC_CLASS ++
++ ++
++gsticydemux ++GstICYDemux ++GstICYDemux ++GstICYDemuxClass ++ ++GST_ICYDEMUX ++GST_IS_ICYDEMUX ++GST_TYPE_ICYDEMUX ++gst_icydemux_get_type ++GST_ICYDEMUX_CLASS ++GST_IS_ICYDEMUX_CLASS ++
++ ++
++gstid3demux ++GstID3Demux ++GstID3Demux ++GstID3DemuxClass ++ ++GST_ID3DEMUX ++GST_IS_ID3DEMUX ++GST_TYPE_ID3DEMUX ++gst_id3demux_get_type ++GST_ID3DEMUX_CLASS ++GST_IS_ID3DEMUX_CLASS ++
++ ++
++gstimagefreeze ++GstImageFreeze ++GstImageFreeze ++GstImageFreezeClass ++ ++GST_IMAGE_FREEZE ++GST_IS_IMAGE_FREEZE ++GST_TYPE_IMAGE_FREEZE ++gst_image_freeze_get_type ++GST_IMAGE_FREEZE_CLASS ++GST_IS_IMAGE_FREEZE_CLASS ++GST_IMAGE_FREEZE_GET_CLASS ++
++ ++
++deinterleave ++GstDeinterleave ++GstDeinterleave ++GstDeinterleaveClass ++GstDeinterleaveFunc ++ ++GST_DEINTERLEAVE ++GST_IS_DEINTERLEAVE ++GST_TYPE_DEINTERLEAVE ++gst_deinterleave_get_type ++GST_DEINTERLEAVE_CLASS ++GST_IS_DEINTERLEAVE_CLASS ++GST_DEINTERLEAVE_GET_CLASS ++
++ ++
++interleave ++GstInterleave ++GstInterleave ++GstInterleaveClass ++GstInterleaveFunc ++ ++GST_INTERLEAVE ++GST_IS_INTERLEAVE ++GST_TYPE_INTERLEAVE ++gst_interleave_get_type ++GST_INTERLEAVE_CLASS ++GST_IS_INTERLEAVE_CLASS ++GST_INTERLEAVE_GET_CLASS ++
++ ++
++gstlevel ++GstLevel ++GstLevel ++GstLevelClass ++ ++GST_LEVEL ++GST_IS_LEVEL ++GST_TYPE_LEVEL ++gst_level_get_type ++GST_LEVEL_CLASS ++GST_IS_LEVEL_CLASS ++GST_LEVEL_GET_CLASS ++
++ ++
++matroska-demux ++GstMatroskaDemux ++GstMatroskaDemuxState ++GstMatroskaDemux ++GstMatroskaDemuxClass ++gst_matroska_demux_plugin_init ++ ++GST_MATROSKA_DEMUX ++GST_IS_MATROSKA_DEMUX ++GST_TYPE_MATROSKA_DEMUX ++GST_MATROSKA_DEMUX_CLASS ++GST_IS_MATROSKA_DEMUX_CLASS ++
++ ++
++matroska-mux ++GstMatroskaMux ++GstMatroskaMuxState ++GstMatroskaMetaSeekIndex ++GstMatroskaMux ++GstMatroskaMuxClass ++ ++GST_MATROSKA_MUX ++GST_IS_MATROSKA_MUX ++GST_TYPE_MATROSKA_MUX ++gst_matroska_mux_get_type ++GST_MATROSKA_MUX_CLASS ++GST_IS_MATROSKA_MUX_CLASS ++
++ ++
++webm-mux ++GstWebMMux ++GstWebMMux ++GstWebMMuxClass ++ ++GST_WEBM_MUX ++GST_IS_WEBM_MUX ++GST_TYPE_WEBM_MUX ++gst_webm_mux_get_type ++GST_WEBM_MUX_CLASS ++GST_IS_WEBM_MUX_CLASS ++
++ ++
++gstmonoscope ++GstMonoscope ++GstMonoscope ++GstMonoscopeClass ++ ++GST_MONOSCOPE ++GST_IS_MONOSCOPE ++GST_TYPE_MONOSCOPE ++gst_monoscope_get_type ++GST_MONOSCOPE_CLASS ++GST_IS_MONOSCOPE_CLASS ++
++ ++
++gstmultifilesink ++GstMultiFileSink ++GstMultiFileSink ++GstMultiFileSinkClass ++GstMultiFileSinkNext ++ ++GST_MULTI_FILE_SINK ++GST_IS_MULTI_FILE_SINK ++GST_TYPE_MULTI_FILE_SINK ++gst_multi_file_sink_get_type ++GST_MULTI_FILE_SINK_CLASS ++GST_IS_MULTI_FILE_SINK_CLASS ++
++ ++
++gstmultifilesrc ++GstMultiFileSrc ++GstMultiFileSrc ++GstMultiFileSrcClass ++ ++GST_MULTI_FILE_SRC ++GST_IS_MULTI_FILE_SRC ++GST_TYPE_MULTI_FILE_SRC ++gst_multi_file_src_get_type ++GST_MULTI_FILE_SRC_CLASS ++GST_IS_MULTI_FILE_SRC_CLASS ++
++ ++
++multipartdemux ++GstMultipartDemux ++GstMultipartDemux ++GstMultipartDemuxClass ++MULTIPART_NEED_MORE_DATA ++MULTIPART_DATA_ERROR ++MULTIPART_DATA_EOS ++gst_multipart_demux_plugin_init ++ ++GST_MULTIPART_DEMUX ++GST_IS_MULTIPART_DEMUX ++GST_TYPE_MULTIPART_DEMUX ++gst_multipart_demux_get_type ++GST_MULTIPART_DEMUX_CLASS ++GST_IS_MULTIPART_DEMUX_CLASS ++GST_MULTIPART_DEMUX_GET_CLASS ++
++ ++
++multipartmux ++GstMultipartMux ++GstMultipartMux ++GstMultipartMuxClass ++gst_multipart_mux_plugin_init ++ ++GST_MULTIPART_MUX ++GST_IS_MULTIPART_MUX ++GST_TYPE_MULTIPART_MUX ++gst_multipart_mux_get_type ++GST_MULTIPART_MUX_CLASS ++GST_IS_MULTIPART_MUX_CLASS ++GST_MULTIPART_MUX_GET_CLASS ++
++ ++
++qtdemux ++GstQTDemux ++GST_CAT_DEFAULT ++GST_QTDEMUX_CAST ++GST_QT_DEMUX_PRIVATE_TAG ++GST_QT_DEMUX_CLASSIFICATION_TAG ++GST_QTDEMUX_MAX_STREAMS ++GstQTDemux ++GstQTDemuxClass ++QtDemuxStream ++ ++GST_QTDEMUX ++GST_IS_QTDEMUX ++GST_TYPE_QTDEMUX ++gst_qtdemux_get_type ++GST_QTDEMUX_CLASS ++GST_IS_QTDEMUX_CLASS ++
++ ++
++gstrganalysis ++GstRgAnalysis ++GstRgAnalysis ++GstRgAnalysisClass ++ ++GST_RG_ANALYSIS ++GST_IS_RG_ANALYSIS ++GST_TYPE_RG_ANALYSIS ++gst_rg_analysis_get_type ++GST_RG_ANALYSIS_CLASS ++GST_IS_RG_ANALYSIS_CLASS ++
++ ++
++gstrglimiter ++GstRgLimiter ++GstRgLimiter ++GstRgLimiterClass ++ ++GST_RG_LIMITER ++GST_IS_RG_LIMITER ++GST_TYPE_RG_LIMITER ++gst_rg_limiter_get_type ++GST_RG_LIMITER_CLASS ++GST_IS_RG_LIMITER_CLASS ++
++ ++
++gstrgvolume ++GstRgVolume ++GstRgVolume ++GstRgVolumeClass ++ ++GST_RG_VOLUME ++GST_IS_RG_VOLUME ++GST_TYPE_RG_VOLUME ++gst_rg_volume_get_type ++GST_RG_VOLUME_CLASS ++GST_IS_RG_VOLUME_CLASS ++
++ ++
++gstrtpj2kpay ++GstRtpJ2KPay ++GstRtpJ2KPay ++GstRtpJ2KPayClass ++gst_rtp_j2k_pay_plugin_init ++ ++GST_RTP_J2K_PAY ++GST_IS_RTP_J2K_PAY ++GST_TYPE_RTP_J2K_PAY ++gst_rtp_j2k_pay_get_type ++GST_RTP_J2K_PAY_CLASS ++GST_IS_RTP_J2K_PAY_CLASS ++
++ ++
++gstrtpjpegpay ++GstRtpJPEGPay ++GstRtpJPEGPay ++GstRtpJPEGPayClass ++gst_rtp_jpeg_pay_plugin_init ++ ++GST_RTP_JPEG_PAY ++GST_IS_RTP_JPEG_PAY ++GST_TYPE_RTP_JPEG_PAY ++gst_rtp_jpeg_pay_get_type ++GST_RTP_JPEG_PAY_CLASS ++GST_IS_RTP_JPEG_PAY_CLASS ++
++ ++
++gstrtpbin ++GstRtpBin ++GstRtpBin ++GstRtpBinClass ++GstRtpBinPrivate ++ ++GST_RTP_BIN ++GST_IS_RTP_BIN ++GST_TYPE_RTP_BIN ++gst_rtp_bin_get_type ++GST_RTP_BIN_CLASS ++GST_IS_RTP_BIN_CLASS ++
++ ++
++gstrtpjitterbuffer ++GstRtpJitterBuffer ++GstRtpJitterBuffer ++GstRtpJitterBufferClass ++GstRtpJitterBufferPrivate ++ ++GST_RTP_JITTER_BUFFER ++GST_IS_RTP_JITTER_BUFFER ++GST_TYPE_RTP_JITTER_BUFFER ++gst_rtp_jitter_buffer_get_type ++GST_RTP_JITTER_BUFFER_CLASS ++GST_IS_RTP_JITTER_BUFFER_CLASS ++
++ ++
++gstrtpptdemux ++GstRtpPtDemux ++GstRtpPtDemux ++GstRtpPtDemuxClass ++GstRtpPtDemuxPad ++ ++GST_RTP_PT_DEMUX ++GST_IS_RTP_PT_DEMUX ++GST_TYPE_RTP_PT_DEMUX ++gst_rtp_pt_demux_get_type ++GST_RTP_PT_DEMUX_CLASS ++GST_IS_RTP_PT_DEMUX_CLASS ++
++ ++
++gstrtpsession ++GstRtpSession ++GST_RTP_SESSION_CAST ++GstRtpSession ++GstRtpSessionClass ++GstRtpSessionPrivate ++ ++GST_RTP_SESSION ++GST_IS_RTP_SESSION ++GST_TYPE_RTP_SESSION ++gst_rtp_session_get_type ++GST_RTP_SESSION_CLASS ++GST_IS_RTP_SESSION_CLASS ++
++ ++
++gstrtpssrcdemux ++GstRtpSsrcDemux ++GstRtpSsrcDemux ++GstRtpSsrcDemuxClass ++GstRtpSsrcDemuxPad ++ ++GST_RTP_SSRC_DEMUX ++GST_IS_RTP_SSRC_DEMUX ++GST_TYPE_RTP_SSRC_DEMUX ++gst_rtp_ssrc_demux_get_type ++GST_RTP_SSRC_DEMUX_CLASS ++GST_IS_RTP_SSRC_DEMUX_CLASS ++
++ ++
++gstrtpdec ++GstRTPDec ++GST_RTP_DEC_CLASS ++GstRTPDec ++GstRTPDecClass ++GstRTPDecSession ++ ++GST_RTP_DEC ++GST_IS_RTP_DEC ++GST_TYPE_RTP_DEC ++gst_rtp_dec_get_type ++GST_IS_RTP_DEC_CLASS ++
++ ++
++gstrtspsrc ++GstRTSPSrc ++GST_RTSPSRC_CAST ++GstRTSPSrc ++GstRTSPSrcClass ++GST_RTSP_STATE_GET_LOCK ++GST_RTSP_STATE_LOCK ++GST_RTSP_STATE_UNLOCK ++GST_RTSP_STREAM_GET_LOCK ++GST_RTSP_STREAM_LOCK ++GST_RTSP_STREAM_UNLOCK ++GST_RTSP_CONN_GET_LOCK ++GST_RTSP_CONN_LOCK ++GST_RTSP_CONN_UNLOCK ++GstRTSPConnInfo ++GstRTSPStream ++GstRTSPNatMethod ++ ++GST_RTSPSRC ++GST_IS_RTSPSRC ++GST_TYPE_RTSPSRC ++gst_rtspsrc_get_type ++GST_RTSPSRC_CLASS ++GST_IS_RTSPSRC_CLASS ++
++ ++
++gstshapewipe ++GstShapeWipe ++GstShapeWipe ++GstShapeWipeClass ++ ++GST_SHAPE_WIPE ++GST_IS_SHAPE_WIPE ++GST_TYPE_SHAPE_WIPE ++gst_shape_wipe_get_type ++GST_SHAPE_WIPE_CLASS ++GST_IS_SHAPE_WIPE_CLASS ++GST_SHAPE_WIPE_GET_CLASS ++
++ ++
++gstsmpte ++GstSMPTE ++GstSMPTE ++GstSMPTEClass ++gst_smpte_plugin_init ++ ++GST_SMPTE ++GST_IS_SMPTE ++GST_TYPE_SMPTE ++GST_SMPTE_CLASS ++GST_IS_SMPTE_CLASS ++
++ ++
++gstsmptealpha ++GstSMPTEAlpha ++GstSMPTEAlpha ++GstSMPTEAlphaClass ++gst_smpte_alpha_plugin_init ++ ++GST_SMPTE_ALPHA ++GST_IS_SMPTE_ALPHA ++GST_TYPE_SMPTE_ALPHA ++gst_smpte_alpha_get_type ++GST_SMPTE_ALPHA_CLASS ++GST_IS_SMPTE_ALPHA_CLASS ++
++ ++
++gstspectrum ++GstSpectrum ++GstSpectrum ++GstSpectrumClass ++ ++GST_SPECTRUM ++GST_IS_SPECTRUM ++GST_TYPE_SPECTRUM ++gst_spectrum_get_type ++GST_SPECTRUM_CLASS ++GST_IS_SPECTRUM_CLASS ++
++ ++
++gstmultiudpsink ++GstMultiUDPSink ++GstMultiUDPSink ++GstMultiUDPSinkClass ++GstUDPClient ++gst_multiudpsink_add ++gst_multiudpsink_remove ++gst_multiudpsink_clear ++gst_multiudpsink_get_stats ++ ++GST_MULTIUDPSINK ++GST_IS_MULTIUDPSINK ++GST_TYPE_MULTIUDPSINK ++gst_multiudpsink_get_type ++GST_MULTIUDPSINK_CLASS ++GST_IS_MULTIUDPSINK_CLASS ++
++ ++
++gstudpsrc ++GstUDPSrc ++GST_UDPSRC_CAST ++GstUDPSrc ++GstUDPSrcClass ++ ++GST_UDPSRC ++GST_IS_UDPSRC ++GST_TYPE_UDPSRC ++gst_udpsrc_get_type ++GST_UDPSRC_CLASS ++GST_IS_UDPSRC_CLASS ++
++ ++
++gstudpsink ++GstUDPSink ++GstUDPSink ++GstUDPSinkClass ++ ++GST_UDPSINK ++GST_IS_UDPSINK ++GST_TYPE_UDPSINK ++gst_udpsink_get_type ++GST_UDPSINK_CLASS ++GST_IS_UDPSINK_CLASS ++
++ ++
++gstvideobox ++GstVideoBox ++GstVideoBox ++GstVideoBoxClass ++GstVideoBoxFill ++ ++GST_VIDEO_BOX ++GST_IS_VIDEO_BOX ++GST_TYPE_VIDEO_BOX ++gst_video_box_get_type ++GST_VIDEO_BOX_CLASS ++GST_IS_VIDEO_BOX_CLASS ++
++ ++
++gstvideocrop ++GstVideoCrop ++VideoCropPixelFormat ++GstVideoCropImageDetails ++GstVideoCrop ++GstVideoCropClass ++ ++GST_VIDEO_CROP ++GST_IS_VIDEO_CROP ++GST_TYPE_VIDEO_CROP ++gst_video_crop_get_type ++GST_VIDEO_CROP_CLASS ++GST_IS_VIDEO_CROP_CLASS ++
++ ++
++gstaspectratiocrop ++GstAspectRatioCrop ++GstAspectRatioCrop ++GstAspectRatioCropClass ++ ++GST_ASPECT_RATIO_CROP ++GST_IS_ASPECT_RATIO_CROP ++GST_TYPE_ASPECT_RATIO_CROP ++gst_aspect_ratio_crop_get_type ++GST_ASPECT_RATIO_CROP_CLASS ++GST_IS_ASPECT_RATIO_CROP_CLASS ++
++ ++
++gstgamma ++GstGamma ++GstGamma ++GstGammaClass ++ ++GST_GAMMA ++GST_IS_GAMMA ++GST_TYPE_GAMMA ++gst_gamma_get_type ++GST_GAMMA_CLASS ++GST_IS_GAMMA_CLASS ++
++ ++
++gstvideobalance ++GstVideoBalance ++GstVideoBalance ++GstVideoBalanceClass ++ ++GST_VIDEO_BALANCE ++GST_IS_VIDEO_BALANCE ++GST_TYPE_VIDEO_BALANCE ++gst_video_balance_get_type ++GST_VIDEO_BALANCE_CLASS ++GST_IS_VIDEO_BALANCE_CLASS ++
++ ++
++gstvideoflip ++GstVideoFlip ++GstVideoFlipMethod ++GstVideoFlip ++GstVideoFlipClass ++ ++GST_VIDEO_FLIP ++GST_IS_VIDEO_FLIP ++GST_TYPE_VIDEO_FLIP ++gst_video_flip_get_type ++GST_VIDEO_FLIP_CLASS ++GST_IS_VIDEO_FLIP_CLASS ++
++ ++
++videomixer ++GstVideoMixer ++GstVideoMixer ++GstVideoMixerClass ++GstVideoMixerBackground ++ ++GST_VIDEO_MIXER ++GST_IS_VIDEO_MIXER ++GST_TYPE_VIDEO_MIXER ++gst_video_mixer_get_type ++GST_VIDEO_MIXER_CLASS ++GST_IS_VIDEO_MIXER_CLASS ++
++ ++
++videomixerpad ++GstVideoMixerPad ++GstVideoMixerPad ++GstVideoMixerPadClass ++GstVideoMixerCollect ++ ++GST_VIDEO_MIXER_PAD ++GST_IS_VIDEO_MIXER_PAD ++GST_TYPE_VIDEO_MIXER_PAD ++GST_VIDEO_MIXER_PAD_CLASS ++GST_IS_VIDEO_MIXER_PAD_CLASS ++
++ ++
++gstwavenc ++GstWavEnc ++GstWavEnc ++GstWavEncClass ++ ++GST_WAVENC ++GST_IS_WAVENC ++GST_TYPE_WAVENC ++gst_wavenc_get_type ++GST_WAVENC_CLASS ++GST_IS_WAVENC_CLASS ++
++ ++
++gstwavparse ++GstWavParse ++GstWavParseState ++GstWavParse ++GstWavParseClass ++ ++GST_WAVPARSE ++GST_IS_WAVPARSE ++GST_TYPE_WAVPARSE ++gst_wavparse_get_type ++GST_WAVPARSE_CLASS ++GST_IS_WAVPARSE_CLASS ++
++ ++
++gsty4mencode ++GstY4mEncode ++GstY4mEncode ++GstY4mEncodeClass ++ ++GST_Y4M_ENCODE ++GST_IS_Y4M_ENCODE ++GST_TYPE_Y4M_ENCODE ++gst_y4m_encode_get_type ++GST_Y4M_ENCODE_CLASS ++GST_IS_Y4M_ENCODE_CLASS ++GST_Y4M_ENCODE_GET_CLASS ++
++ ++
++gstdirectsoundsink ++GstDirectSoundSink ++GstDirectSoundSink ++GstDirectSoundSinkClass ++GST_DSOUND_LOCK ++GST_DSOUND_UNLOCK ++ ++GST_DIRECTSOUND_SINK ++GST_IS_DIRECTSOUND_SINK ++GST_TYPE_DIRECTSOUND_SINK ++gst_directsound_sink_get_type ++GST_DIRECTSOUND_SINK_CLASS ++GST_IS_DIRECTSOUND_SINK_CLASS ++
++ ++
++oss4-mixer ++GstOss4Mixer ++GST_OSS4_MIXER_CAST ++GST_OSS4_MIXER_IS_OPEN ++GstOss4Mixer ++GstOss4MixerClass ++GstOss4MixerControl ++MIXEXT_IS_ROOT ++MIXEXT_IS_SLIDER ++MIXEXT_HAS_DESCRIPTION ++MIXEXT_ENUM_IS_AVAILABLE ++gst_oss4_mixer_get_control_val ++gst_oss4_mixer_set_control_val ++ ++GST_OSS4_MIXER ++GST_IS_OSS4_MIXER ++GST_TYPE_OSS4_MIXER ++gst_oss4_mixer_get_type ++GST_OSS4_MIXER_CLASS ++GST_IS_OSS4_MIXER_CLASS ++
++ ++
++oss4-sink ++GstOss4Sink ++GST_OSS4_SINK_CAST ++GstOss4Sink ++GstOss4SinkClass ++ ++GST_OSS4_SINK ++GST_IS_OSS4_SINK ++GST_TYPE_OSS4_SINK ++gst_oss4_sink_get_type ++GST_OSS4_SINK_CLASS ++GST_IS_OSS4_SINK_CLASS ++
++ ++
++oss4-source ++GstOss4SourceInput ++GstOss4Source ++GST_OSS4_SOURCE_CAST ++GstOss4Source ++GstOss4SourceClass ++GST_TYPE_OSS4_SOURCE_INPUT ++GST_OSS4_SOURCE_INPUT ++GST_OSS4_SOURCE_INPUT_CLASS ++GST_IS_OSS4_SOURCE_INPUT ++GST_IS_OSS4_SOURCE_INPUT_CLASS ++GstOss4SourceInput ++GstOss4SourceInputClass ++gst_oss4_source_input_get_type ++ ++GST_OSS4_SOURCE ++GST_IS_OSS4_SOURCE ++GST_TYPE_OSS4_SOURCE ++gst_oss4_source_get_type ++GST_OSS4_SOURCE_CLASS ++GST_IS_OSS4_SOURCE_CLASS ++
++ ++
++gstossmixerelement ++GstOssMixerElement ++GstOssMixerElement ++GstOssMixerElementClass ++ ++GST_OSS_MIXER_ELEMENT ++GST_IS_OSS_MIXER_ELEMENT ++GST_TYPE_OSS_MIXER_ELEMENT ++gst_oss_mixer_element_get_type ++GST_OSS_MIXER_ELEMENT_CLASS ++GST_IS_OSS_MIXER_ELEMENT_CLASS ++
++ ++
++gstosssink ++GstOssSink ++GstOssSink ++GstOssSinkClass ++ ++GST_OSSSINK ++GST_IS_OSSSINK ++GST_TYPE_OSSSINK ++gst_oss_sink_get_type ++GST_OSSSINK_CLASS ++GST_IS_OSSSINK_CLASS ++
++ ++
++gstosssrc ++GstOssSrc ++GstOssSrc ++GstOssSrcClass ++ ++GST_OSS_SRC ++GST_IS_OSS_SRC ++GST_TYPE_OSS_SRC ++gst_oss_src_get_type ++GST_OSS_SRC_CLASS ++GST_IS_OSS_SRC_CLASS ++
++ ++
++osxvideosink ++GstOSXVideoSink ++GST_CAT_DEFAULT ++GstOSXWindow ++GstOSXVideoSink ++GstOSXVideoSinkClass ++GST_TYPE_OSXVIDEOBUFFER ++ ++GST_OSX_VIDEO_SINK ++GST_IS_OSX_VIDEO_SINK ++GST_TYPE_OSX_VIDEO_SINK ++gst_osx_video_sink_get_type ++GST_OSX_VIDEO_SINK_CLASS ++GST_IS_OSX_VIDEO_SINK_CLASS ++
++ ++
++gstv4l2src ++GstV4l2Src ++GstV4l2Src ++GstV4l2SrcClass ++GstV4l2SrcGetFunc ++ ++GST_V4L2SRC ++GST_IS_V4L2SRC ++GST_TYPE_V4L2SRC ++gst_v4l2src_get_type ++GST_V4L2SRC_CLASS ++GST_IS_V4L2SRC_CLASS ++
++ ++
++gstv4l2sink ++GstV4l2Sink ++GstV4l2Sink ++GstV4l2SinkClass ++ ++GST_V4L2SINK ++GST_IS_V4L2SINK ++GST_TYPE_V4L2SINK ++gst_v4l2sink_get_type ++GST_V4L2SINK_CLASS ++GST_IS_V4L2SINK_CLASS ++
++ ++
++gstwaveformsink ++GstWaveFormSink ++WAVE_FORMAT_96M08 ++WAVE_FORMAT_96S08 ++WAVE_FORMAT_96M16 ++WAVE_FORMAT_96S16 ++ERROR_LENGTH ++BUFFER_COUNT ++BUFFER_SIZE ++GstWaveFormSink ++GstWaveFormSinkClass ++ ++GST_WAVEFORM_SINK ++GST_IS_WAVEFORM_SINK ++GST_TYPE_WAVEFORM_SINK ++gst_waveform_sink_get_type ++GST_WAVEFORM_SINK_CLASS ++GST_IS_WAVEFORM_SINK_CLASS ++
++ ++
++gstximagesrc ++GstXImageSrc ++GstXImageSrc ++GstXImageSrcClass ++ ++GST_XIMAGE_SRC ++GST_IS_XIMAGE_SRC ++GST_TYPE_XIMAGE_SRC ++gst_ximage_src_get_type ++GST_XIMAGE_SRC_CLASS ++GST_IS_XIMAGE_SRC_CLASS ++
++ ++
++gstcairorender ++GstCairoRender ++GST_TYPE_CAIRO_RENDER ++GST_CAIRO_RENDER ++GST_CAIRO_RENDER_CLASS ++GstCairoRender ++GstCairoRenderClass ++gst_cairo_render_get_type ++
++ ++
++gstosxaudiosrc ++GstOsxAudioSrc ++GST_TYPE_OSX_AUDIO_SRC ++GST_OSX_AUDIO_SRC ++GST_OSX_AUDIO_SRC_CLASS ++GstOsxAudioSrc ++GstOsxAudioSrcClass ++gst_osx_audio_src_get_type ++
++ ++
++gstosxaudiosink ++GstOsxAudioSink ++GST_TYPE_OSX_AUDIO_SINK ++GST_OSX_AUDIO_SINK ++GST_OSX_AUDIO_SINK_CLASS ++GstOsxAudioSink ++GstOsxAudioSinkClass ++gst_osx_audio_sink_get_type ++
++ +--- gst-plugins-good0.10-0.10.25.orig/docs/plugins/gst-plugins-good-plugins.interfaces ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins.interfaces +@@ -6,48 +6,46 @@ GstGConfAudioSink GstChildProxy + GstSwitchSrc GstChildProxy + GstGConfVideoSrc GstChildProxy + GstGConfAudioSrc GstChildProxy +-GstHalAudioSink GstChildProxy +-GstHalAudioSrc GstChildProxy ++GstRTSPSrc GstChildProxy GstURIHandler + GstRtpBin GstChildProxy + GstAutoVideoSink GstChildProxy + GstAutoVideoSrc GstChildProxy + GstAutoAudioSink GstChildProxy + GstAutoAudioSrc GstChildProxy + GstPushFileSrc GstChildProxy GstURIHandler +-GstRTSPSrc GstChildProxy GstURIHandler + GstRgVolume GstChildProxy + GstAspectRatioCrop GstChildProxy +-GstPulseSink GstStreamVolume GstImplementsInterface GstPropertyProbe + GstOss4Sink GstStreamVolume GstPropertyProbe +-GstV4l2Sink GstImplementsInterface GstColorBalance GstVideoOrientation GstPropertyProbe ++GstPulseSink GstStreamVolume GstImplementsInterface GstPropertyProbe + GstShout2send GstTagSetter ++GstV4l2Sink GstImplementsInterface GstColorBalance GstVideoOrientation GstPropertyProbe + GstUDPSink GstURIHandler + GstDV1394Src GstURIHandler GstPropertyProbe + GstHDV1394Src GstURIHandler GstPropertyProbe +-GstSoupHTTPSrc GstURIHandler + GstPulseSrc GstImplementsInterface GstMixer GstPropertyProbe + GstOssSrc GstImplementsInterface GstMixer + GstOss4Source GstImplementsInterface GstMixer GstPropertyProbe ++GstSoupHTTPSrc GstURIHandler + GstV4l2Src GstURIHandler GstImplementsInterface GstTuner GstColorBalance GstVideoOrientation GstPropertyProbe + GstUDPSrc GstURIHandler +-GstWavpackEnc GstPreset + GstTagLibMux GstTagSetter + GstId3v2Mux GstTagSetter + GstApev2Mux GstTagSetter ++GstPulseMixer GstImplementsInterface GstMixer GstPropertyProbe + GstFlacEnc GstTagSetter GstPreset + GstFlacTag GstTagSetter +-GstVideoBalance GstImplementsInterface GstColorBalance ++GstSpeexEnc GstTagSetter GstPreset ++GstWavpackEnc GstPreset + GstIirEqualizer GstChildProxy + GstIirEqualizerNBands GstChildProxy + GstIirEqualizer3Bands GstChildProxy GstPreset + GstIirEqualizer10Bands GstChildProxy GstPreset +-GstPulseMixer GstImplementsInterface GstMixer GstPropertyProbe +-GstSpeexEnc GstTagSetter GstPreset ++GstVideoBalance GstImplementsInterface GstColorBalance + GstOssMixerElement GstImplementsInterface GstMixer + GstOss4Mixer GstImplementsInterface GstMixer GstPropertyProbe + GstAviMux GstTagSetter + GstMatroskaMux GstTagSetter + GstWebMMux GstTagSetter + GstDeinterlace GstChildProxy +-GstFlvMux GstTagSetter + GstVideoMixer GstChildProxy ++GstFlvMux GstTagSetter +--- gst-plugins-good0.10-0.10.25.orig/docs/plugins/gst-plugins-good-plugins.hierarchy ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins.hierarchy +@@ -177,8 +177,6 @@ GObject + GstAutoAudioSrc + GstAutoVideoSink + GstAutoVideoSrc +- GstHalAudioSink +- GstHalAudioSrc + GstPipeline + GstPushFileSrc + GstRTSPSrc +@@ -218,6 +216,7 @@ GObject + GstMatroskaDemux + GstMatroskaMux + GstWebMMux ++ GstMonoscope + GstMuLawDec + GstMuLawEnc + GstMultipartDemux +--- /dev/null ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins.signals.new +@@ -0,0 +1,499 @@ ++ ++GstMultiUDPSink::add ++void ++l ++GstMultiUDPSink *gstmultiudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstMultiUDPSink::clear ++void ++l ++GstMultiUDPSink *gstmultiudpsink ++ ++ ++ ++GstMultiUDPSink::client-added ++void ++l ++GstMultiUDPSink *gstmultiudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstMultiUDPSink::client-removed ++void ++l ++GstMultiUDPSink *gstmultiudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstMultiUDPSink::get-stats ++GValueArray* ++l ++GstMultiUDPSink *gstmultiudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstMultiUDPSink::remove ++void ++l ++GstMultiUDPSink *gstmultiudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstDynUDPSink::get-stats ++GValueArray* ++l ++GstDynUDPSink *gstdynudpsink ++gchar *arg1 ++gint arg2 ++ ++ ++ ++GstRtpSsrcDemux::clear-ssrc ++void ++la ++GstRtpSsrcDemux *gstrtpssrcdemux ++guint arg1 ++ ++ ++ ++GstRtpSsrcDemux::new-ssrc-pad ++void ++l ++GstRtpSsrcDemux *gstrtpssrcdemux ++guint arg1 ++GstPad *arg2 ++ ++ ++ ++GstRtpSsrcDemux::removed-ssrc-pad ++void ++l ++GstRtpSsrcDemux *gstrtpssrcdemux ++guint arg1 ++GstPad *arg2 ++ ++ ++ ++GstRtpSession::clear-pt-map ++void ++a ++GstRtpSession *gstrtpsession ++ ++ ++ ++GstRtpSession::on-bye-ssrc ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-bye-timeout ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-new-ssrc ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-sender-timeout ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-ssrc-active ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-ssrc-collision ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-ssrc-sdes ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-ssrc-validated ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::on-timeout ++void ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpSession::request-pt-map ++GstCaps* ++l ++GstRtpSession *gstrtpsession ++guint arg1 ++ ++ ++ ++GstRtpPtDemux::clear-pt-map ++void ++la ++GstRtpPtDemux *gstrtpptdemux ++ ++ ++ ++GstRtpPtDemux::new-payload-type ++void ++l ++GstRtpPtDemux *gstrtpptdemux ++guint arg1 ++GstPad *arg2 ++ ++ ++ ++GstRtpPtDemux::payload-type-change ++void ++l ++GstRtpPtDemux *gstrtpptdemux ++guint arg1 ++ ++ ++ ++GstRtpPtDemux::request-pt-map ++GstCaps* ++l ++GstRtpPtDemux *gstrtpptdemux ++guint arg1 ++ ++ ++ ++GstRtpJitterBuffer::clear-pt-map ++void ++la ++GstRtpJitterBuffer *gstrtpjitterbuffer ++ ++ ++ ++GstRtpJitterBuffer::handle-sync ++void ++l ++GstRtpJitterBuffer *gstrtpjitterbuffer ++GstStructure *arg1 ++ ++ ++ ++GstRtpJitterBuffer::on-npt-stop ++void ++l ++GstRtpJitterBuffer *gstrtpjitterbuffer ++ ++ ++ ++GstRtpJitterBuffer::request-pt-map ++GstCaps* ++l ++GstRtpJitterBuffer *gstrtpjitterbuffer ++guint arg1 ++ ++ ++ ++GstRtpJitterBuffer::set-active ++guint64 ++la ++GstRtpJitterBuffer *gstrtpjitterbuffer ++gboolean arg1 ++guint64 arg2 ++ ++ ++ ++GstRtpBin::clear-pt-map ++void ++la ++GstRtpBin *gstrtpbin ++ ++ ++ ++GstRtpBin::get-internal-session ++RTPSession* ++la ++GstRtpBin *gstrtpbin ++guint arg1 ++ ++ ++ ++GstRtpBin::on-bye-ssrc ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-bye-timeout ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-new-ssrc ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-npt-stop ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-sender-timeout ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-ssrc-active ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-ssrc-collision ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-ssrc-sdes ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-ssrc-validated ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::on-timeout ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::payload-type-change ++void ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::request-pt-map ++GstCaps* ++l ++GstRtpBin *gstrtpbin ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRtpBin::reset-sync ++void ++la ++GstRtpBin *gstrtpbin ++ ++ ++ ++GstRTPDec::clear-pt-map ++void ++l ++GstRTPDec *gstrtpdec ++ ++ ++ ++GstRTPDec::on-bye-ssrc ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::on-bye-timeout ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::on-new-ssrc ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::on-ssrc-collision ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::on-ssrc-validated ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::on-timeout ++void ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstRTPDec::request-pt-map ++GstCaps* ++l ++GstRTPDec *gstrtpdec ++guint arg1 ++guint arg2 ++ ++ ++ ++GstAudioIIRFilter::rate-changed ++void ++l ++GstAudioIIRFilter *gstaudioiirfilter ++gint arg1 ++ ++ ++ ++GstAudioFIRFilter::rate-changed ++void ++l ++GstAudioFIRFilter *gstaudiofirfilter ++gint arg1 ++ ++ ++ ++GstShout2send::connection-problem ++void ++c ++GstShout2send *gstshout2send ++gint arg1 ++ ++ ++ ++GstAASink::frame-displayed ++void ++l ++GstAASink *gstaasink ++ ++ ++ ++GstAASink::have-size ++void ++l ++GstAASink *gstaasink ++guint arg1 ++guint arg2 ++ ++ ++ ++GstJpegEnc::frame-encoded ++void ++l ++GstJpegEnc *gstjpegenc ++ ++ ++ ++GstDV1394Src::frame-dropped ++void ++l ++GstDV1394Src *gstdv1394src ++ ++ +--- /dev/null ++++ gst-plugins-good0.10-0.10.25/docs/plugins/gst-plugins-good-plugins-decl.txt +@@ -0,0 +1,11144 @@ ++ ++GST_TYPE_AASINK ++#define GST_TYPE_AASINK \ ++ (gst_aasink_get_type()) ++ ++ ++GST_AASINK ++#define GST_AASINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AASINK,GstAASink)) ++ ++ ++GST_AASINK_CLASS ++#define GST_AASINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AASINK,GstAASinkClass)) ++ ++ ++GST_IS_AASINK ++#define GST_IS_AASINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AASINK)) ++ ++ ++GST_IS_AASINK_CLASS ++#define GST_IS_AASINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AASINK)) ++ ++ ++GstAASink ++ ++ ++GstAASinkClass ++ ++ ++GstAASink ++struct _GstAASink { ++ GstBaseSink parent; ++ ++ gulong format; ++ gint width, height; ++ ++ gint frames_displayed; ++ guint64 frame_time; ++ ++ aa_context *context; ++ struct aa_hardware_params ascii_surf; ++ struct aa_renderparams ascii_parms; ++ aa_palette palette; ++ gint aa_driver; ++}; ++ ++ ++GstAASinkClass ++struct _GstAASinkClass { ++ GstBaseSinkClass parent_class; ++ ++ /* signals */ ++ void (*frame_displayed) (GstElement *element); ++ void (*have_size) (GstElement *element, guint width, guint height); ++}; ++ ++ ++gst_aasink_get_type ++GType ++void ++ ++ ++GST_TYPE_CMML_DEC ++#define GST_TYPE_CMML_DEC (gst_cmml_dec_get_type()) ++ ++ ++GST_CMML_DEC ++#define GST_CMML_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_DEC, GstCmmlDec)) ++ ++ ++GST_CMML_DEC_CLASS ++#define GST_CMML_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_DEC, GstCmmlDecClass)) ++ ++ ++GST_IS_CMML_DEC ++#define GST_IS_CMML_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CMML_DEC)) ++ ++ ++GST_IS_CMML_DEC_CLASS ++#define GST_IS_CMML_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_CMML_DEC)) ++ ++ ++GST_CMML_DEC_GET_CLASS ++#define GST_CMML_DEC_GET_CLASS(klass) \ ++ (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_CMML_DEC, GstCmmlDecClass)) ++ ++ ++GstCmmlDec ++ ++ ++GstCmmlDecClass ++ ++ ++GstCmmlDec ++struct _GstCmmlDec ++{ ++ GstElement element; ++ ++ /* element part */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ /* bitstream part */ ++ gint16 major; /* bitstream version major */ ++ gint16 minor; /* bitstream version minor */ ++ gint64 granulerate_n; /* bitrstream granulerate numerator */ ++ gint64 granulerate_d; /* bitstream granulerate denominator */ ++ gint8 granuleshift; /* bitstreamgranuleshift */ ++ gint64 granulepos; /* bitstream granule position */ ++ GstClockTime timestamp; /* timestamp of the last buffer */ ++ ++ /* decoder part */ ++ GstCmmlParser *parser; /* cmml parser */ ++ gboolean sent_root; ++ GstFlowReturn flow_return; /* _chain return value */ ++ gboolean wait_clip_end; /* when TRUE, the GST_TAG_MESSAGE for a ++ * clip is sent when the next clip (or EOS) ++ * is found, so that the clip end-time is ++ * known. This is useful for pre-extracting ++ * the clips. ++ */ ++ GHashTable *tracks; ++}; ++ ++ ++GstCmmlDecClass ++struct _GstCmmlDecClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_cmml_dec_get_type ++GType ++void ++ ++ ++gst_cmml_dec_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_CMML_ENC ++#define GST_TYPE_CMML_ENC (gst_cmml_enc_get_type()) ++ ++ ++GST_CMML_ENC ++#define GST_CMML_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_ENC, GstCmmlEnc)) ++ ++ ++GST_CMML_ENC_CLASS ++#define GST_CMML_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_ENC, GstCmmlEncClass)) ++ ++ ++GST_IS_CMML_ENC ++#define GST_IS_CMML_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CMML_ENC)) ++ ++ ++GST_IS_CMML_ENC_CLASS ++#define GST_IS_CMML_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_CMML_ENC)) ++ ++ ++GST_CMML_ENC_GET_CLASS ++#define GST_CMML_ENC_GET_CLASS(obj) \ ++ (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_CMML_ENC, GstCmmlEncClass)) ++ ++ ++GstCmmlEnc ++ ++ ++GstCmmlEncClass ++ ++ ++GstCmmlEnc ++struct _GstCmmlEnc ++{ ++ GstElement element; ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ gint16 major; ++ gint16 minor; ++ gint64 granulerate_n; ++ gint64 granulerate_d; ++ gint8 granuleshift; ++ ++ GstCmmlParser *parser; ++ gboolean streaming; ++ GHashTable *tracks; ++ GstFlowReturn flow_return; ++ guchar *preamble; ++ gboolean sent_headers; ++ gboolean sent_eos; ++}; ++ ++ ++GstCmmlEncClass ++struct _GstCmmlEncClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_cmml_enc_get_type ++GType ++void ++ ++ ++gst_cmml_enc_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_CAIRO_TEXT_OVERLAY ++#define GST_TYPE_CAIRO_TEXT_OVERLAY (gst_text_overlay_get_type()) ++ ++ ++GST_CAIRO_TEXT_OVERLAY ++#define GST_CAIRO_TEXT_OVERLAY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),\ ++ GST_TYPE_CAIRO_TEXT_OVERLAY, GstCairoTextOverlay)) ++ ++ ++GST_CAIRO_TEXT_OVERLAY_CLASS ++#define GST_CAIRO_TEXT_OVERLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),\ ++ GST_TYPE_CAIRO_TEXT_OVERLAY, GstCairoTextOverlayClass)) ++ ++ ++GST_CAIRO_TEXT_OVERLAY_GET_CLASS ++#define GST_CAIRO_TEXT_OVERLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\ ++ GST_TYPE_CAIRO_TEXT_OVERLAY, GstCairoTextOverlayClass)) ++ ++ ++GST_IS_CAIRO_TEXT_OVERLAY ++#define GST_IS_CAIRO_TEXT_OVERLAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),\ ++ GST_TYPE_CAIRO_TEXT_OVERLAY)) ++ ++ ++GST_IS_CAIRO_TEXT_OVERLAY_CLASS ++#define GST_IS_CAIRO_TEXT_OVERLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),\ ++ GST_TYPE_CAIRO_TEXT_OVERLAY)) ++ ++ ++GstCairoTextOverlay ++ ++ ++GstCairoTextOverlayClass ++ ++ ++GstCairoTextOverlayVAlign ++enum GstCairoTextOverlayVAlign { ++ GST_CAIRO_TEXT_OVERLAY_VALIGN_BASELINE, ++ GST_CAIRO_TEXT_OVERLAY_VALIGN_BOTTOM, ++ GST_CAIRO_TEXT_OVERLAY_VALIGN_TOP ++}; ++ ++ ++GstCairoTextOverlayHAlign ++enum GstCairoTextOverlayHAlign { ++ GST_CAIRO_TEXT_OVERLAY_HALIGN_LEFT, ++ GST_CAIRO_TEXT_OVERLAY_HALIGN_CENTER, ++ GST_CAIRO_TEXT_OVERLAY_HALIGN_RIGHT ++}; ++ ++ ++GstCairoTextOverlay ++struct _GstCairoTextOverlay { ++ GstElement element; ++ ++ GstPad *video_sinkpad; ++ GstPad *text_sinkpad; ++ GstPad *srcpad; ++ ++ GstCollectPads *collect; ++ GstCollectData *video_collect_data; ++ GstCollectData *text_collect_data; ++ ++ gint width; ++ gint height; ++ gint fps_n; ++ gint fps_d; ++ ++ GstCairoTextOverlayVAlign valign; ++ GstCairoTextOverlayHAlign halign; ++ gint xpad; ++ gint ypad; ++ gint deltax; ++ gint deltay; ++ gchar *default_text; ++ gboolean want_shading; ++ ++ guchar *text_fill_image; ++ guchar *text_outline_image; ++ gint font_height; ++ gint text_x0, text_x1; /* start/end x position of text */ ++ gint text_dy; ++ ++ gboolean need_render; ++ ++ gchar *font; ++ gint slant; ++ gint weight; ++ gdouble scale; ++}; ++ ++ ++GstCairoTextOverlayClass ++struct _GstCairoTextOverlayClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_text_overlay_get_type ++GType ++void ++ ++ ++GST_TYPE_CAIRO_TIME_OVERLAY ++#define GST_TYPE_CAIRO_TIME_OVERLAY \ ++ (gst_cairo_time_overlay_get_type()) ++ ++ ++GST_CAIRO_TIME_OVERLAY ++#define GST_CAIRO_TIME_OVERLAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CAIRO_TIME_OVERLAY,GstCairoTimeOverlay)) ++ ++ ++GST_CAIRO_TIME_OVERLAY_CLASS ++#define GST_CAIRO_TIME_OVERLAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CAIRO_TIME_OVERLAY,GstCairoTimeOverlayClass)) ++ ++ ++GST_IS_CAIRO_TIME_OVERLAY ++#define GST_IS_CAIRO_TIME_OVERLAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CAIRO_TIME_OVERLAY)) ++ ++ ++GST_IS_CAIRO_TIME_OVERLAY_CLASS ++#define GST_IS_CAIRO_TIME_OVERLAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CAIRO_TIME_OVERLAY)) ++ ++ ++GstCairoTimeOverlay ++typedef struct _GstCairoTimeOverlay { ++ GstBaseTransform basetransform; ++ ++ gint width, height; ++ ++ cairo_surface_t *surface; ++ cairo_t *cr; ++ int text_height; ++ ++} GstCairoTimeOverlay; ++ ++ ++GstCairoTimeOverlayClass ++typedef struct _GstCairoTimeOverlayClass { ++ GstBaseTransformClass parent_class; ++} GstCairoTimeOverlayClass; ++ ++ ++gst_cairo_time_overlay_get_type ++GType ++void ++ ++ ++GST_TYPE_CAIRO_RENDER ++#define GST_TYPE_CAIRO_RENDER (gst_cairo_render_get_type()) ++ ++ ++GST_CAIRO_RENDER ++#define GST_CAIRO_RENDER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CAIRO_RENDER,GstCairoRender)) ++ ++ ++GST_CAIRO_RENDER_CLASS ++#define GST_CAIRO_RENDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CAIRO_RENDER,GstCairoRenderClass)) ++ ++ ++GstCairoRender ++ ++ ++GstCairoRenderClass ++ ++ ++GstCairoRender ++struct _GstCairoRender ++{ ++ GstElement parent; ++ ++ GstPad *snk, *src; ++ ++ /* < private > */ ++ ++ /* Source */ ++ cairo_surface_t *surface; ++ gint width, height, stride; ++ ++ /* Sink */ ++ gint64 offset, duration; ++ gboolean png; ++ cairo_format_t format; ++}; ++ ++ ++GstCairoRenderClass ++struct _GstCairoRenderClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_cairo_render_get_type ++GType ++void ++ ++ ++GST_TYPE_DVDEC ++#define GST_TYPE_DVDEC \ ++ (gst_dvdec_get_type()) ++ ++ ++GST_DVDEC ++#define GST_DVDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DVDEC,GstDVDec)) ++ ++ ++GST_DVDEC_CLASS ++#define GST_DVDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DVDEC,GstDVDecClass)) ++ ++ ++GST_IS_DVDEC ++#define GST_IS_DVDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DVDEC)) ++ ++ ++GST_IS_DVDEC_CLASS ++#define GST_IS_DVDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DVDEC)) ++ ++ ++GstDVDec ++ ++ ++GstDVDecClass ++ ++ ++GstDVDec ++struct _GstDVDec { ++ GstElement element; ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ dv_decoder_t *decoder; ++ gboolean clamp_luma; ++ gboolean clamp_chroma; ++ gint quality; ++ ++ gboolean PAL; ++ gboolean interlaced; ++ gboolean wide; ++ gint frame_len; ++ ++ /* input caps */ ++ gboolean sink_negotiated; ++ gint framerate_numerator; ++ gint framerate_denominator; ++ gint height; ++ gint par_x; ++ gint par_y; ++ gboolean need_par; ++ ++ /* negotiated output */ ++ dv_color_space_t space; ++ gint bpp; ++ gboolean src_negotiated; ++ ++ gint video_offset; ++ gint drop_factor; ++ ++ GstSegment *segment; ++}; ++ ++ ++GstDVDecClass ++struct _GstDVDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_dvdec_get_type ++GType ++void ++ ++ ++GST_TYPE_DVDEMUX ++#define GST_TYPE_DVDEMUX \ ++ (gst_dvdemux_get_type()) ++ ++ ++GST_DVDEMUX ++#define GST_DVDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DVDEMUX,GstDVDemux)) ++ ++ ++GST_DVDEMUX_CLASS ++#define GST_DVDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DVDEMUX,GstDVDemuxClass)) ++ ++ ++GST_IS_DVDEMUX ++#define GST_IS_DVDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DVDEMUX)) ++ ++ ++GST_IS_DVDEMUX_CLASS ++#define GST_IS_DVDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DVDEMUX)) ++ ++ ++GstDVDemux ++ ++ ++GstDVDemuxClass ++ ++ ++GstDVDemuxSeekHandler ++gboolean ++GstDVDemux *demux, GstPad * pad, GstEvent * event ++ ++ ++GstDVDemux ++struct _GstDVDemux { ++ GstElement element; ++ ++ GstPad *sinkpad; ++ GstPad *videosrcpad; ++ GstPad *audiosrcpad; ++ ++ dv_decoder_t *decoder; ++ ++ GstAdapter *adapter; ++ gint frame_len; ++ ++ /* video params */ ++ gint framerate_numerator; ++ gint framerate_denominator; ++ gint height; ++ gboolean wide; ++ /* audio params */ ++ gint frequency; ++ gint channels; ++ ++ gint framecount; ++ ++ gint64 frame_offset; ++ gint64 audio_offset; ++ gint64 video_offset; ++ ++ GstDVDemuxSeekHandler seek_handler; ++ GstSegment byte_segment; ++ GstSegment time_segment; ++ gboolean running; ++ gboolean need_segment; ++ gboolean new_media; ++ int frames_since_new_media; ++ ++ gint found_header; /* ATOMIC */ ++ GstEvent *seek_event; ++ GstEvent *pending_segment; ++ ++ gint16 *audio_buffers[4]; ++}; ++ ++ ++GstDVDemuxClass ++struct _GstDVDemuxClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_dvdemux_get_type ++GType ++void ++ ++ ++GST_TYPE_ESDSINK ++#define GST_TYPE_ESDSINK \ ++ (gst_esdsink_get_type()) ++ ++ ++GST_ESDSINK ++#define GST_ESDSINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ESDSINK,GstEsdSink)) ++ ++ ++GST_ESDSINK_CLASS ++#define GST_ESDSINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ESDSINK,GstEsdSinkClass)) ++ ++ ++GST_IS_ESDSINK ++#define GST_IS_ESDSINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ESDSINK)) ++ ++ ++GST_IS_ESDSINK_CLASS ++#define GST_IS_ESDSINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ESDSINK)) ++ ++ ++GstEsdSink ++ ++ ++GstEsdSinkClass ++ ++ ++GstEsdSink ++struct _GstEsdSink { ++ GstAudioSink sink; ++ ++ int fd; ++ int ctrl_fd; ++ gchar *host; ++ ++ guint rate; ++ GstCaps *cur_caps; ++}; ++ ++ ++GstEsdSinkClass ++struct _GstEsdSinkClass { ++ GstAudioSinkClass parent_class; ++}; ++ ++ ++gst_esdsink_get_type ++GType ++void ++ ++ ++GST_TYPE_FLAC_DEC ++#define GST_TYPE_FLAC_DEC gst_flac_dec_get_type() ++ ++ ++GST_FLAC_DEC ++#define GST_FLAC_DEC(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, GST_TYPE_FLAC_DEC, GstFlacDec) ++ ++ ++GST_FLAC_DEC_CLASS ++#define GST_FLAC_DEC_CLASS(klass) G_TYPE_CHECK_CLASS_CAST(klass, GST_TYPE_FLAC_DEC, GstFlacDecClass) ++ ++ ++GST_IS_FLAC_DEC ++#define GST_IS_FLAC_DEC(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, GST_TYPE_FLAC_DEC) ++ ++ ++GST_IS_FLAC_DEC_CLASS ++#define GST_IS_FLAC_DEC_CLASS(klass) G_TYPE_CHECK_CLASS_TYPE(klass, GST_TYPE_FLAC_DEC) ++ ++ ++GstFlacDec ++ ++ ++GstFlacDecClass ++ ++ ++GstFlacDec ++struct _GstFlacDec { ++ GstElement element; ++ ++ /* < private > */ ++ ++ FLAC__StreamDecoder *decoder; ++ GstAdapter *adapter; ++ gboolean framed; ++ gboolean streaming; ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ gboolean init; ++ ++ guint64 offset; /* current byte offset of input */ ++ ++ gboolean seeking; /* set to TRUE while seeking to make sure we ++ * don't push any buffers in the write callback ++ * until we are actually at the new position */ ++ ++ GstSegment segment; /* the currently configured segment, in ++ * samples/audio frames (DEFAULT format) */ ++ gboolean running; ++ gboolean discont; ++ GstBuffer *pending; /* pending buffer, produced in seek */ ++ guint pending_samples; ++ GstEvent *close_segment; ++ GstEvent *start_segment; ++ GstTagList *tags; ++ ++ GstFlowReturn pull_flow; /* last flow from pull_range */ /* STREAM_LOCK */ ++ ++ GstFlowReturn last_flow; /* the last flow return received from either ++ * gst_pad_push or gst_pad_buffer_alloc */ ++ ++ gint channels; ++ gint depth; ++ gint width; ++ gint sample_rate; ++ ++ /* from the stream info, needed for scanning */ ++ guint16 min_blocksize; ++ guint16 max_blocksize; ++ ++ gint64 cur_granulepos; /* only used in framed mode (flac-in-ogg) */ ++}; ++ ++ ++GstFlacDecClass ++struct _GstFlacDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_flac_dec_get_type ++GType ++void ++ ++ ++GST_TYPE_FLAC_ENC ++#define GST_TYPE_FLAC_ENC (gst_flac_enc_get_type()) ++ ++ ++GST_FLAC_ENC ++#define GST_FLAC_ENC(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, GST_TYPE_FLAC_ENC, GstFlacEnc) ++ ++ ++GST_FLAC_ENC_CLASS ++#define GST_FLAC_ENC_CLASS(klass) G_TYPE_CHECK_CLASS_CAST(klass, GST_TYPE_FLAC_ENC, GstFlacEncClass) ++ ++ ++GST_IS_FLAC_ENC ++#define GST_IS_FLAC_ENC(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, GST_TYPE_FLAC_ENC) ++ ++ ++GST_IS_FLAC_ENC_CLASS ++#define GST_IS_FLAC_ENC_CLASS(klass) G_TYPE_CHECK_CLASS_TYPE(klass, GST_TYPE_FLAC_ENC) ++ ++ ++GstFlacEnc ++ ++ ++GstFlacEncClass ++ ++ ++GstFlacEnc ++struct _GstFlacEnc { ++ GstElement element; ++ ++ /* < private > */ ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstFlowReturn last_flow; /* save flow from last push so we can pass the ++ * correct flow return upstream in case the push ++ * fails for some reason */ ++ ++ guint64 offset; ++ guint64 samples_written; ++ gint channels; ++ gint width; ++ gint depth; ++ gint sample_rate; ++ gint quality; ++ gboolean stopped; ++ guint padding; ++ gint seekpoints; ++ ++#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT < 8 ++ FLAC__SeekableStreamEncoder *encoder; ++#else ++ FLAC__StreamEncoder *encoder; ++#endif ++ FLAC__StreamMetadata **meta; ++ ++ GstTagList * tags; ++ ++ /* queue headers until we have them all so we can add streamheaders to caps */ ++ gboolean got_headers; ++ GList *headers; ++ ++ /* Timestamp and granulepos tracking */ ++ GstClockTime start_ts; ++ GstClockTime next_ts; ++ guint64 granulepos_offset; ++}; ++ ++ ++GstFlacEncClass ++struct _GstFlacEncClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_flac_enc_get_type ++GType ++void ++ ++ ++GST_TYPE_FLAC_TAG ++#define GST_TYPE_FLAC_TAG (gst_flac_tag_get_type()) ++ ++ ++GST_FLAC_TAG ++#define GST_FLAC_TAG(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLAC_TAG, GstFlacTag)) ++ ++ ++GST_FLAC_TAG_CLASS ++#define GST_FLAC_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLAC_TAG, GstFlacTag)) ++ ++ ++GST_IS_FLAC_TAG ++#define GST_IS_FLAC_TAG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLAC_TAG)) ++ ++ ++GST_IS_FLAC_TAG_CLASS ++#define GST_IS_FLAC_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLAC_TAG)) ++ ++ ++GstFlacTag ++ ++ ++GstFlacTagClass ++ ++ ++GstFlacTagState ++typedef enum ++{ ++ GST_FLAC_TAG_STATE_INIT, ++ GST_FLAC_TAG_STATE_METADATA_BLOCKS, ++ GST_FLAC_TAG_STATE_METADATA_NEXT_BLOCK, ++ GST_FLAC_TAG_STATE_WRITING_METADATA_BLOCK, ++ GST_FLAC_TAG_STATE_VC_METADATA_BLOCK, ++ GST_FLAC_TAG_STATE_ADD_VORBIS_COMMENT, ++ GST_FLAC_TAG_STATE_AUDIO_DATA ++} ++GstFlacTagState; ++ ++ ++GstFlacTag ++struct _GstFlacTag ++{ ++ GstElement element; ++ ++ /* < private > */ ++ ++ /* pads */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstFlacTagState state; ++ ++ GstAdapter *adapter; ++ GstBuffer *vorbiscomment; ++ GstTagList *tags; ++ ++ guint metadata_block_size; ++ gboolean metadata_last_block; ++}; ++ ++ ++GstFlacTagClass ++struct _GstFlacTagClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_flac_tag_get_type ++GType ++void ++ ++ ++GST_TYPE_GCONF_AUDIO_SRC ++#define GST_TYPE_GCONF_AUDIO_SRC (gst_gconf_audio_src_get_type ()) ++ ++ ++GST_GCONF_AUDIO_SRC ++#define GST_GCONF_AUDIO_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_GCONF_AUDIO_SRC, GstGConfAudioSrc)) ++ ++ ++GST_GCONF_AUDIO_SRC_CLASS ++#define GST_GCONF_AUDIO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_GCONF_AUDIO_SRC, GstGConfAudioSrcClass)) ++ ++ ++GST_IS_GCONF_AUDIO_SRC ++#define GST_IS_GCONF_AUDIO_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_GCONF_AUDIO_SRC)) ++ ++ ++GST_IS_GCONF_AUDIO_SRC_CLASS ++#define GST_IS_GCONF_AUDIO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_GCONF_AUDIO_SRC)) ++ ++ ++GstGConfAudioSrc ++typedef struct _GstGConfAudioSrc { ++ GstSwitchSrc parent; ++ ++ /* explicit pointers to stuff used */ ++ GConfClient *client; ++ ++ guint gconf_notify_id; ++ ++ /* Current gconf string */ ++ gchar *gconf_str; ++} GstGConfAudioSrc; ++ ++ ++GstGConfAudioSrcClass ++typedef struct _GstGConfAudioSrcClass { ++ GstSwitchSrcClass parent_class; ++} GstGConfAudioSrcClass; ++ ++ ++gst_gconf_audio_src_get_type ++GType ++void ++ ++ ++GST_TYPE_GCONF_AUDIO_SINK ++#define GST_TYPE_GCONF_AUDIO_SINK \ ++ (gst_gconf_audio_sink_get_type ()) ++ ++ ++GST_GCONF_AUDIO_SINK ++#define GST_GCONF_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_GCONF_AUDIO_SINK, \ ++ GstGConfAudioSink)) ++ ++ ++GST_GCONF_AUDIO_SINK_CLASS ++#define GST_GCONF_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_GCONF_AUDIO_SINK, \ ++ GstGConfAudioSinkClass)) ++ ++ ++GST_IS_GCONF_AUDIO_SINK ++#define GST_IS_GCONF_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_GCONF_AUDIO_SINK)) ++ ++ ++GST_IS_GCONF_AUDIO_SINK_CLASS ++#define GST_IS_GCONF_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_GCONF_AUDIO_SINK)) ++ ++ ++GstGConfAudioSink ++typedef struct _GstGConfAudioSink { ++ GstSwitchSink parent; ++ ++ /* explicit pointers to stuff used */ ++ GConfClient *client; ++ GstGConfProfile profile; ++ guint notify_id; ++ ++ /* Current gconf string */ ++ gchar *gconf_str; ++} GstGConfAudioSink; ++ ++ ++GstGConfAudioSinkClass ++typedef struct _GstGConfAudioSinkClass { ++ GstSwitchSinkClass parent_class; ++} GstGConfAudioSinkClass; ++ ++ ++gst_gconf_audio_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_GCONF_VIDEO_SRC ++#define GST_TYPE_GCONF_VIDEO_SRC (gst_gconf_video_src_get_type ()) ++ ++ ++GST_GCONF_VIDEO_SRC ++#define GST_GCONF_VIDEO_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_GCONF_VIDEO_SRC, GstGConfVideoSrc)) ++ ++ ++GST_GCONF_VIDEO_SRC_CLASS ++#define GST_GCONF_VIDEO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_GCONF_VIDEO_SRC, GstGConfVideoSrcClass)) ++ ++ ++GST_IS_GCONF_VIDEO_SRC ++#define GST_IS_GCONF_VIDEO_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_GCONF_VIDEO_SRC)) ++ ++ ++GST_IS_GCONF_VIDEO_SRC_CLASS ++#define GST_IS_GCONF_VIDEO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_GCONF_VIDEO_SRC)) ++ ++ ++GstGConfVideoSrc ++typedef struct _GstGConfVideoSrc { ++ GstSwitchSrc parent; ++ ++ /* explicit pointers to stuff used */ ++ GConfClient *client; ++ ++ /* gconf key notification id */ ++ guint notify_id; ++ ++ /* Current gconf string */ ++ gchar *gconf_str; ++} GstGConfVideoSrc; ++ ++ ++GstGConfVideoSrcClass ++typedef struct _GstGConfVideoSrcClass { ++ GstSwitchSrcClass parent_class; ++} GstGConfVideoSrcClass; ++ ++ ++gst_gconf_video_src_get_type ++GType ++void ++ ++ ++GST_TYPE_GCONF_VIDEO_SINK ++#define GST_TYPE_GCONF_VIDEO_SINK \ ++ (gst_gconf_video_sink_get_type ()) ++ ++ ++GST_GCONF_VIDEO_SINK ++#define GST_GCONF_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_GCONF_VIDEO_SINK, \ ++ GstGConfVideoSink)) ++ ++ ++GST_GCONF_VIDEO_SINK_CLASS ++#define GST_GCONF_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_GCONF_VIDEO_SINK, \ ++ GstGConfVideoSinkClass)) ++ ++ ++GST_IS_GCONF_VIDEO_SINK ++#define GST_IS_GCONF_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_GCONF_VIDEO_SINK)) ++ ++ ++GST_IS_GCONF_VIDEO_SINK_CLASS ++#define GST_IS_GCONF_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_GCONF_VIDEO_SINK)) ++ ++ ++GstGConfVideoSink ++typedef struct _GstGConfVideoSink { ++ GstSwitchSink parent; ++ ++ /* explicit pointers to stuff used */ ++ GConfClient *client; ++ ++ /* gconf notify id */ ++ guint notify_id; ++ ++ /* Current gconf string */ ++ gchar *gconf_str; ++} GstGConfVideoSink; ++ ++ ++GstGConfVideoSinkClass ++typedef struct _GstGConfVideoSinkClass { ++ GstSwitchSinkClass parent_class; ++} GstGConfVideoSinkClass; ++ ++ ++gst_gconf_video_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_GDK_PIXBUF_SINK ++#define GST_TYPE_GDK_PIXBUF_SINK (gst_gdk_pixbuf_sink_get_type()) ++ ++ ++GST_GDK_PIXBUF_SINK ++#define GST_GDK_PIXBUF_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GDK_PIXBUF_SINK,GstGdkPixbufSink)) ++ ++ ++GST_GDK_PIXBUF_SINK_CLASS ++#define GST_GDK_PIXBUF_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GDK_PIXBUF_SINK,GstGdkPixbufSinkClass)) ++ ++ ++GST_IS_GDK_PIXBUF_SINK ++#define GST_IS_GDK_PIXBUF_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GDK_PIXBUF_SINK)) ++ ++ ++GST_IS_GDK_PIXBUF_SINK_CLASS ++#define GST_IS_GDK_PIXBUF_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GDK_PIXBUF_SINK)) ++ ++ ++GstGdkPixbufSink ++ ++ ++GstGdkPixbufSinkClass ++ ++ ++GstGdkPixbufSink ++struct _GstGdkPixbufSink ++{ ++ GstVideoSink basesink; ++ ++ /*< private >*/ ++ ++ /* current caps */ ++ gint width; ++ gint height; ++ gint rowstride; ++ gint par_n; ++ gint par_d; ++ gboolean has_alpha; ++ ++ /* properties */ ++ gboolean post_messages; ++ GdkPixbuf * last_pixbuf; ++}; ++ ++ ++GstGdkPixbufSinkClass ++struct _GstGdkPixbufSinkClass ++{ ++ GstVideoSinkClass basesinkclass; ++}; ++ ++ ++gst_gdk_pixbuf_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_HAL_AUDIO_SINK ++#define GST_TYPE_HAL_AUDIO_SINK \ ++ (gst_hal_audio_sink_get_type ()) ++ ++ ++GST_HAL_AUDIO_SINK ++#define GST_HAL_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_HAL_AUDIO_SINK, \ ++ GstHalAudioSink)) ++ ++ ++GST_HAL_AUDIO_SINK_CLASS ++#define GST_HAL_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_HAL_AUDIO_SINK, \ ++ GstHalAudioSinkClass)) ++ ++ ++GST_IS_HAL_AUDIO_SINK ++#define GST_IS_HAL_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_HAL_AUDIO_SINK)) ++ ++ ++GST_IS_HAL_AUDIO_SINK_CLASS ++#define GST_IS_HAL_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_HAL_AUDIO_SINK)) ++ ++ ++GstHalAudioSink ++typedef struct _GstHalAudioSink { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ gchar *udi; ++ GstElement *kid; ++ GstPad *pad; ++} GstHalAudioSink; ++ ++ ++GstHalAudioSinkClass ++typedef struct _GstHalAudioSinkClass { ++ GstBinClass parent_class; ++} GstHalAudioSinkClass; ++ ++ ++gst_hal_audio_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_HAL_AUDIO_SRC ++#define GST_TYPE_HAL_AUDIO_SRC (gst_hal_audio_src_get_type ()) ++ ++ ++GST_HAL_AUDIO_SRC ++#define GST_HAL_AUDIO_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_HAL_AUDIO_SRC, GstHalAudioSrc)) ++ ++ ++GST_HAL_AUDIO_SRC_CLASS ++#define GST_HAL_AUDIO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_HAL_AUDIO_SRC, GstHalAudioSrcClass)) ++ ++ ++GST_IS_HAL_AUDIO_SRC ++#define GST_IS_HAL_AUDIO_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_HAL_AUDIO_SRC)) ++ ++ ++GST_IS_HAL_AUDIO_SRC_CLASS ++#define GST_IS_HAL_AUDIO_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_HAL_AUDIO_SRC)) ++ ++ ++GstHalAudioSrc ++typedef struct _GstHalAudioSrc { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ gchar *udi; ++ GstElement *kid; ++ GstPad *pad; ++} GstHalAudioSrc; ++ ++ ++GstHalAudioSrcClass ++typedef struct _GstHalAudioSrcClass { ++ GstBinClass parent_class; ++} GstHalAudioSrcClass; ++ ++ ++gst_hal_audio_src_get_type ++GType ++void ++ ++ ++GST_TYPE_JPEG_DEC ++#define GST_TYPE_JPEG_DEC \ ++ (gst_jpeg_dec_get_type()) ++ ++ ++GST_JPEG_DEC ++#define GST_JPEG_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_JPEG_DEC,GstJpegDec)) ++ ++ ++GST_JPEG_DEC_CLASS ++#define GST_JPEG_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_JPEG_DEC,GstJpegDecClass)) ++ ++ ++GST_IS_JPEG_DEC ++#define GST_IS_JPEG_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_JPEG_DEC)) ++ ++ ++GST_IS_JPEG_DEC_CLASS ++#define GST_IS_JPEG_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_JPEG_DEC)) ++ ++ ++GstJpegDec ++ ++ ++GstJpegDecClass ++ ++ ++GstJpegDec ++struct _GstJpegDec { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstAdapter *adapter; ++ ++ guint8 *cur_buf; ++ ++ /* TRUE if each input buffer contains a whole jpeg image */ ++ gboolean packetized; ++ ++ /* the (expected) timestamp of the next frame */ ++ guint64 next_ts; ++ ++ GstSegment segment; ++ ++ /* TRUE if the next output buffer should have the DISCONT flag set */ ++ gboolean discont; ++ ++ /* QoS stuff *//* with LOCK */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++ GstClockTime qos_duration; ++ ++ /* video state */ ++ gint framerate_numerator; ++ gint framerate_denominator; ++ ++ /* negotiated state */ ++ gint caps_framerate_numerator; ++ gint caps_framerate_denominator; ++ gint caps_width; ++ gint caps_height; ++ gint outsize; ++ gint clrspc; ++ ++ gint offset[3]; ++ gint stride; ++ gint inc; ++ ++ /* parse state */ ++ gint parse_offset; ++ gint parse_entropy_len; ++ gint parse_resync; ++ ++ /* properties */ ++ gint idct_method; ++ ++ struct jpeg_decompress_struct cinfo; ++ struct GstJpegDecErrorMgr jerr; ++ struct GstJpegDecSourceMgr jsrc; ++ ++ /* arrays for indirect decoding */ ++ gboolean idr_width_allocated; ++ guchar *idr_y[16],*idr_u[16],*idr_v[16]; ++ /* current (parsed) image size */ ++ guint rem_img_len; ++}; ++ ++ ++GstJpegDecClass ++struct _GstJpegDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_jpeg_dec_get_type ++GType ++void ++ ++ ++GST_TYPE_JPEGENC ++#define GST_TYPE_JPEGENC \ ++ (gst_jpegenc_get_type()) ++ ++ ++GST_JPEGENC ++#define GST_JPEGENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_JPEGENC,GstJpegEnc)) ++ ++ ++GST_JPEGENC_CLASS ++#define GST_JPEGENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_JPEGENC,GstJpegEncClass)) ++ ++ ++GST_IS_JPEGENC ++#define GST_IS_JPEGENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_JPEGENC)) ++ ++ ++GST_IS_JPEGENC_CLASS ++#define GST_IS_JPEGENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_JPEGENC)) ++ ++ ++GstJpegEnc ++ ++ ++GstJpegEncClass ++ ++ ++GST_JPEG_ENC_MAX_COMPONENT ++#define GST_JPEG_ENC_MAX_COMPONENT 4 ++ ++ ++GstJpegEnc ++struct _GstJpegEnc ++{ ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad, *srcpad; ++ ++ /* stream/image properties */ ++ GstVideoFormat format; ++ gint width; ++ gint height; ++ gint channels; ++ gint fps_num, fps_den; ++ gint par_num, par_den; ++ /* standard video_format indexed */ ++ gint stride[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint offset[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint inc[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint cwidth[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint cheight[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint h_samp[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint v_samp[GST_JPEG_ENC_MAX_COMPONENT]; ++ gint h_max_samp; ++ gint v_max_samp; ++ gboolean planar; ++ /* the video buffer */ ++ gint bufsize; ++ /* the jpeg line buffer */ ++ guchar **line[3]; ++ /* indirect encoding line buffers */ ++ guchar *row[3][4 * DCTSIZE]; ++ ++ struct jpeg_compress_struct cinfo; ++ struct jpeg_error_mgr jerr; ++ struct jpeg_destination_mgr jdest; ++ ++ /* properties */ ++ gint quality; ++ gint smoothing; ++ gint idct_method; ++ ++ /* cached return state for any problems that may occur in callbacks */ ++ GstFlowReturn last_ret; ++ ++ GstBuffer *output_buffer; ++}; ++ ++ ++GstJpegEncClass ++struct _GstJpegEncClass ++{ ++ GstElementClass parent_class; ++ ++ /* signals */ ++ void (*frame_encoded) (GstElement * element); ++}; ++ ++ ++gst_jpegenc_get_type ++GType ++void ++ ++ ++GST_TYPE_SMOKEDEC ++#define GST_TYPE_SMOKEDEC \ ++ (gst_smokedec_get_type()) ++ ++ ++GST_SMOKEDEC ++#define GST_SMOKEDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMOKEDEC,GstSmokeDec)) ++ ++ ++GST_SMOKEDEC_CLASS ++#define GST_SMOKEDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMOKEDEC,GstSmokeDecClass)) ++ ++ ++GST_IS_SMOKEDEC ++#define GST_IS_SMOKEDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMOKEDEC)) ++ ++ ++GST_IS_SMOKEDEC_CLASS ++#define GST_IS_SMOKEDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMOKEDEC)) ++ ++ ++GstSmokeDec ++ ++ ++GstSmokeDecClass ++ ++ ++GstSmokeDec ++struct _GstSmokeDec { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad,*srcpad; ++ ++ /* video state */ ++ gint format; ++ gint width; ++ gint height; ++ gint fps_num; ++ gint fps_denom; ++ GstClockTime next_time; ++ ++ SmokeCodecInfo *info; ++ ++ gint threshold; ++ gint quality; ++ gint smoothing; ++ ++ gboolean need_keyframe; ++}; ++ ++ ++GstSmokeDecClass ++struct _GstSmokeDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_smokedec_get_type ++GType ++void ++ ++ ++GST_TYPE_SMOKEENC ++#define GST_TYPE_SMOKEENC \ ++ (gst_smokeenc_get_type()) ++ ++ ++GST_SMOKEENC ++#define GST_SMOKEENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMOKEENC,GstSmokeEnc)) ++ ++ ++GST_SMOKEENC_CLASS ++#define GST_SMOKEENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMOKEENC,GstSmokeEncClass)) ++ ++ ++GST_IS_SMOKEENC ++#define GST_IS_SMOKEENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMOKEENC)) ++ ++ ++GST_IS_SMOKEENC_CLASS ++#define GST_IS_SMOKEENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMOKEENC)) ++ ++ ++GstSmokeEnc ++ ++ ++GstSmokeEncClass ++ ++ ++GstSmokeEnc ++struct _GstSmokeEnc { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad,*srcpad; ++ ++ /* video state */ ++ gint format; ++ gint width; ++ gint height; ++ gint frame; ++ gint keyframe; ++ gint fps_num, fps_denom; ++ ++ SmokeCodecInfo *info; ++ ++ gint threshold; ++ gint min_quality; ++ gint max_quality; ++ ++ gboolean need_header; ++}; ++ ++ ++GstSmokeEncClass ++struct _GstSmokeEncClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_smokeenc_get_type ++GType ++void ++ ++ ++GST_TYPE_CACASINK ++#define GST_TYPE_CACASINK \ ++ (gst_cacasink_get_type()) ++ ++ ++GST_CACASINK ++#define GST_CACASINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CACASINK,GstCACASink)) ++ ++ ++GST_CACASINK_CLASS ++#define GST_CACASINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CACASINK,GstCACASinkClass)) ++ ++ ++GST_IS_CACASINK ++#define GST_IS_CACASINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CACASINK)) ++ ++ ++GST_IS_CACASINK_CLASS ++#define GST_IS_CACASINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CACASINK)) ++ ++ ++GstCACASink ++ ++ ++GstCACASinkClass ++ ++ ++GstCACASink ++struct _GstCACASink { ++ GstBaseSink parent; ++ ++ gint width, height; ++ gint screen_width, screen_height; ++ guint bpp; ++ guint dither; ++ gboolean antialiasing; ++ guint red_mask, green_mask, blue_mask; ++ ++ struct caca_bitmap *bitmap; ++}; ++ ++ ++GstCACASinkClass ++struct _GstCACASinkClass { ++ GstBaseSinkClass parent_class; ++ ++ /* signals */ ++}; ++ ++ ++gst_cacasink_get_type ++GType ++void ++ ++ ++GST_TYPE_PNGDEC ++#define GST_TYPE_PNGDEC (gst_pngdec_get_type()) ++ ++ ++GST_PNGDEC ++#define GST_PNGDEC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PNGDEC,GstPngDec)) ++ ++ ++GST_PNGDEC_CLASS ++#define GST_PNGDEC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PNGDEC,GstPngDecClass)) ++ ++ ++GST_IS_PNGDEC ++#define GST_IS_PNGDEC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PNGDEC)) ++ ++ ++GST_IS_PNGDEC_CLASS ++#define GST_IS_PNGDEC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PNGDEC)) ++ ++ ++GstPngDec ++ ++ ++GstPngDecClass ++ ++ ++GstPngDec ++struct _GstPngDec ++{ ++ GstElement element; ++ ++ GstPad *sinkpad, *srcpad; ++ ++ gboolean need_newsegment; ++ ++ /* Progressive */ ++ GstBuffer *buffer_out; ++ GstFlowReturn ret; ++ png_uint_32 rowbytes; ++ ++ /* Pull range */ ++ gint offset; ++ ++ png_structp png; ++ png_infop info; ++ png_infop endinfo; ++ gboolean setup; ++ ++ gint width; ++ gint height; ++ gint bpp; ++ gint color_type; ++ gint fps_n; ++ gint fps_d; ++ ++ /* Chain */ ++ gboolean framed; ++ GstClockTime in_timestamp; ++ GstClockTime in_duration; ++ ++ GstSegment segment; ++ gboolean image_ready; ++}; ++ ++ ++GstPngDecClass ++struct _GstPngDecClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_pngdec_get_type ++GType ++void ++ ++ ++GST_TYPE_PNGENC ++#define GST_TYPE_PNGENC (gst_pngenc_get_type()) ++ ++ ++GST_PNGENC ++#define GST_PNGENC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PNGENC,GstPngEnc)) ++ ++ ++GST_PNGENC_CLASS ++#define GST_PNGENC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PNGENC,GstPngEncClass)) ++ ++ ++GST_IS_PNGENC ++#define GST_IS_PNGENC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PNGENC)) ++ ++ ++GST_IS_PNGENC_CLASS ++#define GST_IS_PNGENC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PNGENC)) ++ ++ ++GstPngEnc ++ ++ ++GstPngEncClass ++ ++ ++GstPngEnc ++struct _GstPngEnc ++{ ++ GstElement element; ++ ++ GstPad *sinkpad, *srcpad; ++ GstBuffer *buffer_out; ++ guint written; ++ ++ png_structp png_struct_ptr; ++ png_infop png_info_ptr; ++ ++ gint width; ++ gint height; ++ gint bpp; ++ gint stride; ++ guint compression_level; ++ ++ gboolean snapshot; ++ gboolean newmedia; ++}; ++ ++ ++GstPngEncClass ++struct _GstPngEncClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_pngenc_get_type ++GType ++void ++ ++ ++GST_TYPE_DV1394SRC ++#define GST_TYPE_DV1394SRC \ ++ (gst_dv1394src_get_type()) ++ ++ ++GST_DV1394SRC ++#define GST_DV1394SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DV1394SRC,GstDV1394Src)) ++ ++ ++GST_DV1394SRC_CLASS ++#define GST_DV1394SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DV1394SRC,GstDV1394SrcClass)) ++ ++ ++GST_IS_DV1394SRC ++#define GST_IS_DV1394SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DV1394SRC)) ++ ++ ++GST_IS_DV1394SRC_CLASS ++#define GST_IS_DV1394SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DV1394SRC)) ++ ++ ++GstDV1394Src ++ ++ ++GstDV1394SrcClass ++ ++ ++GstDV1394Src ++struct _GstDV1394Src { ++ GstPushSrc element; ++ ++ // consecutive=2, skip=4 will skip 4 frames, then let 2 consecutive ones thru ++ gint consecutive; ++ gint skip; ++ gboolean drop_incomplete; ++ ++ gint num_ports; ++ gint port; ++ gint channel; ++ octlet_t guid; ++ gint avc_node; ++ gboolean use_avc; ++ ++ struct raw1394_portinfo pinfo[16]; ++ raw1394handle_t handle; ++ ++ GstBuffer *buf; ++ ++ GstBuffer *frame; ++ guint frame_size; ++ guint frame_rate; ++ guint bytes_in_frame; ++ guint frame_sequence; ++ ++ int control_sock[2]; ++ ++ gchar *uri; ++ ++ gchar *device_name; ++ ++ gboolean connected; ++ #ifdef HAVE_LIBIEC61883 ++ iec61883_dv_fb_t iec61883dv; ++ #endif ++ ++ Gst1394Clock *provided_clock; ++}; ++ ++ ++GstDV1394SrcClass ++struct _GstDV1394SrcClass { ++ GstPushSrcClass parent_class; ++ ++ /* signal */ ++ void (*frame_dropped) (GstElement *elem); ++}; ++ ++ ++gst_dv1394src_get_type ++GType ++void ++ ++ ++GST_TYPE_HDV1394SRC ++#define GST_TYPE_HDV1394SRC \ ++ (gst_hdv1394src_get_type()) ++ ++ ++GST_HDV1394SRC ++#define GST_HDV1394SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_HDV1394SRC,GstHDV1394Src)) ++ ++ ++GST_HDV1394SRC_CLASS ++#define GST_HDV1394SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_HDV1394SRC,GstHDV1394SrcClass)) ++ ++ ++GST_IS_HDV1394SRC ++#define GST_IS_HDV1394SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_HDV1394SRC)) ++ ++ ++GST_IS_HDV1394SRC_CLASS ++#define GST_IS_HDV1394SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_HDV1394SRC)) ++ ++ ++GstHDV1394Src ++ ++ ++GstHDV1394SrcClass ++ ++ ++GstHDV1394Src ++struct _GstHDV1394Src { ++ GstPushSrc element; ++ ++ gint num_ports; ++ gint port; ++ gint channel; ++ octlet_t guid; ++ gint avc_node; ++ gboolean use_avc; ++ ++ struct raw1394_portinfo pinfo[16]; ++ raw1394handle_t handle; ++ ++ gpointer outdata; ++ gsize outoffset; ++ guint frame_size; ++ guint frame_sequence; ++ ++ int control_sock[2]; ++ ++ gchar *uri; ++ ++ gchar *device_name; ++ ++ gboolean connected; ++ iec61883_mpeg2_t iec61883mpeg2; ++}; ++ ++ ++GstHDV1394SrcClass ++struct _GstHDV1394SrcClass { ++ GstPushSrcClass parent_class; ++}; ++ ++ ++gst_hdv1394src_get_type ++GType ++void ++ ++ ++GST_TYPE_SOUP_HTTP_SRC ++#define GST_TYPE_SOUP_HTTP_SRC \ ++ (gst_soup_http_src_get_type()) ++ ++ ++GST_SOUP_HTTP_SRC ++#define GST_SOUP_HTTP_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SOUP_HTTP_SRC,GstSoupHTTPSrc)) ++ ++ ++GST_SOUP_HTTP_SRC_CLASS ++#define GST_SOUP_HTTP_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), \ ++ GST_TYPE_SOUP_HTTP_SRC,GstSoupHTTPSrcClass)) ++ ++ ++GST_IS_SOUP_HTTP_SRC ++#define GST_IS_SOUP_HTTP_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SOUP_HTTP_SRC)) ++ ++ ++GST_IS_SOUP_HTTP_SRC_CLASS ++#define GST_IS_SOUP_HTTP_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SOUP_HTTP_SRC)) ++ ++ ++GstSoupHTTPSrc ++ ++ ++GstSoupHTTPSrcClass ++ ++ ++GstSoupHTTPSrcSessionIOStatus ++typedef enum { ++ GST_SOUP_HTTP_SRC_SESSION_IO_STATUS_IDLE, ++ GST_SOUP_HTTP_SRC_SESSION_IO_STATUS_QUEUED, ++ GST_SOUP_HTTP_SRC_SESSION_IO_STATUS_RUNNING, ++ GST_SOUP_HTTP_SRC_SESSION_IO_STATUS_CANCELLED, ++} GstSoupHTTPSrcSessionIOStatus; ++ ++ ++GstSoupHTTPSrc ++struct _GstSoupHTTPSrc { ++ GstPushSrc element; ++ ++ gchar *location; /* Full URI. */ ++ gchar *user_agent; /* User-Agent HTTP header. */ ++ gboolean automatic_redirect; /* Follow redirects. */ ++ SoupURI *proxy; /* HTTP proxy URI. */ ++ gchar *user_id; /* Authentication user id for location URI. */ ++ gchar *user_pw; /* Authentication user password for location URI. */ ++ gchar *proxy_id; /* Authentication user id for proxy URI. */ ++ gchar *proxy_pw; /* Authentication user password for proxy URI. */ ++ gchar **cookies; /* HTTP request cookies. */ ++ GMainContext *context; /* I/O context. */ ++ GMainLoop *loop; /* Event loop. */ ++ SoupSession *session; /* Async context. */ ++ GstSoupHTTPSrcSessionIOStatus session_io_status; ++ /* Async I/O status. */ ++ SoupMessage *msg; /* Request message. */ ++ GstFlowReturn ret; /* Return code from callback. */ ++ GstBuffer **outbuf; /* Return buffer allocated by callback. */ ++ gboolean interrupted; /* Signal unlock(). */ ++ gboolean retry; /* Should attempt to reconnect. */ ++ ++ gboolean have_size; /* Received and parsed Content-Length ++ header. */ ++ guint64 content_size; /* Value of Content-Length header. */ ++ guint64 read_position; /* Current position. */ ++ gboolean seekable; /* FALSE if the server does not support ++ Range. */ ++ guint64 request_position; /* Seek to this position. */ ++ ++ /* Shoutcast/icecast metadata extraction handling. */ ++ gboolean iradio_mode; ++ GstCaps *src_caps; ++ gchar *iradio_name; ++ gchar *iradio_genre; ++ gchar *iradio_url; ++ gchar *iradio_title; ++ ++ GstStructure *extra_headers; ++ ++ guint timeout; ++}; ++ ++ ++GstSoupHTTPSrcClass ++struct _GstSoupHTTPSrcClass { ++ GstPushSrcClass parent_class; ++}; ++ ++ ++gst_soup_http_src_get_type ++GType ++void ++ ++ ++GstApev2Mux ++ ++ ++GstApev2MuxClass ++ ++ ++GstApev2Mux ++struct _GstApev2Mux { ++ GstTagLibMux taglibmux; ++}; ++ ++ ++GstApev2MuxClass ++struct _GstApev2MuxClass { ++ GstTagLibMuxClass taglibmux_class; ++}; ++ ++ ++GST_TYPE_APEV2_MUX ++#define GST_TYPE_APEV2_MUX \ ++ (gst_apev2_mux_get_type()) ++ ++ ++GST_APEV2_MUX ++#define GST_APEV2_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_APEV2_MUX,GstApev2Mux)) ++ ++ ++GST_APEV2_MUX_CLASS ++#define GST_APEV2_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_APEV2_MUX,GstApev2MuxClass)) ++ ++ ++GST_IS_APEV2_MUX ++#define GST_IS_APEV2_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_APEV2_MUX)) ++ ++ ++GST_IS_APEV2_MUX_CLASS ++#define GST_IS_APEV2_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_APEV2_MUX)) ++ ++ ++gst_apev2_mux_get_type ++GType ++void ++ ++ ++GstId3v2Mux ++ ++ ++GstId3v2MuxClass ++ ++ ++GstId3v2Mux ++struct _GstId3v2Mux { ++ GstTagLibMux taglibmux; ++}; ++ ++ ++GstId3v2MuxClass ++struct _GstId3v2MuxClass { ++ GstTagLibMuxClass taglibmux_class; ++}; ++ ++ ++GST_TYPE_ID3V2_MUX ++#define GST_TYPE_ID3V2_MUX \ ++ (gst_id3v2_mux_get_type()) ++ ++ ++GST_ID3V2_MUX ++#define GST_ID3V2_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ID3V2_MUX,GstId3v2Mux)) ++ ++ ++GST_ID3V2_MUX_CLASS ++#define GST_ID3V2_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ID3V2_MUX,GstId3v2MuxClass)) ++ ++ ++GST_IS_ID3V2_MUX ++#define GST_IS_ID3V2_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ID3V2_MUX)) ++ ++ ++GST_IS_ID3V2_MUX_CLASS ++#define GST_IS_ID3V2_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ID3V2_MUX)) ++ ++ ++gst_id3v2_mux_get_type ++GType ++void ++ ++ ++GST_TYPE_PULSESINK ++#define GST_TYPE_PULSESINK \ ++ (gst_pulsesink_get_type()) ++ ++ ++GST_PULSESINK ++#define GST_PULSESINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PULSESINK,GstPulseSink)) ++ ++ ++GST_PULSESINK_CLASS ++#define GST_PULSESINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PULSESINK,GstPulseSinkClass)) ++ ++ ++GST_IS_PULSESINK ++#define GST_IS_PULSESINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PULSESINK)) ++ ++ ++GST_IS_PULSESINK_CLASS ++#define GST_IS_PULSESINK_CLASS(obj) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PULSESINK)) ++ ++ ++GST_PULSESINK_CAST ++#define GST_PULSESINK_CAST(obj) \ ++ ((GstPulseSink *)(obj)) ++ ++ ++GstPulseSink ++ ++ ++GstPulseSinkClass ++ ++ ++GstPulseSink ++struct _GstPulseSink ++{ ++ GstBaseAudioSink sink; ++ ++ gchar *server, *device, *stream_name; ++ gchar *device_description; ++ ++ pa_threaded_mainloop *mainloop; ++ ++ GstPulseProbe *probe; ++ ++ gdouble volume; ++ gboolean volume_set:1; ++ gboolean mute:1; ++ gboolean mute_set:1; ++ ++ gboolean pa_defer_ran:1; ++ ++ gint notify; /* atomic */ ++ ++ const gchar *pa_version; ++ ++}; ++ ++ ++GstPulseSinkClass ++struct _GstPulseSinkClass ++{ ++ GstBaseAudioSinkClass parent_class; ++}; ++ ++ ++gst_pulsesink_get_type ++GType ++void ++ ++ ++GST_TYPE_PULSESRC ++#define GST_TYPE_PULSESRC \ ++ (gst_pulsesrc_get_type()) ++ ++ ++GST_PULSESRC ++#define GST_PULSESRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PULSESRC,GstPulseSrc)) ++ ++ ++GST_PULSESRC_CLASS ++#define GST_PULSESRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PULSESRC,GstPulseSrcClass)) ++ ++ ++GST_IS_PULSESRC ++#define GST_IS_PULSESRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PULSESRC)) ++ ++ ++GST_IS_PULSESRC_CLASS ++#define GST_IS_PULSESRC_CLASS(obj) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PULSESRC)) ++ ++ ++GST_PULSESRC_CAST ++#define GST_PULSESRC_CAST(obj) \ ++ ((GstPulseSrc *)(obj)) ++ ++ ++GstPulseSrc ++ ++ ++GstPulseSrcClass ++ ++ ++GstPulseSrc ++struct _GstPulseSrc ++{ ++ GstAudioSrc src; ++ ++ gchar *server, *device; ++ ++ pa_threaded_mainloop *mainloop; ++ ++ pa_context *context; ++ pa_stream *stream; ++ ++ pa_sample_spec sample_spec; ++ ++ const void *read_buffer; ++ size_t read_buffer_length; ++ ++ gchar *device_description; ++ ++ GstPulseMixerCtrl *mixer; ++ GstPulseProbe *probe; ++ ++ gboolean corked:1; ++ gboolean operation_success:1; ++ gboolean paused:1; ++ gboolean in_read:1; ++}; ++ ++ ++GstPulseSrcClass ++struct _GstPulseSrcClass ++{ ++ GstAudioSrcClass parent_class; ++}; ++ ++ ++gst_pulsesrc_get_type ++GType ++void ++ ++ ++GST_TYPE_PULSEMIXER ++#define GST_TYPE_PULSEMIXER \ ++ (gst_pulsemixer_get_type()) ++ ++ ++GST_PULSEMIXER ++#define GST_PULSEMIXER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PULSEMIXER,GstPulseMixer)) ++ ++ ++GST_PULSEMIXER_CLASS ++#define GST_PULSEMIXER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PULSEMIXER,GstPulseMixerClass)) ++ ++ ++GST_IS_PULSEMIXER ++#define GST_IS_PULSEMIXER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PULSEMIXER)) ++ ++ ++GST_IS_PULSEMIXER_CLASS ++#define GST_IS_PULSEMIXER_CLASS(obj) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PULSEMIXER)) ++ ++ ++GstPulseMixer ++ ++ ++GstPulseMixerClass ++ ++ ++GstPulseMixer ++struct _GstPulseMixer ++{ ++ GstElement parent; ++ ++ gchar *server, *device; ++ ++ GstPulseMixerCtrl *mixer; ++ GstPulseProbe *probe; ++}; ++ ++ ++GstPulseMixerClass ++struct _GstPulseMixerClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_pulsemixer_get_type ++GType ++void ++ ++ ++GST_TYPE_SPEEX_ENC ++#define GST_TYPE_SPEEX_ENC \ ++ (gst_speex_enc_get_type()) ++ ++ ++GST_SPEEX_ENC ++#define GST_SPEEX_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPEEX_ENC,GstSpeexEnc)) ++ ++ ++GST_SPEEX_ENC_CLASS ++#define GST_SPEEX_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SPEEX_ENC,GstSpeexEncClass)) ++ ++ ++GST_IS_SPEEX_ENC ++#define GST_IS_SPEEX_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPEEX_ENC)) ++ ++ ++GST_IS_SPEEX_ENC_CLASS ++#define GST_IS_SPEEX_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SPEEX_ENC)) ++ ++ ++GstSpeexMode ++typedef enum ++{ ++ GST_SPEEX_ENC_MODE_AUTO, ++ GST_SPEEX_ENC_MODE_UWB, ++ GST_SPEEX_ENC_MODE_WB, ++ GST_SPEEX_ENC_MODE_NB ++} GstSpeexMode; ++ ++ ++GstSpeexEnc ++ ++ ++GstSpeexEncClass ++ ++ ++GstSpeexEnc ++struct _GstSpeexEnc { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad, ++ *srcpad; ++ ++ gint packet_count; ++ gint n_packets; ++ ++ SpeexBits bits; ++ SpeexHeader header; ++#ifdef SPEEX_1_0 ++ SpeexMode *speex_mode; ++#else ++ const SpeexMode *speex_mode; ++#endif ++ void *state; ++ GstSpeexMode mode; ++ GstAdapter *adapter; ++ ++ gfloat quality; ++ gint bitrate; ++ gboolean vbr; ++ gint abr; ++ gboolean vad; ++ gboolean dtx; ++ gint complexity; ++ gint nframes; ++ ++ gint lookahead; ++ ++ gint channels; ++ gint rate; ++ ++ gboolean setup; ++ gboolean header_sent; ++ ++ guint64 samples_in; ++ guint64 bytes_out; ++ ++ GstTagList *tags; ++ ++ gchar *last_message; ++ ++ gint frame_size; ++ guint64 frameno; ++ guint64 frameno_out; ++ ++ guint8 *comments; ++ gint comment_len; ++ ++ /* Timestamp and granulepos tracking */ ++ GstClockTime start_ts; ++ GstClockTime next_ts; ++ guint64 granulepos_offset; ++}; ++ ++ ++GstSpeexEncClass ++struct _GstSpeexEncClass { ++ GstElementClass parent_class; ++ ++ /* signals */ ++ void (*frame_encoded) (GstElement *element); ++}; ++ ++ ++gst_speex_enc_get_type ++GType ++void ++ ++ ++GST_TYPE_SPEEX_DEC ++#define GST_TYPE_SPEEX_DEC \ ++ (gst_speex_dec_get_type()) ++ ++ ++GST_SPEEX_DEC ++#define GST_SPEEX_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPEEX_DEC,GstSpeexDec)) ++ ++ ++GST_SPEEX_DEC_CLASS ++#define GST_SPEEX_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SPEEX_DEC,GstSpeexDecClass)) ++ ++ ++GST_IS_SPEEX_DEC ++#define GST_IS_SPEEX_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPEEX_DEC)) ++ ++ ++GST_IS_SPEEX_DEC_CLASS ++#define GST_IS_SPEEX_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SPEEX_DEC)) ++ ++ ++GstSpeexDec ++ ++ ++GstSpeexDecClass ++ ++ ++GstSpeexDec ++struct _GstSpeexDec { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ void *state; ++ SpeexStereoState *stereo; ++#ifdef SPEEX_1_0 ++ SpeexMode *mode; ++#else ++ const SpeexMode *mode; ++#endif ++ SpeexHeader *header; ++ SpeexCallback callback; ++ SpeexBits bits; ++ ++ gboolean enh; ++ ++ gint frame_size; ++ GstClockTime frame_duration; ++ guint64 packetno; ++ ++ GstSegment segment; /* STREAM LOCK */ ++}; ++ ++ ++GstSpeexDecClass ++struct _GstSpeexDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_speex_dec_get_type ++GType ++void ++ ++ ++GST_TYPE_WAVPACK_DEC ++#define GST_TYPE_WAVPACK_DEC \ ++ (gst_wavpack_dec_get_type()) ++ ++ ++GST_WAVPACK_DEC ++#define GST_WAVPACK_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVPACK_DEC,GstWavpackDec)) ++ ++ ++GST_WAVPACK_DEC_CLASS ++#define GST_WAVPACK_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVPACK_DEC,GstWavpackDecClass)) ++ ++ ++GST_IS_WAVPACK_DEC ++#define GST_IS_WAVPACK_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVPACK_DEC)) ++ ++ ++GST_IS_WAVPACK_DEC_CLASS ++#define GST_IS_WAVPACK_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVPACK_DEC)) ++ ++ ++GstWavpackDec ++ ++ ++GstWavpackDecClass ++ ++ ++GstWavpackDec ++struct _GstWavpackDec ++{ ++ GstElement element; ++ ++ /*< private > */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ WavpackContext *context; ++ WavpackStreamReader *stream_reader; ++ ++ read_id wv_id; ++ ++ GstSegment segment; /* used for clipping, TIME format */ ++ guint32 next_block_index; ++ ++ gint sample_rate; ++ gint depth; ++ gint channels; ++ gint channel_mask; ++ ++ gint error_count; ++}; ++ ++ ++GstWavpackDecClass ++struct _GstWavpackDecClass ++{ ++ GstElementClass parent; ++}; ++ ++ ++gst_wavpack_dec_get_type ++GType ++void ++ ++ ++gst_wavpack_dec_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_WAVPACK_ENC ++#define GST_TYPE_WAVPACK_ENC \ ++ (gst_wavpack_enc_get_type()) ++ ++ ++GST_WAVPACK_ENC ++#define GST_WAVPACK_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVPACK_ENC,GstWavpackEnc)) ++ ++ ++GST_WAVPACK_ENC_CLASS ++#define GST_WAVPACK_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVPACK_ENC,GstWavpackEnc)) ++ ++ ++GST_IS_WAVPACK_ENC ++#define GST_IS_WAVPACK_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVPACK_ENC)) ++ ++ ++GST_IS_WAVPACK_ENC_CLASS ++#define GST_IS_WAVPACK_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVPACK_ENC)) ++ ++ ++GstWavpackEnc ++ ++ ++GstWavpackEncClass ++ ++ ++GstWavpackEnc ++struct _GstWavpackEnc ++{ ++ GstElement element; ++ ++ /*< private > */ ++ GstPad *sinkpad, *srcpad; ++ GstPad *wvcsrcpad; ++ ++ GstFlowReturn srcpad_last_return; ++ GstFlowReturn wvcsrcpad_last_return; ++ ++ WavpackConfig *wp_config; ++ WavpackContext *wp_context; ++ ++ gint samplerate; ++ gint channels; ++ gint channel_mask; ++ gint8 channel_mapping[8]; ++ gboolean need_channel_remap; ++ gint depth; ++ ++ GstWavpackEncWriteID wv_id; ++ GstWavpackEncWriteID wvc_id; ++ ++ guint mode; ++ guint bitrate; ++ gdouble bps; ++ guint correction_mode; ++ gboolean md5; ++ GChecksum *md5_context; ++ guint extra_processing; ++ guint joint_stereo_mode; ++ ++ void *first_block; ++ int32_t first_block_size; ++ ++ GstBuffer *pending_buffer; ++ gint32 pending_offset; ++ ++ GstClockTime timestamp_offset; ++ GstClockTime next_ts; ++}; ++ ++ ++GstWavpackEncClass ++struct _GstWavpackEncClass ++{ ++ GstElementClass parent; ++}; ++ ++ ++gst_wavpack_enc_get_type ++GType ++void ++ ++ ++gst_wavpack_enc_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_WAVPACK_PARSE ++#define GST_TYPE_WAVPACK_PARSE \ ++ (gst_wavpack_parse_get_type()) ++ ++ ++GST_WAVPACK_PARSE ++#define GST_WAVPACK_PARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVPACK_PARSE,GstWavpackParse)) ++ ++ ++GST_WAVPACK_PARSE_CLASS ++#define GST_WAVPACK_PARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVPACK_PARSE,GstWavpackParseClass)) ++ ++ ++GST_IS_WAVPACK_PARSE ++#define GST_IS_WAVPACK_PARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVPACK_PARSE)) ++ ++ ++GST_IS_WAVPACK_PARSE_CLASS ++#define GST_IS_WAVPACK_PARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVPACK_PARSE)) ++ ++ ++GstWavpackParse ++ ++ ++GstWavpackParseClass ++ ++ ++GstWavpackParseIndexEntry ++ ++ ++GstWavpackParseIndexEntry ++struct _GstWavpackParseIndexEntry ++{ ++ gint64 byte_offset; /* byte offset of this chunk */ ++ gint64 sample_offset; /* first sample in this chunk */ ++ gint64 sample_offset_end; /* first sample in next chunk */ ++}; ++ ++ ++GstWavpackParse ++struct _GstWavpackParse ++{ ++ GstElement element; ++ ++ /*< private > */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ guint samplerate; ++ guint channels; ++ gint64 total_samples; ++ ++ gboolean need_newsegment; ++ gboolean discont; ++ ++ gint64 current_offset; /* byte offset on sink pad */ ++ gint64 upstream_length; /* length of file in bytes */ ++ ++ GstSegment segment; /* the currently configured segment, in ++ * samples/audio frames (DEFAULT format) */ ++ ++ GstBuffer *pending_buffer; ++ gint32 pending_offset; ++ guint32 next_block_index; ++ ++ GstAdapter *adapter; /* when operating chain-based, otherwise NULL */ ++ ++ /* List of GstWavpackParseIndexEntry structs, mapping known ++ * sample offsets to byte offsets. Is kept increasing without ++ * gaps (ie. append only and consecutive entries must always ++ * map to consecutive chunks in the file). */ ++ GSList *entries; ++ ++ /* Queued events (e.g. tag events we receive before we create the src pad) */ ++ GList *queued_events; /* STREAM_LOCK */ ++}; ++ ++ ++GstWavpackParseClass ++struct _GstWavpackParseClass ++{ ++ GstElementClass parent; ++}; ++ ++ ++gst_wavpack_parse_get_type ++GType ++void ++ ++ ++gst_wavpack_parse_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_ALPHA ++#define GST_TYPE_ALPHA \ ++ (gst_alpha_get_type()) ++ ++ ++GST_ALPHA ++#define GST_ALPHA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALPHA,GstAlpha)) ++ ++ ++GST_ALPHA_CLASS ++#define GST_ALPHA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALPHA,GstAlphaClass)) ++ ++ ++GST_IS_ALPHA ++#define GST_IS_ALPHA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALPHA)) ++ ++ ++GST_IS_ALPHA_CLASS ++#define GST_IS_ALPHA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALPHA)) ++ ++ ++GstAlpha ++ ++ ++GstAlphaClass ++ ++ ++GstAlphaMethod ++typedef enum ++{ ++ ALPHA_METHOD_SET, ++ ALPHA_METHOD_GREEN, ++ ALPHA_METHOD_BLUE, ++ ALPHA_METHOD_CUSTOM, ++} ++GstAlphaMethod; ++ ++ ++GST_CAT_DEFAULT ++#define GST_CAT_DEFAULT gst_alpha_debug ++ ++ ++GstAlpha ++struct _GstAlpha ++{ ++ GstVideoFilter parent; ++ ++ /* */ ++ ++ /* caps */ ++ GStaticMutex lock; ++ ++ GstVideoFormat in_format, out_format; ++ gint width, height; ++ gboolean in_sdtv, out_sdtv; ++ ++ /* properties */ ++ gdouble alpha; ++ ++ guint target_r; ++ guint target_g; ++ guint target_b; ++ ++ GstAlphaMethod method; ++ ++ gfloat angle; ++ gfloat noise_level; ++ guint black_sensitivity; ++ guint white_sensitivity; ++ ++ gboolean prefer_passthrough; ++ ++ /* processing function */ ++ void (*process) (const guint8 *src, guint8 *dest, gint width, gint height, GstAlpha *alpha); ++ ++ /* precalculated values for chroma keying */ ++ gint8 cb, cr; ++ gint8 kg; ++ guint8 accept_angle_tg; ++ guint8 accept_angle_ctg; ++ guint8 one_over_kc; ++ guint8 kfgy_scale; ++ guint noise_level2; ++}; ++ ++ ++GstAlphaClass ++struct _GstAlphaClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_alpha_get_type ++GType ++void ++ ++ ++GST_TYPE_ALPHA_COLOR ++#define GST_TYPE_ALPHA_COLOR \ ++ (gst_alpha_color_get_type()) ++ ++ ++GST_ALPHA_COLOR ++#define GST_ALPHA_COLOR(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALPHA_COLOR,GstAlphaColor)) ++ ++ ++GST_ALPHA_COLOR_CLASS ++#define GST_ALPHA_COLOR_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALPHA_COLOR,GstAlphaColorClass)) ++ ++ ++GST_IS_ALPHA_COLOR ++#define GST_IS_ALPHA_COLOR(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALPHA_COLOR)) ++ ++ ++GST_IS_ALPHA_COLOR_CLASS ++#define GST_IS_ALPHA_COLOR_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALPHA_COLOR)) ++ ++ ++GstAlphaColor ++ ++ ++GstAlphaColorClass ++ ++ ++GstAlphaColor ++struct _GstAlphaColor ++{ ++ GstVideoFilter parent; ++ ++ /*< private >*/ ++ /* caps */ ++ GstVideoFormat in_format, out_format; ++ gint width, height; ++ ++ void (*process) (guint8 * data, gint size, const gint * matrix); ++ const gint *matrix; ++}; ++ ++ ++GstAlphaColorClass ++struct _GstAlphaColorClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_alpha_color_get_type ++GType ++void ++ ++ ++GST_TYPE_APE_DEMUX ++#define GST_TYPE_APE_DEMUX (gst_ape_demux_get_type()) ++ ++ ++GST_APE_DEMUX ++#define GST_APE_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_APE_DEMUX,GstApeDemux)) ++ ++ ++GST_APE_DEMUX_CLASS ++#define GST_APE_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_APE_DEMUX,GstApeDemuxClass)) ++ ++ ++GST_IS_APE_DEMUX ++#define GST_IS_APE_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_APE_DEMUX)) ++ ++ ++GST_IS_APE_DEMUX_CLASS ++#define GST_IS_APE_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_APE_DEMUX)) ++ ++ ++GstApeDemux ++ ++ ++GstApeDemuxClass ++ ++ ++GstApeDemux ++struct _GstApeDemux ++{ ++ GstTagDemux tagdemux; ++}; ++ ++ ++GstApeDemuxClass ++struct _GstApeDemuxClass ++{ ++ GstTagDemuxClass parent_class; ++}; ++ ++ ++gst_ape_demux_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_AMPLIFY ++#define GST_TYPE_AUDIO_AMPLIFY (gst_audio_amplify_get_type()) ++ ++ ++GST_AUDIO_AMPLIFY ++#define GST_AUDIO_AMPLIFY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_AMPLIFY,GstAudioAmplify)) ++ ++ ++GST_IS_AUDIO_AMPLIFY ++#define GST_IS_AUDIO_AMPLIFY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_AMPLIFY)) ++ ++ ++GST_AUDIO_AMPLIFY_CLASS ++#define GST_AUDIO_AMPLIFY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_AMPLIFY,GstAudioAmplifyClass)) ++ ++ ++GST_IS_AUDIO_AMPLIFY_CLASS ++#define GST_IS_AUDIO_AMPLIFY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_AMPLIFY)) ++ ++ ++GST_AUDIO_AMPLIFY_GET_CLASS ++#define GST_AUDIO_AMPLIFY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_AMPLIFY,GstAudioAmplifyClass)) ++ ++ ++GstAudioAmplify ++ ++ ++GstAudioAmplifyClass ++ ++ ++GstAudioAmplifyProcessFunc ++void ++GstAudioAmplify *, void *, guint ++ ++ ++GstAudioAmplify ++struct _GstAudioAmplify ++{ ++ GstAudioFilter audiofilter; ++ ++ gfloat amplification; ++ ++ /* < private > */ ++ GstAudioAmplifyProcessFunc process; ++ gint clipping_method; ++ gint format; ++ gint width; ++}; ++ ++ ++GstAudioAmplifyClass ++struct _GstAudioAmplifyClass ++{ ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_amplify_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_ECHO ++#define GST_TYPE_AUDIO_ECHO (gst_audio_echo_get_type()) ++ ++ ++GST_AUDIO_ECHO ++#define GST_AUDIO_ECHO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_ECHO,GstAudioEcho)) ++ ++ ++GST_IS_AUDIO_ECHO ++#define GST_IS_AUDIO_ECHO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_ECHO)) ++ ++ ++GST_AUDIO_ECHO_CLASS ++#define GST_AUDIO_ECHO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_ECHO,GstAudioEchoClass)) ++ ++ ++GST_IS_AUDIO_ECHO_CLASS ++#define GST_IS_AUDIO_ECHO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_ECHO)) ++ ++ ++GST_AUDIO_ECHO_GET_CLASS ++#define GST_AUDIO_ECHO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_ECHO,GstAudioEchoClass)) ++ ++ ++GstAudioEcho ++ ++ ++GstAudioEchoClass ++ ++ ++GstAudioEchoProcessFunc ++void ++GstAudioEcho *, guint8 *, guint ++ ++ ++GstAudioEcho ++struct _GstAudioEcho ++{ ++ GstAudioFilter audiofilter; ++ ++ guint64 delay; ++ guint64 max_delay; ++ gfloat intensity; ++ gfloat feedback; ++ ++ /* < private > */ ++ GstAudioEchoProcessFunc process; ++ guint delay_frames; ++ guint8 *buffer; ++ guint buffer_pos; ++ guint buffer_size; ++ guint buffer_size_frames; ++}; ++ ++ ++GstAudioEchoClass ++struct _GstAudioEchoClass ++{ ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_echo_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_DYNAMIC ++#define GST_TYPE_AUDIO_DYNAMIC (gst_audio_dynamic_get_type()) ++ ++ ++GST_AUDIO_DYNAMIC ++#define GST_AUDIO_DYNAMIC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_DYNAMIC,GstAudioDynamic)) ++ ++ ++GST_IS_AUDIO_DYNAMIC ++#define GST_IS_AUDIO_DYNAMIC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_DYNAMIC)) ++ ++ ++GST_AUDIO_DYNAMIC_CLASS ++#define GST_AUDIO_DYNAMIC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_DYNAMIC,GstAudioDynamicClass)) ++ ++ ++GST_IS_AUDIO_DYNAMIC_CLASS ++#define GST_IS_AUDIO_DYNAMIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_DYNAMIC)) ++ ++ ++GST_AUDIO_DYNAMIC_GET_CLASS ++#define GST_AUDIO_DYNAMIC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_DYNAMIC,GstAudioDynamicClass)) ++ ++ ++GstAudioDynamic ++ ++ ++GstAudioDynamicClass ++ ++ ++GstAudioDynamicProcessFunc ++void ++GstAudioDynamic *, guint8 *, guint ++ ++ ++GstAudioDynamic ++struct _GstAudioDynamic ++{ ++ GstAudioFilter audiofilter; ++ ++ gfloat degree; ++ ++ /* < private > */ ++ GstAudioDynamicProcessFunc process; ++ gint characteristics; ++ gint mode; ++ gfloat threshold; ++ gfloat ratio; ++}; ++ ++ ++GstAudioDynamicClass ++struct _GstAudioDynamicClass ++{ ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_dynamic_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_INVERT ++#define GST_TYPE_AUDIO_INVERT (gst_audio_invert_get_type()) ++ ++ ++GST_AUDIO_INVERT ++#define GST_AUDIO_INVERT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_INVERT,GstAudioInvert)) ++ ++ ++GST_IS_AUDIO_INVERT ++#define GST_IS_AUDIO_INVERT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_INVERT)) ++ ++ ++GST_AUDIO_INVERT_CLASS ++#define GST_AUDIO_INVERT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_INVERT,GstAudioInvertClass)) ++ ++ ++GST_IS_AUDIO_INVERT_CLASS ++#define GST_IS_AUDIO_INVERT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_INVERT)) ++ ++ ++GST_AUDIO_INVERT_GET_CLASS ++#define GST_AUDIO_INVERT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_INVERT,GstAudioInvertClass)) ++ ++ ++GstAudioInvert ++ ++ ++GstAudioInvertClass ++ ++ ++GstAudioInvertProcessFunc ++void ++GstAudioInvert *, guint8 *, guint ++ ++ ++GstAudioInvert ++struct _GstAudioInvert ++{ ++ GstAudioFilter audiofilter; ++ ++ gfloat degree; ++ ++ /* < private > */ ++ GstAudioInvertProcessFunc process; ++}; ++ ++ ++GstAudioInvertClass ++struct _GstAudioInvertClass ++{ ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_invert_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_KARAOKE ++#define GST_TYPE_AUDIO_KARAOKE (gst_audio_karaoke_get_type()) ++ ++ ++GST_AUDIO_KARAOKE ++#define GST_AUDIO_KARAOKE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_KARAOKE,GstAudioKaraoke)) ++ ++ ++GST_IS_AUDIO_KARAOKE ++#define GST_IS_AUDIO_KARAOKE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_KARAOKE)) ++ ++ ++GST_AUDIO_KARAOKE_CLASS ++#define GST_AUDIO_KARAOKE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_KARAOKE,GstAudioKaraokeClass)) ++ ++ ++GST_IS_AUDIO_KARAOKE_CLASS ++#define GST_IS_AUDIO_KARAOKE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_KARAOKE)) ++ ++ ++GST_AUDIO_KARAOKE_GET_CLASS ++#define GST_AUDIO_KARAOKE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_KARAOKE,GstAudioKaraokeClass)) ++ ++ ++GstAudioKaraoke ++ ++ ++GstAudioKaraokeClass ++ ++ ++GstAudioKaraokeProcessFunc ++void ++GstAudioKaraoke *, guint8 *, guint ++ ++ ++GstAudioKaraoke ++struct _GstAudioKaraoke ++{ ++ GstAudioFilter audiofilter; ++ ++ gint channels; ++ gint rate; ++ ++ /* properties */ ++ gfloat level; ++ gfloat mono_level; ++ gfloat filter_band; ++ gfloat filter_width; ++ ++ /* filter coef */ ++ gfloat A, B, C; ++ gfloat y1, y2; ++ ++ /* < private > */ ++ GstAudioKaraokeProcessFunc process; ++}; ++ ++ ++GstAudioKaraokeClass ++struct _GstAudioKaraokeClass ++{ ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_karaoke_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_PANORAMA ++#define GST_TYPE_AUDIO_PANORAMA (gst_audio_panorama_get_type()) ++ ++ ++GST_AUDIO_PANORAMA ++#define GST_AUDIO_PANORAMA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_PANORAMA,GstAudioPanorama)) ++ ++ ++GST_IS_AUDIO_PANORAMA ++#define GST_IS_AUDIO_PANORAMA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_PANORAMA)) ++ ++ ++GST_AUDIO_PANORAMA_CLASS ++#define GST_AUDIO_PANORAMA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_PANORAMA,GstAudioPanoramaClass)) ++ ++ ++GST_IS_AUDIO_PANORAMA_CLASS ++#define GST_IS_AUDIO_PANORAMA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_PANORAMA)) ++ ++ ++GST_AUDIO_PANORAMA_GET_CLASS ++#define GST_AUDIO_PANORAMA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_PANORAMA,GstAudioPanoramaClass)) ++ ++ ++GstAudioPanorama ++ ++ ++GstAudioPanoramaClass ++ ++ ++GstAudioPanoramaProcessFunc ++void ++GstAudioPanorama*, guint8*, guint8*, guint ++ ++ ++GstAudioPanorama ++struct _GstAudioPanorama { ++ GstBaseTransform element; ++ ++ gfloat panorama; ++ ++ /* < private > */ ++ GstAudioPanoramaProcessFunc process; ++ gint channels; ++ gboolean format_float; ++ gint width; ++ gint method; ++}; ++ ++ ++GstAudioPanoramaClass ++struct _GstAudioPanoramaClass { ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_audio_panorama_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_CHEB_LIMIT ++#define GST_TYPE_AUDIO_CHEB_LIMIT (gst_audio_cheb_limit_get_type()) ++ ++ ++GST_AUDIO_CHEB_LIMIT ++#define GST_AUDIO_CHEB_LIMIT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_CHEB_LIMIT,GstAudioChebLimit)) ++ ++ ++GST_IS_AUDIO_CHEB_LIMIT ++#define GST_IS_AUDIO_CHEB_LIMIT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_CHEB_LIMIT)) ++ ++ ++GST_AUDIO_CHEB_LIMIT_CLASS ++#define GST_AUDIO_CHEB_LIMIT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_CHEB_LIMIT,GstAudioChebLimitClass)) ++ ++ ++GST_IS_AUDIO_CHEB_LIMIT_CLASS ++#define GST_IS_AUDIO_CHEB_LIMIT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_CHEB_LIMIT)) ++ ++ ++GST_AUDIO_CHEB_LIMIT_GET_CLASS ++#define GST_AUDIO_CHEB_LIMIT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_CHEB_LIMIT,GstAudioChebLimitClass)) ++ ++ ++GstAudioChebLimit ++ ++ ++GstAudioChebLimitClass ++ ++ ++GstAudioChebLimit ++struct _GstAudioChebLimit ++{ ++ GstAudioFXBaseIIRFilter parent; ++ ++ gint mode; ++ gint type; ++ gint poles; ++ gfloat cutoff; ++ gfloat ripple; ++ ++ /* < private > */ ++ GMutex *lock; ++}; ++ ++ ++GstAudioChebLimitClass ++struct _GstAudioChebLimitClass ++{ ++ GstAudioFXBaseIIRFilterClass parent; ++}; ++ ++ ++gst_audio_cheb_limit_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_CHEB_BAND ++#define GST_TYPE_AUDIO_CHEB_BAND (gst_audio_cheb_band_get_type()) ++ ++ ++GST_AUDIO_CHEB_BAND ++#define GST_AUDIO_CHEB_BAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_CHEB_BAND,GstAudioChebBand)) ++ ++ ++GST_IS_AUDIO_CHEB_BAND ++#define GST_IS_AUDIO_CHEB_BAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_CHEB_BAND)) ++ ++ ++GST_AUDIO_CHEB_BAND_CLASS ++#define GST_AUDIO_CHEB_BAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_AUDIO_CHEB_BAND,GstAudioChebBandClass)) ++ ++ ++GST_IS_AUDIO_CHEB_BAND_CLASS ++#define GST_IS_AUDIO_CHEB_BAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_AUDIO_CHEB_BAND)) ++ ++ ++GST_AUDIO_CHEB_BAND_GET_CLASS ++#define GST_AUDIO_CHEB_BAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_AUDIO_CHEB_BAND,GstAudioChebBandClass)) ++ ++ ++GstAudioChebBand ++ ++ ++GstAudioChebBandClass ++ ++ ++GstAudioChebBand ++struct _GstAudioChebBand ++{ ++ GstAudioFXBaseIIRFilter parent; ++ ++ gint mode; ++ gint type; ++ gint poles; ++ gfloat lower_frequency; ++ gfloat upper_frequency; ++ gfloat ripple; ++ ++ /* < private > */ ++ GMutex *lock; ++}; ++ ++ ++GstAudioChebBandClass ++struct _GstAudioChebBandClass ++{ ++ GstAudioFXBaseIIRFilterClass parent; ++}; ++ ++ ++gst_audio_cheb_band_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_IIR_FILTER ++#define GST_TYPE_AUDIO_IIR_FILTER \ ++ (gst_audio_iir_filter_get_type()) ++ ++ ++GST_AUDIO_IIR_FILTER ++#define GST_AUDIO_IIR_FILTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_IIR_FILTER,GstAudioIIRFilter)) ++ ++ ++GST_AUDIO_IIR_FILTER_CLASS ++#define GST_AUDIO_IIR_FILTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_IIR_FILTER,GstAudioIIRFilterClass)) ++ ++ ++GST_IS_AUDIO_IIR_FILTER ++#define GST_IS_AUDIO_IIR_FILTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_IIR_FILTER)) ++ ++ ++GST_IS_AUDIO_IIR_FILTER_CLASS ++#define GST_IS_AUDIO_IIR_FILTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_IIR_FILTER)) ++ ++ ++GstAudioIIRFilter ++ ++ ++GstAudioIIRFilterClass ++ ++ ++GstAudioIIRFilter ++struct _GstAudioIIRFilter { ++ GstAudioFXBaseIIRFilter parent; ++ ++ GValueArray *a, *b; ++ ++ /* < private > */ ++ GMutex *lock; ++ gint rate; ++}; ++ ++ ++GstAudioIIRFilterClass ++struct _GstAudioIIRFilterClass { ++ GstAudioFXBaseIIRFilterClass parent; ++ ++ void (*rate_changed) (GstElement * element, gint rate); ++}; ++ ++ ++gst_audio_iir_filter_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_WSINC_BAND ++#define GST_TYPE_AUDIO_WSINC_BAND \ ++ (gst_audio_wsincband_get_type()) ++ ++ ++GST_AUDIO_WSINC_BAND ++#define GST_AUDIO_WSINC_BAND(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_WSINC_BAND,GstAudioWSincBand)) ++ ++ ++GST_AUDIO_WSINC_BAND_CLASS ++#define GST_AUDIO_WSINC_BAND_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_WSINC_BAND,GstAudioWSincBandClass)) ++ ++ ++GST_IS_AUDIO_WSINC_BAND ++#define GST_IS_AUDIO_WSINC_BAND(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_WSINC_BAND)) ++ ++ ++GST_IS_AUDIO_WSINC_BAND_CLASS ++#define GST_IS_AUDIO_WSINC_BAND_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_WSINC_BAND)) ++ ++ ++GstAudioWSincBand ++ ++ ++GstAudioWSincBandClass ++ ++ ++GstAudioWSincBand ++struct _GstAudioWSincBand { ++ GstAudioFXBaseFIRFilter parent; ++ ++ gint mode; ++ gint window; ++ gfloat lower_frequency, upper_frequency; ++ gint kernel_length; /* length of the filter kernel */ ++ ++ /* < private > */ ++ GMutex *lock; ++}; ++ ++ ++GstAudioWSincBandClass ++struct _GstAudioWSincBandClass { ++ GstAudioFilterClass parent; ++}; ++ ++ ++gst_audio_wsincband_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_WSINC_LIMIT ++#define GST_TYPE_AUDIO_WSINC_LIMIT \ ++ (gst_audio_wsinclimit_get_type()) ++ ++ ++GST_AUDIO_WSINC_LIMIT ++#define GST_AUDIO_WSINC_LIMIT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_WSINC_LIMIT,GstAudioWSincLimit)) ++ ++ ++GST_AUDIO_WSINC_LIMIT_CLASS ++#define GST_AUDIO_WSINC_LIMIT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_WSINC_LIMIT,GstAudioWSincLimitClass)) ++ ++ ++GST_IS_AUDIO_WSINC_LIMIT ++#define GST_IS_AUDIO_WSINC_LIMIT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_WSINC_LIMIT)) ++ ++ ++GST_IS_AUDIO_WSINC_LIMIT_CLASS ++#define GST_IS_AUDIO_WSINC_LIMIT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_WSINC_LIMIT)) ++ ++ ++GstAudioWSincLimit ++ ++ ++GstAudioWSincLimitClass ++ ++ ++GstAudioWSincLimit ++struct _GstAudioWSincLimit { ++ GstAudioFXBaseFIRFilter parent; ++ ++ gint mode; ++ gint window; ++ gfloat cutoff; ++ gint kernel_length; ++ ++ /* < private > */ ++ GMutex *lock; ++}; ++ ++ ++GstAudioWSincLimitClass ++struct _GstAudioWSincLimitClass { ++ GstAudioFXBaseFIRFilterClass parent; ++}; ++ ++ ++gst_audio_wsinclimit_get_type ++GType ++void ++ ++ ++GST_TYPE_AUDIO_FIR_FILTER ++#define GST_TYPE_AUDIO_FIR_FILTER \ ++ (gst_audio_fir_filter_get_type()) ++ ++ ++GST_AUDIO_FIR_FILTER ++#define GST_AUDIO_FIR_FILTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_FIR_FILTER,GstAudioFIRFilter)) ++ ++ ++GST_AUDIO_FIR_FILTER_CLASS ++#define GST_AUDIO_FIR_FILTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_FIR_FILTER,GstAudioFIRFilterClass)) ++ ++ ++GST_IS_AUDIO_FIR_FILTER ++#define GST_IS_AUDIO_FIR_FILTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_FIR_FILTER)) ++ ++ ++GST_IS_AUDIO_FIR_FILTER_CLASS ++#define GST_IS_AUDIO_FIR_FILTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_FIR_FILTER)) ++ ++ ++GstAudioFIRFilter ++ ++ ++GstAudioFIRFilterClass ++ ++ ++GstAudioFIRFilter ++struct _GstAudioFIRFilter { ++ GstAudioFXBaseFIRFilter parent; ++ ++ GValueArray *kernel; ++ guint64 latency; ++ ++ /* < private > */ ++ GMutex *lock; ++ gint rate; ++}; ++ ++ ++GstAudioFIRFilterClass ++struct _GstAudioFIRFilterClass { ++ GstAudioFXBaseFIRFilterClass parent; ++ ++ void (*rate_changed) (GstElement * element, gint rate); ++}; ++ ++ ++gst_audio_fir_filter_get_type ++GType ++void ++ ++ ++GST_TYPE_AU_PARSE ++#define GST_TYPE_AU_PARSE \ ++ (gst_au_parse_get_type()) ++ ++ ++GST_AU_PARSE ++#define GST_AU_PARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AU_PARSE,GstAuParse)) ++ ++ ++GST_AU_PARSE_CLASS ++#define GST_AU_PARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AU_PARSE,GstAuParseClass)) ++ ++ ++GST_IS_AU_PARSE ++#define GST_IS_AU_PARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AU_PARSE)) ++ ++ ++GST_IS_AU_PARSE_CLASS ++#define GST_IS_AU_PARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AU_PARSE)) ++ ++ ++GstAuParse ++ ++ ++GstAuParseClass ++ ++ ++GstAuParse ++struct _GstAuParse { ++ GstElement element; ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstCaps *src_caps; ++ ++ GstAdapter *adapter; ++ ++ /* GstSegment segment; */ ++ ++ gint64 offset; /* where sample data starts */ ++ gint64 buffer_offset; ++ guint sample_size; ++ guint encoding; ++ guint samplerate; ++ guint endianness; ++ guint channels; ++}; ++ ++ ++GstAuParseClass ++struct _GstAuParseClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_au_parse_get_type ++GType ++void ++ ++ ++GST_TYPE_AUTO_AUDIO_SINK ++#define GST_TYPE_AUTO_AUDIO_SINK \ ++ (gst_auto_audio_sink_get_type ()) ++ ++ ++GST_AUTO_AUDIO_SINK ++#define GST_AUTO_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AUTO_AUDIO_SINK, \ ++ GstAutoAudioSink)) ++ ++ ++GST_AUTO_AUDIO_SINK_CLASS ++#define GST_AUTO_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AUTO_AUDIO_SINK, \ ++ GstAutoAudioSinkClass)) ++ ++ ++GST_IS_AUTO_AUDIO_SINK ++#define GST_IS_AUTO_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AUTO_AUDIO_SINK)) ++ ++ ++GST_IS_AUTO_AUDIO_SINK_CLASS ++#define GST_IS_AUTO_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AUTO_AUDIO_SINK)) ++ ++ ++GstAutoAudioSink ++typedef struct _GstAutoAudioSink { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ GstPad *pad; ++ GstElement *kid; ++ GstCaps *filter_caps; ++} GstAutoAudioSink; ++ ++ ++GstAutoAudioSinkClass ++typedef struct _GstAutoAudioSinkClass { ++ GstBinClass parent_class; ++} GstAutoAudioSinkClass; ++ ++ ++gst_auto_audio_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_AUTO_AUDIO_SRC ++#define GST_TYPE_AUTO_AUDIO_SRC \ ++ (gst_auto_audio_src_get_type ()) ++ ++ ++GST_AUTO_AUDIO_SRC ++#define GST_AUTO_AUDIO_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AUTO_AUDIO_SRC, \ ++ GstAutoAudioSrc)) ++ ++ ++GST_AUTO_AUDIO_SRC_CLASS ++#define GST_AUTO_AUDIO_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AUTO_AUDIO_SRC, \ ++ GstAutoAudioSrcClass)) ++ ++ ++GST_IS_AUTO_AUDIO_SRC ++#define GST_IS_AUTO_AUDIO_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AUTO_AUDIO_SRC)) ++ ++ ++GST_IS_AUTO_AUDIO_SRC_CLASS ++#define GST_IS_AUTO_AUDIO_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AUTO_AUDIO_SRC)) ++ ++ ++GstAutoAudioSrc ++typedef struct _GstAutoAudioSrc { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ GstPad *pad; ++ GstElement *kid; ++ GstCaps *filter_caps; ++} GstAutoAudioSrc; ++ ++ ++GstAutoAudioSrcClass ++typedef struct _GstAutoAudioSrcClass { ++ GstBinClass parent_class; ++} GstAutoAudioSrcClass; ++ ++ ++gst_auto_audio_src_get_type ++GType ++void ++ ++ ++GST_TYPE_AUTO_VIDEO_SINK ++#define GST_TYPE_AUTO_VIDEO_SINK \ ++ (gst_auto_video_sink_get_type ()) ++ ++ ++GST_AUTO_VIDEO_SINK ++#define GST_AUTO_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AUTO_VIDEO_SINK, \ ++ GstAutoVideoSink)) ++ ++ ++GST_AUTO_VIDEO_SINK_CLASS ++#define GST_AUTO_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AUTO_VIDEO_SINK, \ ++ GstAutoVideoSinkClass)) ++ ++ ++GST_IS_AUTO_VIDEO_SINK ++#define GST_IS_AUTO_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AUTO_VIDEO_SINK)) ++ ++ ++GST_IS_AUTO_VIDEO_SINK_CLASS ++#define GST_IS_AUTO_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AUTO_VIDEO_SINK)) ++ ++ ++GstAutoVideoSink ++typedef struct _GstAutoVideoSink { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ GstPad *pad; ++ GstElement *kid; ++ GstCaps *filter_caps; ++} GstAutoVideoSink; ++ ++ ++GstAutoVideoSinkClass ++typedef struct _GstAutoVideoSinkClass { ++ GstBinClass parent_class; ++} GstAutoVideoSinkClass; ++ ++ ++gst_auto_video_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_AUTO_VIDEO_SRC ++#define GST_TYPE_AUTO_VIDEO_SRC \ ++ (gst_auto_video_src_get_type ()) ++ ++ ++GST_AUTO_VIDEO_SRC ++#define GST_AUTO_VIDEO_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AUTO_VIDEO_SRC, \ ++ GstAutoVideoSrc)) ++ ++ ++GST_AUTO_VIDEO_SRC_CLASS ++#define GST_AUTO_VIDEO_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AUTO_VIDEO_SRC, \ ++ GstAutoVideoSrcClass)) ++ ++ ++GST_IS_AUTO_VIDEO_SRC ++#define GST_IS_AUTO_VIDEO_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AUTO_VIDEO_SRC)) ++ ++ ++GST_IS_AUTO_VIDEO_SRC_CLASS ++#define GST_IS_AUTO_VIDEO_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AUTO_VIDEO_SRC)) ++ ++ ++GstAutoVideoSrc ++typedef struct _GstAutoVideoSrc { ++ GstBin parent; ++ ++ /* explicit pointers to stuff used */ ++ GstPad *pad; ++ GstElement *kid; ++ GstCaps *filter_caps; ++} GstAutoVideoSrc; ++ ++ ++GstAutoVideoSrcClass ++typedef struct _GstAutoVideoSrcClass { ++ GstBinClass parent_class; ++} GstAutoVideoSrcClass; ++ ++ ++gst_auto_video_src_get_type ++GType ++void ++ ++ ++GST_TYPE_AVI_DEMUX ++#define GST_TYPE_AVI_DEMUX \ ++ (gst_avi_demux_get_type ()) ++ ++ ++GST_AVI_DEMUX ++#define GST_AVI_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AVI_DEMUX, GstAviDemux)) ++ ++ ++GST_AVI_DEMUX_CLASS ++#define GST_AVI_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AVI_DEMUX, GstAviDemuxClass)) ++ ++ ++GST_IS_AVI_DEMUX ++#define GST_IS_AVI_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AVI_DEMUX)) ++ ++ ++GST_IS_AVI_DEMUX_CLASS ++#define GST_IS_AVI_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AVI_DEMUX)) ++ ++ ++GST_AVI_DEMUX_MAX_STREAMS ++#define GST_AVI_DEMUX_MAX_STREAMS 16 ++ ++ ++CHUNKID_TO_STREAMNR ++#define CHUNKID_TO_STREAMNR(chunkid) \ ++ ((((chunkid) & 0xff) - '0') * 10 + \ ++ (((chunkid) >> 8) & 0xff) - '0') ++ ++ ++GstAviIndexEntry ++typedef struct { ++ guint32 flags; ++ guint32 size; /* bytes of the data */ ++ guint64 offset; /* data offset in file */ ++ guint64 total; /* total bytes before */ ++} GstAviIndexEntry; ++ ++ ++GstAviStream ++typedef struct { ++ /* index of this streamcontext */ ++ guint num; ++ ++ /* pad*/ ++ GstPad *pad; ++ gboolean exposed; ++ ++ /* stream info and headers */ ++ gst_riff_strh *strh; ++ union { ++ gst_riff_strf_vids *vids; ++ gst_riff_strf_auds *auds; ++ gst_riff_strf_iavs *iavs; ++ gpointer data; ++ } strf; ++ GstBuffer *extradata, *initdata; ++ gchar *name; ++ ++ /* the start/step/stop entries */ ++ guint start_entry; ++ guint step_entry; ++ guint stop_entry; ++ ++ /* current index entry */ ++ guint current_entry; ++ /* position (byte, frame, time) for current_entry */ ++ guint current_total; ++ GstClockTime current_timestamp; ++ GstClockTime current_ts_end; ++ guint64 current_offset; ++ guint64 current_offset_end; ++ ++ GstFlowReturn last_flow; ++ gboolean discont; ++ ++ /* stream length */ ++ guint64 total_bytes; ++ guint32 total_blocks; ++ guint n_keyframes; ++ /* stream length according to index */ ++ GstClockTime idx_duration; ++ /* stream length according to header */ ++ GstClockTime hdr_duration; ++ /* stream length based on header/index */ ++ GstClockTime duration; ++ ++ /* VBR indicator */ ++ gboolean is_vbr; ++ ++ /* openDML support (for files >4GB) */ ++ gboolean superindex; ++ guint64 *indexes; ++ ++ /* new indexes */ ++ GstAviIndexEntry *index; /* array with index entries */ ++ guint idx_n; /* number of entries */ ++ guint idx_max; /* max allocated size of entries */ ++ ++ GstTagList *taglist; ++ ++ gint index_id; ++} GstAviStream; ++ ++ ++GstAviDemuxState ++typedef enum { ++ GST_AVI_DEMUX_START, ++ GST_AVI_DEMUX_HEADER, ++ GST_AVI_DEMUX_MOVI, ++ GST_AVI_DEMUX_SEEK, ++} GstAviDemuxState; ++ ++ ++GstAviDemuxHeaderState ++typedef enum { ++ GST_AVI_DEMUX_HEADER_TAG_LIST, ++ GST_AVI_DEMUX_HEADER_AVIH, ++ GST_AVI_DEMUX_HEADER_ELEMENTS, ++ GST_AVI_DEMUX_HEADER_INFO, ++ GST_AVI_DEMUX_HEADER_JUNK, ++ GST_AVI_DEMUX_HEADER_DATA ++} GstAviDemuxHeaderState; ++ ++ ++GstAviDemux ++typedef struct _GstAviDemux { ++ GstElement parent; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ ++ /* AVI decoding state */ ++ GstAviDemuxState state; ++ GstAviDemuxHeaderState header_state; ++ guint64 offset; ++ gboolean abort_buffering; ++ ++ /* when we loaded the indexes */ ++ gboolean have_index; ++ /* index offset in the file */ ++ guint64 index_offset; ++ ++ /* streams */ ++ GstAviStream stream[GST_AVI_DEMUX_MAX_STREAMS]; ++ guint num_streams; ++ guint num_v_streams; ++ guint num_a_streams; ++ guint num_t_streams; /* subtitle text streams */ ++ ++ guint main_stream; /* used for seeking */ ++ ++ /* for streaming mode */ ++ gboolean streaming; ++ gboolean have_eos; ++ GstAdapter *adapter; ++ guint todrop; ++ ++ /* some stream info for length */ ++ gst_riff_avih *avih; ++ GstClockTime duration; ++ ++ /* segment in TIME */ ++ GstSegment segment; ++ gboolean segment_running; ++ ++ /* pending tags/events */ ++ GstEvent *seg_event; ++ GstTagList *globaltags; ++ gboolean got_tags; ++ ++ /* gst index support */ ++ GstIndex *element_index; ++ gint index_id; ++ gboolean seekable; ++ ++ guint64 first_movi_offset; ++ guint64 idx1_offset; /* offset in file of list/chunk after movi */ ++ GstEvent *seek_event; ++ ++ gboolean building_index; ++ guint odml_stream; ++ guint odml_subidx; ++ guint64 *odml_subidxs; ++ ++ guint64 seek_kf_offset; /* offset of the keyframe to which we want to seek */ ++} GstAviDemux; ++ ++ ++GstAviDemuxClass ++typedef struct _GstAviDemuxClass { ++ GstElementClass parent_class; ++} GstAviDemuxClass; ++ ++ ++gst_avi_demux_get_type ++GType ++void ++ ++ ++GST_TYPE_AVI_MUX ++#define GST_TYPE_AVI_MUX \ ++ (gst_avi_mux_get_type()) ++ ++ ++GST_AVI_MUX ++#define GST_AVI_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AVI_MUX,GstAviMux)) ++ ++ ++GST_AVI_MUX_CLASS ++#define GST_AVI_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AVI_MUX,GstAviMuxClass)) ++ ++ ++GST_IS_AVI_MUX ++#define GST_IS_AVI_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AVI_MUX)) ++ ++ ++GST_IS_AVI_MUX_CLASS ++#define GST_IS_AVI_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AVI_MUX)) ++ ++ ++GST_AVI_INDEX_OF_INDEXES ++#define GST_AVI_INDEX_OF_INDEXES 0 ++ ++ ++GST_AVI_INDEX_OF_CHUNKS ++#define GST_AVI_INDEX_OF_CHUNKS 1 ++ ++ ++GST_AVI_SUPERINDEX_COUNT ++#define GST_AVI_SUPERINDEX_COUNT 32 ++ ++ ++GST_AVI_MAX_SIZE ++#define GST_AVI_MAX_SIZE 0x40000000 ++ ++ ++gst_avi_superindex_entry ++typedef struct _gst_avi_superindex_entry { ++ guint64 offset; ++ guint32 size; ++ guint32 duration; ++} gst_avi_superindex_entry; ++ ++ ++gst_riff_strh_full ++typedef struct _gst_riff_strh_full { ++ gst_riff_strh parent; ++ /* rcFrame, RECT structure (struct of 4 shorts) */ ++ gint16 left; ++ gint16 top; ++ gint16 right; ++ gint16 bottom; ++} gst_riff_strh_full; ++ ++ ++GstAviPad ++ ++ ++GstAviMux ++ ++ ++GstAviMuxClass ++ ++ ++GstAviPadHook ++GstFlowReturn ++GstAviMux * avi, GstAviPad * avipad, ++ GstBuffer * buffer ++ ++ ++GstAviPad ++struct _GstAviPad { ++ /* do not extend, link to it */ ++ /* is NULL if original sink request pad has been removed */ ++ GstCollectData *collect; ++ ++ /* type */ ++ gboolean is_video; ++ gboolean connected; ++ ++ /* chunk tag */ ++ gchar *tag; ++ ++ /* stream header */ ++ gst_riff_strh hdr; ++ ++ /* odml super indexes */ ++ gst_avi_superindex_entry idx[GST_AVI_SUPERINDEX_COUNT]; ++ gint idx_index; ++ gchar *idx_tag; ++ ++ /* stream specific hook */ ++ GstAviPadHook hook; ++}; ++ ++ ++GstAviVideoPad ++typedef struct _GstAviVideoPad { ++ GstAviPad parent; ++ ++ /* stream format */ ++ gst_riff_strf_vids vids; ++ /* extra data */ ++ GstBuffer *vids_codec_data; ++ /* ODML video properties */ ++ gst_riff_vprp vprp; ++ ++ GstBuffer *prepend_buffer; ++ ++} GstAviVideoPad; ++ ++ ++GstAviAudioPad ++typedef struct _GstAviAudioPad { ++ GstAviPad parent; ++ ++ /* stream format */ ++ gst_riff_strf_auds auds; ++ /* audio info for bps calculation */ ++ guint32 audio_size; ++ guint64 audio_time; ++ ++ /* counts the number of samples to put in indx chunk ++ * useful for raw audio where usually there are more than ++ * 1 sample in each GstBuffer */ ++ gint samples; ++ ++ /* extra data */ ++ GstBuffer *auds_codec_data; ++} GstAviAudioPad; ++ ++ ++GstAviCollectData ++typedef struct _GstAviCollectData { ++ /* extend the CollectData */ ++ GstCollectData collect; ++ ++ GstAviPad *avipad; ++} GstAviCollectData; ++ ++ ++GstAviMux ++struct _GstAviMux { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *srcpad; ++ /* sinkpads, video first */ ++ GSList *sinkpads; ++ /* video restricted to 1 pad */ ++ guint video_pads, audio_pads; ++ GstCollectPads *collect; ++ GstPadEventFunction collect_event; ++ ++ /* the AVI header */ ++ /* still some single stream video data in mux struct */ ++ gst_riff_avih avi_hdr; ++ /* total number of (video) frames */ ++ guint32 total_frames; ++ /* amount of total data (bytes) */ ++ guint64 total_data; ++ /* amount of data (bytes) in the AVI/AVIX block; ++ * actually the movi list, so counted from and including the movi tag */ ++ guint32 data_size, datax_size; ++ /* num (video) frames in the AVI/AVIX block */ ++ guint32 num_frames, numx_frames; ++ /* size of hdrl list, including tag as usual */ ++ ++ /* total size of extra codec data */ ++ guint32 codec_data_size; ++ /* state info */ ++ gboolean write_header; ++ gboolean restart; ++ ++ /* tags */ ++ GstTagList *tags_snap; ++ ++ /* information about the AVI index ('idx') */ ++ gst_riff_index_entry *idx; ++ gint idx_index, idx_count; ++ /* offset of *chunk* (relative to a base offset); entered in the index */ ++ guint32 idx_offset; ++ /* size of idx1 chunk (including! chunk header and size bytes) */ ++ guint32 idx_size; ++ ++ /* are we a big file already? */ ++ gboolean is_bigfile; ++ guint64 avix_start; ++ ++ /* whether to use "large AVI files" or just stick to small indexed files */ ++ gboolean enable_large_avi; ++}; ++ ++ ++GstAviMuxClass ++struct _GstAviMuxClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_avi_mux_get_type ++GType ++void ++ ++ ++GstAviSubtitle ++ ++ ++GstAviSubtitleClass ++ ++ ++GST_TYPE_AVI_SUBTITLE ++#define GST_TYPE_AVI_SUBTITLE (gst_avi_subtitle_get_type ()) ++ ++ ++GST_AVI_SUBTITLE ++#define GST_AVI_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_AVI_SUBTITLE, GstAviSubtitle)) ++ ++ ++GST_AVI_SUBTITLE_CLASS ++#define GST_AVI_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_AVI_SUBTITLE, GstAviSubtitleClass)) ++ ++ ++GST_IS_AVI_SUBTITLE ++#define GST_IS_AVI_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_AVI_SUBTITLE)) ++ ++ ++GST_IS_AVI_SUBTITLE_CLASS ++#define GST_IS_AVI_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_AVI_SUBTITLE)) ++ ++ ++GST_AVI_SUBTITLE_GET_CLASS ++#define GST_AVI_SUBTITLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_AVI_SUBTITLE, GstAviSubtitleClass)) ++ ++ ++gst_avi_subtitle_get_type ++GType ++void ++ ++ ++GstAviSubtitle ++struct _GstAviSubtitle ++{ ++ GstElement parent; ++ ++ GstPad *src; ++ GstPad *sink; ++ ++ GstBuffer *subfile; /* the complete subtitle file in one buffer */ ++}; ++ ++ ++GstAviSubtitleClass ++struct _GstAviSubtitleClass ++{ ++ GstElementClass parent; ++}; ++ ++ ++GST_TYPE_CUTTER ++#define GST_TYPE_CUTTER \ ++ (gst_cutter_get_type()) ++ ++ ++GST_CUTTER ++#define GST_CUTTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CUTTER,GstCutter)) ++ ++ ++GST_CUTTER_CLASS ++#define GST_CUTTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CUTTER,GstCutterClass)) ++ ++ ++GST_IS_CUTTER ++#define GST_IS_CUTTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CUTTER)) ++ ++ ++GST_IS_CUTTER_CLASS ++#define GST_IS_CUTTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CUTTER)) ++ ++ ++GstCutter ++ ++ ++GstCutterClass ++ ++ ++GstCutter ++struct _GstCutter ++{ ++ GstElement element; ++ ++ GstPad *sinkpad, *srcpad; ++ ++ double threshold_level; /* level below which to cut */ ++ double threshold_length; /* how long signal has to remain ++ * below this level before cutting */ ++ ++ double silent_run_length; /* how long has it been below threshold ? */ ++ gboolean silent; ++ gboolean silent_prev; ++ ++ double pre_length; /* how long can the pre-record buffer be ? */ ++ double pre_run_length; /* how long is it currently ? */ ++ GList *pre_buffer; /* list of GstBuffers in pre-record buffer */ ++ gboolean leaky; /* do we leak an overflowing prebuffer ? */ ++ ++ gboolean have_caps; /* did we get the needed caps yet ? */ ++ gint width; /* bit width of data */ ++ long max_sample; /* maximum sample value */ ++}; ++ ++ ++GstCutterClass ++struct _GstCutterClass ++{ ++ GstElementClass parent_class; ++ void (*cut_start) (GstCutter* filter); ++ void (*cut_stop) (GstCutter* filter); ++}; ++ ++ ++gst_cutter_get_type ++GType ++void ++ ++ ++GST_TYPE_CAPS_SETTER ++#define GST_TYPE_CAPS_SETTER \ ++ (gst_caps_setter_get_type()) ++ ++ ++GST_CAPS_SETTER ++#define GST_CAPS_SETTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CAPS_SETTER,GstCapsSetter)) ++ ++ ++GST_CAPS_SETTER_CLASS ++#define GST_CAPS_SETTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CAPS_SETTER,GstCapsSetterClass)) ++ ++ ++GST_IS_CAPS_SETTER ++#define GST_IS_CAPS_SETTER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CAPS_SETTER)) ++ ++ ++GST_IS_CAPS_SETTER_CLASS ++#define GST_IS_CAPS_SETTER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CAPS_SETTER)) ++ ++ ++gst_caps_setter_get_type ++GType ++void ++ ++ ++GstCapsSetter ++ ++ ++GstCapsSetterClass ++ ++ ++GstCapsSetter ++struct _GstCapsSetter ++{ ++ GstBaseTransform parent; ++ ++ /* < private > */ ++ /* properties */ ++ GstCaps *caps; ++ gboolean join; ++ gboolean replace; ++}; ++ ++ ++GstCapsSetterClass ++struct _GstCapsSetterClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++GST_TYPE_TAG_INJECT ++#define GST_TYPE_TAG_INJECT \ ++ (gst_tag_inject_get_type()) ++ ++ ++GST_TAG_INJECT ++#define GST_TAG_INJECT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_TAG_INJECT,GstTagInject)) ++ ++ ++GST_TAG_INJECT_CLASS ++#define GST_TAG_INJECT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_TAG_INJECT,GstTagInjectClass)) ++ ++ ++GST_IS_TAG_INJECT ++#define GST_IS_TAG_INJECT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_TAG_INJECT)) ++ ++ ++GST_IS_TAG_INJECT_CLASS ++#define GST_IS_TAG_INJECT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_TAG_INJECT)) ++ ++ ++GstTagInject ++ ++ ++GstTagInjectClass ++ ++ ++GstTagInject ++struct _GstTagInject ++{ ++ GstBaseTransform element; ++ ++ /*< private > */ ++ GstTagList *tags; ++ gboolean tags_sent; ++}; ++ ++ ++GstTagInjectClass ++struct _GstTagInjectClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_tag_inject_get_type ++GType ++void ++ ++ ++GST_TYPE_PROGRESS_REPORT ++#define GST_TYPE_PROGRESS_REPORT \ ++ (gst_progress_report_get_type()) ++ ++ ++GST_PROGRESS_REPORT ++#define GST_PROGRESS_REPORT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PROGRESS_REPORT,GstProgressReport)) ++ ++ ++GST_PROGRESS_REPORT_CLASS ++#define GST_PROGRESS_REPORT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PROGRESS_REPORT,GstProgressReportClass)) ++ ++ ++GST_IS_PROGRESS_REPORT ++#define GST_IS_PROGRESS_REPORT(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PROGRESS_REPORT)) ++ ++ ++GST_IS_PROGRESS_REPORT_CLASS ++#define GST_IS_PROGRESS_REPORT_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PROGRESS_REPORT)) ++ ++ ++GstProgressReport ++ ++ ++GstProgressReportClass ++ ++ ++GstProgressReport ++struct _GstProgressReport ++{ ++ GstBaseTransform basetransform; ++ ++ GstMessage *pending_msg; ++ ++ gint update_freq; ++ gboolean silent; ++ GTimeVal start_time; ++ GTimeVal last_report; ++ ++ /* Format used for querying. Using a string here because the ++ * format might not be registered yet when the property is set */ ++ gchar *format; ++}; ++ ++ ++GstProgressReportClass ++struct _GstProgressReportClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_progress_report_get_type ++GType ++void ++ ++ ++GST_TYPE_DEINTERLACE ++#define GST_TYPE_DEINTERLACE \ ++ (gst_deinterlace_get_type()) ++ ++ ++GST_DEINTERLACE ++#define GST_DEINTERLACE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DEINTERLACE,GstDeinterlace)) ++ ++ ++GST_DEINTERLACE_CLASS ++#define GST_DEINTERLACE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DEINTERLACE,GstDeinterlace)) ++ ++ ++GST_IS_DEINTERLACE ++#define GST_IS_DEINTERLACE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DEINTERLACE)) ++ ++ ++GST_IS_DEINTERLACE_CLASS ++#define GST_IS_DEINTERLACE_CLASS(obj) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DEINTERLACE)) ++ ++ ++GstDeinterlace ++ ++ ++GstDeinterlaceClass ++ ++ ++GST_DEINTERLACE_MAX_FIELD_HISTORY ++#define GST_DEINTERLACE_MAX_FIELD_HISTORY 10 ++ ++ ++GstDeinterlaceMethods ++typedef enum ++{ ++ GST_DEINTERLACE_TOMSMOCOMP, ++ GST_DEINTERLACE_GREEDY_H, ++ GST_DEINTERLACE_GREEDY_L, ++ GST_DEINTERLACE_VFIR, ++ GST_DEINTERLACE_LINEAR, ++ GST_DEINTERLACE_LINEAR_BLEND, ++ GST_DEINTERLACE_SCALER_BOB, ++ GST_DEINTERLACE_WEAVE, ++ GST_DEINTERLACE_WEAVE_TFF, ++ GST_DEINTERLACE_WEAVE_BFF ++} GstDeinterlaceMethods; ++ ++ ++GstDeinterlaceFields ++typedef enum ++{ ++ GST_DEINTERLACE_ALL, /* All (missing data is interp.) */ ++ GST_DEINTERLACE_TF, /* Top Fields Only */ ++ GST_DEINTERLACE_BF /* Bottom Fields Only */ ++} GstDeinterlaceFields; ++ ++ ++GstDeinterlaceFieldLayout ++typedef enum ++{ ++ GST_DEINTERLACE_LAYOUT_AUTO, ++ GST_DEINTERLACE_LAYOUT_TFF, ++ GST_DEINTERLACE_LAYOUT_BFF ++} GstDeinterlaceFieldLayout; ++ ++ ++GstDeinterlaceMode ++typedef enum { ++ GST_DEINTERLACE_MODE_AUTO, ++ GST_DEINTERLACE_MODE_INTERLACED, ++ GST_DEINTERLACE_MODE_DISABLED ++} GstDeinterlaceMode; ++ ++ ++GstDeinterlace ++struct _GstDeinterlace ++{ ++ GstElement parent; ++ ++ GstPad *srcpad, *sinkpad; ++ ++ /* */ ++ GstDeinterlaceMode mode; ++ ++ GstDeinterlaceFieldLayout field_layout; ++ ++ GstDeinterlaceFields fields; ++ ++ GstDeinterlaceMethods method_id; ++ GstDeinterlaceMethod *method; ++ ++ GstVideoFormat format; ++ gint width, height; /* frame width & height */ ++ guint frame_size; /* frame size in bytes */ ++ gint fps_n, fps_d; /* frame rate */ ++ gboolean interlaced; /* is input interlaced? */ ++ ++ gboolean passthrough; ++ ++ GstClockTime field_duration; /* Duration of one field */ ++ ++ /* The most recent pictures ++ PictureHistory[0] is always the most recent. ++ Pointers are NULL if the picture in question isn't valid, e.g. because ++ the program just started or a picture was skipped. ++ */ ++ GstDeinterlaceField field_history[GST_DEINTERLACE_MAX_FIELD_HISTORY]; ++ guint history_count; ++ ++ /* Set to TRUE if we're in still frame mode, ++ i.e. just forward all buffers ++ */ ++ gboolean still_frame_mode; ++ ++ /* Last buffer that was pushed in */ ++ GstBuffer *last_buffer; ++ ++ /* Current segment */ ++ GstSegment segment; ++ ++ /* QoS stuff */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++ ++ /* Upstream negotiation stuff */ ++ GstCaps *sink_caps; ++ GstCaps *src_caps; ++ ++ GstCaps *request_caps; ++ ++ gboolean reconfigure; ++ GstDeinterlaceMode new_mode; ++ GstDeinterlaceFields new_fields; ++}; ++ ++ ++GstDeinterlaceClass ++struct _GstDeinterlaceClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_deinterlace_get_type ++GType ++void ++ ++ ++GST_TYPE_AGINGTV ++#define GST_TYPE_AGINGTV \ ++ (gst_agingtv_get_type()) ++ ++ ++GST_AGINGTV ++#define GST_AGINGTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AGINGTV,GstAgingTV)) ++ ++ ++GST_AGINGTV_CLASS ++#define GST_AGINGTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AGINGTV,GstAgingTVClass)) ++ ++ ++GST_IS_AGINGTV ++#define GST_IS_AGINGTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AGINGTV)) ++ ++ ++GST_IS_AGINGTV_CLASS ++#define GST_IS_AGINGTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AGINGTV)) ++ ++ ++SCRATCH_MAX ++#define SCRATCH_MAX 20 ++ ++ ++GstAgingTV ++ ++ ++GstAgingTVClass ++ ++ ++GstAgingTV ++struct _GstAgingTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ ++ gboolean color_aging; ++ gboolean pits; ++ gboolean dusts; ++ ++ gint coloraging_state; ++ ++ scratch scratches[SCRATCH_MAX]; ++ gint scratch_lines; ++ ++ gint dust_interval; ++ gint pits_interval; ++ ++}; ++ ++ ++GstAgingTVClass ++struct _GstAgingTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_agingtv_get_type ++GType ++void ++ ++ ++GST_TYPE_DICETV ++#define GST_TYPE_DICETV \ ++ (gst_dicetv_get_type()) ++ ++ ++GST_DICETV ++#define GST_DICETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DICETV,GstDiceTV)) ++ ++ ++GST_DICETV_CLASS ++#define GST_DICETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DICETV,GstDiceTVClass)) ++ ++ ++GST_IS_DICETV ++#define GST_IS_DICETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DICETV)) ++ ++ ++GST_IS_DICETV_CLASS ++#define GST_IS_DICETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DICETV)) ++ ++ ++GstDiceTV ++ ++ ++GstDiceTVClass ++ ++ ++GstDiceTV ++struct _GstDiceTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ guint8 *dicemap; ++ ++ gint g_cube_bits; ++ gint g_cube_size; ++ gint g_map_height; ++ gint g_map_width; ++}; ++ ++ ++GstDiceTVClass ++struct _GstDiceTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_dicetv_get_type ++GType ++void ++ ++ ++GST_TYPE_EDGETV ++#define GST_TYPE_EDGETV \ ++ (gst_edgetv_get_type()) ++ ++ ++GST_EDGETV ++#define GST_EDGETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_EDGETV,GstEdgeTV)) ++ ++ ++GST_EDGETV_CLASS ++#define GST_EDGETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_EDGETV,GstEdgeTVClass)) ++ ++ ++GST_IS_EDGETV ++#define GST_IS_EDGETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_EDGETV)) ++ ++ ++GST_IS_EDGETV_CLASS ++#define GST_IS_EDGETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_EDGETV)) ++ ++ ++GstEdgeTV ++ ++ ++GstEdgeTVClass ++ ++ ++GstEdgeTV ++struct _GstEdgeTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ gint map_width, map_height; ++ guint32 *map; ++ gint video_width_margin; ++}; ++ ++ ++GstEdgeTVClass ++struct _GstEdgeTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_edgetv_get_type ++GType ++void ++ ++ ++GST_TYPE_QUARKTV ++#define GST_TYPE_QUARKTV \ ++ (gst_quarktv_get_type()) ++ ++ ++GST_QUARKTV ++#define GST_QUARKTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QUARKTV,GstQuarkTV)) ++ ++ ++GST_QUARKTV_CLASS ++#define GST_QUARKTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QUARKTV,GstQuarkTVClass)) ++ ++ ++GST_IS_QUARKTV ++#define GST_IS_QUARKTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QUARKTV)) ++ ++ ++GST_IS_QUARKTV_CLASS ++#define GST_IS_QUARKTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QUARKTV)) ++ ++ ++GstQuarkTV ++ ++ ++GstQuarkTVClass ++ ++ ++GstQuarkTV ++struct _GstQuarkTV ++{ ++ GstVideoFilter element; ++ ++ /* < private > */ ++ ++ gint width, height; ++ gint area; ++ gint planes; ++ gint current_plane; ++ GstBuffer **planetable; ++}; ++ ++ ++GstQuarkTVClass ++struct _GstQuarkTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_quarktv_get_type ++GType ++void ++ ++ ++GST_TYPE_REVTV ++#define GST_TYPE_REVTV \ ++ (gst_revtv_get_type()) ++ ++ ++GST_REVTV ++#define GST_REVTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_REVTV,GstRevTV)) ++ ++ ++GST_REVTV_CLASS ++#define GST_REVTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_REVTV,GstRevTVClass)) ++ ++ ++GST_IS_REVTV ++#define GST_IS_REVTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_REVTV)) ++ ++ ++GST_IS_REVTV_CLASS ++#define GST_IS_REVTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_REVTV)) ++ ++ ++GstRevTV ++ ++ ++GstRevTVClass ++ ++ ++GstRevTV ++struct _GstRevTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ gint vgrabtime; ++ gint vgrab; ++ gint linespace; ++ gint vscale; ++}; ++ ++ ++GstRevTVClass ++struct _GstRevTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_revtv_get_type ++GType ++void ++ ++ ++GST_TYPE_SHAGADELICTV ++#define GST_TYPE_SHAGADELICTV \ ++ (gst_shagadelictv_get_type()) ++ ++ ++GST_SHAGADELICTV ++#define GST_SHAGADELICTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SHAGADELICTV,GstShagadelicTV)) ++ ++ ++GST_SHAGADELICTV_CLASS ++#define GST_SHAGADELICTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SHAGADELICTV,GstShagadelicTVClass)) ++ ++ ++GST_IS_SHAGADELICTV ++#define GST_IS_SHAGADELICTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SHAGADELICTV)) ++ ++ ++GST_IS_SHAGADELICTV_CLASS ++#define GST_IS_SHAGADELICTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SHAGADELICTV)) ++ ++ ++GstShagadelicTV ++ ++ ++GstShagadelicTVClass ++ ++ ++GstShagadelicTV ++struct _GstShagadelicTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ gint stat; ++ guint8 *ripple; ++ guint8 *spiral; ++ guint8 phase; ++ gint rx, ry; ++ gint bx, by; ++ gint rvx, rvy; ++ gint bvx, bvy; ++}; ++ ++ ++GstShagadelicTVClass ++struct _GstShagadelicTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_shagadelictv_get_type ++GType ++void ++ ++ ++GST_TYPE_VERTIGOTV ++#define GST_TYPE_VERTIGOTV \ ++ (gst_vertigotv_get_type()) ++ ++ ++GST_VERTIGOTV ++#define GST_VERTIGOTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VERTIGOTV,GstVertigoTV)) ++ ++ ++GST_VERTIGOTV_CLASS ++#define GST_VERTIGOTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VERTIGOTV,GstVertigoTVClass)) ++ ++ ++GST_IS_VERTIGOTV ++#define GST_IS_VERTIGOTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VERTIGOTV)) ++ ++ ++GST_IS_VERTIGOTV_CLASS ++#define GST_IS_VERTIGOTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VERTIGOTV)) ++ ++ ++GstVertigoTV ++ ++ ++GstVertigoTVClass ++ ++ ++GstVertigoTV ++struct _GstVertigoTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ guint32 *buffer; ++ guint32 *current_buffer, *alt_buffer; ++ gint dx, dy; ++ gint sx, sy; ++ gdouble phase; ++ gdouble phase_increment; ++ gdouble zoomrate; ++}; ++ ++ ++GstVertigoTVClass ++struct _GstVertigoTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_vertigotv_get_type ++GType ++void ++ ++ ++GST_TYPE_WARPTV ++#define GST_TYPE_WARPTV \ ++ (gst_warptv_get_type()) ++ ++ ++GST_WARPTV ++#define GST_WARPTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WARPTV,GstWarpTV)) ++ ++ ++GST_WARPTV_CLASS ++#define GST_WARPTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WARPTV,GstWarpTVClass)) ++ ++ ++GST_IS_WARPTV ++#define GST_IS_WARPTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WARPTV)) ++ ++ ++GST_IS_WARPTV_CLASS ++#define GST_IS_WARPTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WARPTV)) ++ ++ ++GstWarpTV ++ ++ ++GstWarpTVClass ++ ++ ++GstWarpTV ++struct _GstWarpTV ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ gint width, height; ++ gint *offstable; ++ gint32 *disttable; ++ gint32 ctable[1024]; ++ gint tval; ++}; ++ ++ ++GstWarpTVClass ++struct _GstWarpTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_warptv_get_type ++GType ++void ++ ++ ++GST_TYPE_STREAKTV ++#define GST_TYPE_STREAKTV \ ++ (gst_streaktv_get_type()) ++ ++ ++GST_STREAKTV ++#define GST_STREAKTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_STREAKTV,GstStreakTV)) ++ ++ ++GST_STREAKTV_CLASS ++#define GST_STREAKTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_STREAKTV,GstStreakTVClass)) ++ ++ ++GST_IS_STREAKTV ++#define GST_IS_STREAKTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_STREAKTV)) ++ ++ ++GST_IS_STREAKTV_CLASS ++#define GST_IS_STREAKTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_STREAKTV)) ++ ++ ++GstStreakTV ++ ++ ++GstStreakTVClass ++ ++ ++PLANES ++#define PLANES 32 ++ ++ ++GstStreakTV ++struct _GstStreakTV ++{ ++ GstVideoFilter element; ++ ++ /* < private > */ ++ gint width, height; ++ ++ gboolean feedback; ++ ++ guint32 *planebuffer; ++ guint32 *planetable[PLANES]; ++ gint plane; ++}; ++ ++ ++GstStreakTVClass ++struct _GstStreakTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_streaktv_get_type ++GType ++void ++ ++ ++GST_TYPE_RIPPLETV ++#define GST_TYPE_RIPPLETV \ ++ (gst_rippletv_get_type()) ++ ++ ++GST_RIPPLETV ++#define GST_RIPPLETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RIPPLETV,GstRippleTV)) ++ ++ ++GST_RIPPLETV_CLASS ++#define GST_RIPPLETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RIPPLETV,GstRippleTVClass)) ++ ++ ++GST_IS_RIPPLETV ++#define GST_IS_RIPPLETV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RIPPLETV)) ++ ++ ++GST_IS_RIPPLETV_CLASS ++#define GST_IS_RIPPLETV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RIPPLETV)) ++ ++ ++GstRippleTV ++ ++ ++GstRippleTVClass ++ ++ ++GstRippleTV ++struct _GstRippleTV ++{ ++ GstVideoFilter element; ++ ++ /* < private > */ ++ gint width, height; ++ ++ gint mode; ++ ++ gint16 *background; ++ guint8 *diff; ++ ++ gint *map, *map1, *map2, *map3; ++ gint map_h, map_w; ++ ++ gint8 *vtable; ++ ++ gboolean bg_is_set; ++ ++ gint period; ++ gint rain_stat; ++ guint drop_prob; ++ gint drop_prob_increment; ++ gint drops_per_frame_max; ++ gint drops_per_frame; ++ gint drop_power; ++}; ++ ++ ++GstRippleTVClass ++struct _GstRippleTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_rippletv_get_type ++GType ++void ++ ++ ++GST_TYPE_OPTV ++#define GST_TYPE_OPTV \ ++ (gst_optv_get_type()) ++ ++ ++GST_OPTV ++#define GST_OPTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OPTV,GstOpTV)) ++ ++ ++GST_OPTV_CLASS ++#define GST_OPTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OPTV,GstOpTVClass)) ++ ++ ++GST_IS_OPTV ++#define GST_IS_OPTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OPTV)) ++ ++ ++GST_IS_OPTV_CLASS ++#define GST_IS_OPTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OPTV)) ++ ++ ++GstOpTV ++ ++ ++GstOpTVClass ++ ++ ++GstOpTV ++struct _GstOpTV ++{ ++ GstVideoFilter element; ++ ++ /* < private > */ ++ gint width, height; ++ ++ gint mode; ++ gint speed; ++ guint threshold; ++ ++ gint8 *opmap[4]; ++ guint8 *diff; ++ guint8 phase; ++}; ++ ++ ++GstOpTVClass ++struct _GstOpTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_optv_get_type ++GType ++void ++ ++ ++GST_TYPE_RADIOACTV ++#define GST_TYPE_RADIOACTV \ ++ (gst_radioactv_get_type()) ++ ++ ++GST_RADIOACTV ++#define GST_RADIOACTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RADIOACTV,GstRadioacTV)) ++ ++ ++GST_RADIOACTV_CLASS ++#define GST_RADIOACTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RADIOACTV,GstRadioacTVClass)) ++ ++ ++GST_IS_RADIOACTV ++#define GST_IS_RADIOACTV(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RADIOACTV)) ++ ++ ++GST_IS_RADIOACTV_CLASS ++#define GST_IS_RADIOACTV_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RADIOACTV)) ++ ++ ++GstRadioacTV ++ ++ ++GstRadioacTVClass ++ ++ ++GstRadioacTV ++struct _GstRadioacTV ++{ ++ GstVideoFilter element; ++ ++ /* < private > */ ++ gint width, height; ++ ++ gint mode; ++ gint color; ++ guint interval; ++ gboolean trigger; ++ ++ gint snaptime; ++ ++ guint32 *snapframe; ++ guint8 *blurzoombuf; ++ guint8 *diff; ++ guint32 *background; ++ gint *blurzoomx; ++ gint *blurzoomy; ++ ++ gint buf_width_blocks; ++ gint buf_width; ++ gint buf_height; ++ gint buf_area; ++ gint buf_margin_right; ++ gint buf_margin_left; ++}; ++ ++ ++GstRadioacTVClass ++struct _GstRadioacTVClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_radioactv_get_type ++GType ++void ++ ++ ++GstIirEqualizer ++ ++ ++GstIirEqualizerClass ++ ++ ++GstIirEqualizerBand ++ ++ ++GST_TYPE_IIR_EQUALIZER ++#define GST_TYPE_IIR_EQUALIZER \ ++ (gst_iir_equalizer_get_type()) ++ ++ ++GST_IIR_EQUALIZER ++#define GST_IIR_EQUALIZER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IIR_EQUALIZER,GstIirEqualizer)) ++ ++ ++GST_IIR_EQUALIZER_CLASS ++#define GST_IIR_EQUALIZER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IIR_EQUALIZER,GstIirEqualizerClass)) ++ ++ ++GST_IS_IIR_EQUALIZER ++#define GST_IS_IIR_EQUALIZER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IIR_EQUALIZER)) ++ ++ ++GST_IS_IIR_EQUALIZER_CLASS ++#define GST_IS_IIR_EQUALIZER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IIR_EQUALIZER)) ++ ++ ++LOWEST_FREQ ++#define LOWEST_FREQ (20.0) ++ ++ ++HIGHEST_FREQ ++#define HIGHEST_FREQ (20000.0) ++ ++ ++ProcessFunc ++void ++GstIirEqualizer * eq, guint8 * data, guint size, ++ guint channels ++ ++ ++GstIirEqualizer ++struct _GstIirEqualizer ++{ ++ GstAudioFilter audiofilter; ++ ++ /*< private >*/ ++ ++ GMutex *bands_lock; ++ GstIirEqualizerBand **bands; ++ ++ /* properties */ ++ guint freq_band_count; ++ /* for each band and channel */ ++ gpointer history; ++ guint history_size; ++ ++ gboolean need_new_coefficients; ++ ++ ProcessFunc process; ++}; ++ ++ ++GstIirEqualizerClass ++struct _GstIirEqualizerClass ++{ ++ GstAudioFilterClass audiofilter_class; ++}; ++ ++ ++gst_iir_equalizer_compute_frequencies ++void ++GstIirEqualizer * equ, guint new_count ++ ++ ++gst_iir_equalizer_get_type ++GType ++void ++ ++ ++GstIirEqualizer3Bands ++ ++ ++GstIirEqualizer3BandsClass ++ ++ ++GST_TYPE_IIR_EQUALIZER_3BANDS ++#define GST_TYPE_IIR_EQUALIZER_3BANDS \ ++ (gst_iir_equalizer_3bands_get_type()) ++ ++ ++GST_IIR_EQUALIZER_3BANDS ++#define GST_IIR_EQUALIZER_3BANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IIR_EQUALIZER_3BANDS,GstIirEqualizer3Bands)) ++ ++ ++GST_IIR_EQUALIZER_3BANDS_CLASS ++#define GST_IIR_EQUALIZER_3BANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IIR_EQUALIZER_3BANDS,GstIirEqualizer3BandsClass)) ++ ++ ++GST_IS_IIR_EQUALIZER_3BANDS ++#define GST_IS_IIR_EQUALIZER_3BANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IIR_EQUALIZER_3BANDS)) ++ ++ ++GST_IS_IIR_EQUALIZER_3BANDS_CLASS ++#define GST_IS_IIR_EQUALIZER_3BANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IIR_EQUALIZER_3BANDS)) ++ ++ ++GstIirEqualizer3Bands ++struct _GstIirEqualizer3Bands ++{ ++ GstIirEqualizer equalizer; ++}; ++ ++ ++GstIirEqualizer3BandsClass ++struct _GstIirEqualizer3BandsClass ++{ ++ GstIirEqualizer equalizer_class; ++}; ++ ++ ++gst_iir_equalizer_3bands_get_type ++GType ++void ++ ++ ++GstIirEqualizer10Bands ++ ++ ++GstIirEqualizer10BandsClass ++ ++ ++GST_TYPE_IIR_EQUALIZER_10BANDS ++#define GST_TYPE_IIR_EQUALIZER_10BANDS \ ++ (gst_iir_equalizer_10bands_get_type()) ++ ++ ++GST_IIR_EQUALIZER_10BANDS ++#define GST_IIR_EQUALIZER_10BANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IIR_EQUALIZER_10BANDS,GstIirEqualizer10Bands)) ++ ++ ++GST_IIR_EQUALIZER_10BANDS_CLASS ++#define GST_IIR_EQUALIZER_10BANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IIR_EQUALIZER_10BANDS,GstIirEqualizer10BandsClass)) ++ ++ ++GST_IS_IIR_EQUALIZER_10BANDS ++#define GST_IS_IIR_EQUALIZER_10BANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IIR_EQUALIZER_10BANDS)) ++ ++ ++GST_IS_IIR_EQUALIZER_10BANDS_CLASS ++#define GST_IS_IIR_EQUALIZER_10BANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IIR_EQUALIZER_10BANDS)) ++ ++ ++GstIirEqualizer10Bands ++struct _GstIirEqualizer10Bands ++{ ++ GstIirEqualizer equalizer; ++}; ++ ++ ++GstIirEqualizer10BandsClass ++struct _GstIirEqualizer10BandsClass ++{ ++ GstIirEqualizer equalizer_class; ++}; ++ ++ ++gst_iir_equalizer_10bands_get_type ++GType ++void ++ ++ ++GstIirEqualizerNBands ++ ++ ++GstIirEqualizerNBandsClass ++ ++ ++GST_TYPE_IIR_EQUALIZER_NBANDS ++#define GST_TYPE_IIR_EQUALIZER_NBANDS \ ++ (gst_iir_equalizer_nbands_get_type()) ++ ++ ++GST_IIR_EQUALIZER_NBANDS ++#define GST_IIR_EQUALIZER_NBANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IIR_EQUALIZER_NBANDS,GstIirEqualizerNBands)) ++ ++ ++GST_IIR_EQUALIZER_NBANDS_CLASS ++#define GST_IIR_EQUALIZER_NBANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IIR_EQUALIZER_NBANDS,GstIirEqualizerNBandsClass)) ++ ++ ++GST_IS_IIR_EQUALIZER_NBANDS ++#define GST_IS_IIR_EQUALIZER_NBANDS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IIR_EQUALIZER_NBANDS)) ++ ++ ++GST_IS_IIR_EQUALIZER_NBANDS_CLASS ++#define GST_IS_IIR_EQUALIZER_NBANDS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IIR_EQUALIZER_NBANDS)) ++ ++ ++GstIirEqualizerNBands ++struct _GstIirEqualizerNBands ++{ ++ GstIirEqualizer equalizer; ++}; ++ ++ ++GstIirEqualizerNBandsClass ++struct _GstIirEqualizerNBandsClass ++{ ++ GstIirEqualizer equalizer_class; ++}; ++ ++ ++gst_iir_equalizer_nbands_get_type ++GType ++void ++ ++ ++GST_TYPE_FLV_DEMUX ++#define GST_TYPE_FLV_DEMUX \ ++ (gst_flv_demux_get_type()) ++ ++ ++GST_FLV_DEMUX ++#define GST_FLV_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLV_DEMUX,GstFlvDemux)) ++ ++ ++GST_FLV_DEMUX_CLASS ++#define GST_FLV_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLV_DEMUX,GstFlvDemuxClass)) ++ ++ ++GST_IS_FLV_DEMUX ++#define GST_IS_FLV_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLV_DEMUX)) ++ ++ ++GST_IS_FLV_DEMUX_CLASS ++#define GST_IS_FLV_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLV_DEMUX)) ++ ++ ++GstFlvDemux ++ ++ ++GstFlvDemuxClass ++ ++ ++GstFlvDemuxState ++typedef enum ++{ ++ FLV_STATE_HEADER, ++ FLV_STATE_TAG_TYPE, ++ FLV_STATE_TAG_VIDEO, ++ FLV_STATE_TAG_AUDIO, ++ FLV_STATE_TAG_SCRIPT, ++ FLV_STATE_SEEK, ++ FLV_STATE_DONE, ++ FLV_STATE_NONE ++} GstFlvDemuxState; ++ ++ ++GstFlvDemux ++struct _GstFlvDemux ++{ ++ GstElement element; ++ ++ GstPad *sinkpad; ++ ++ GstPad *audio_pad; ++ GstPad *video_pad; ++ ++ /* */ ++ ++ GstIndex *index; ++ gint index_id; ++ gboolean own_index; ++ ++ GArray * times; ++ GArray * filepositions; ++ ++ GstAdapter *adapter; ++ ++ GstSegment segment; ++ ++ GstEvent *close_seg_event; ++ GstEvent *new_seg_event; ++ ++ GstTagList *taglist; ++ ++ GstFlvDemuxState state; ++ ++ guint64 offset; ++ guint64 cur_tag_offset; ++ GstClockTime duration; ++ guint64 tag_size; ++ guint64 tag_data_size; ++ ++ /* Audio infos */ ++ guint16 rate; ++ guint16 channels; ++ guint16 width; ++ guint16 audio_codec_tag; ++ guint64 audio_offset; ++ gboolean audio_need_discont; ++ gboolean audio_need_segment; ++ gboolean audio_linked; ++ GstBuffer * audio_codec_data; ++ GstClockTime audio_start; ++ ++ /* Video infos */ ++ guint32 w; ++ guint32 h; ++ guint32 par_x; ++ guint32 par_y; ++ guint16 video_codec_tag; ++ guint64 video_offset; ++ gboolean video_need_discont; ++ gboolean video_need_segment; ++ gboolean video_linked; ++ gboolean got_par; ++ GstBuffer * video_codec_data; ++ GstClockTime video_start; ++ ++ gboolean random_access; ++ gboolean need_header; ++ gboolean has_audio; ++ gboolean has_video; ++ gboolean push_tags; ++ gboolean strict; ++ gboolean flushing; ++ ++ gboolean no_more_pads; ++ ++ gboolean seeking; ++ gboolean building_index; ++ gboolean indexed; /* TRUE if index is completely built */ ++ gint64 file_size; ++ GstEvent *seek_event; ++ gint64 seek_time; ++ ++ GstClockTime index_max_time; ++ gint64 index_max_pos; ++ ++ /* reverse playback */ ++ GstClockTime video_first_ts; ++ GstClockTime audio_first_ts; ++ gboolean video_done; ++ gboolean audio_done; ++ gint64 from_offset; ++ gint64 to_offset; ++}; ++ ++ ++GstFlvDemuxClass ++struct _GstFlvDemuxClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_flv_demux_get_type ++GType ++void ++ ++ ++GST_TYPE_FLV_MUX ++#define GST_TYPE_FLV_MUX \ ++ (gst_flv_mux_get_type ()) ++ ++ ++GST_FLV_MUX ++#define GST_FLV_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_FLV_MUX, GstFlvMux)) ++ ++ ++GST_FLV_MUX_CLASS ++#define GST_FLV_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_FLV_MUX, GstFlvMuxClass)) ++ ++ ++GST_IS_FLV_MUX ++#define GST_IS_FLV_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_FLV_MUX)) ++ ++ ++GST_IS_FLV_MUX_CLASS ++#define GST_IS_FLV_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_FLV_MUX)) ++ ++ ++GstFlvMuxState ++typedef enum ++{ ++ GST_FLV_MUX_STATE_HEADER, ++ GST_FLV_MUX_STATE_DATA ++} GstFlvMuxState; ++ ++ ++GstFlvMux ++typedef struct _GstFlvMux { ++ GstElement element; ++ ++ GstPad *srcpad; ++ GstCollectPads *collect; ++ ++ /* */ ++ GstPadEventFunction collect_event; ++ ++ GstFlvMuxState state; ++ gboolean have_audio; ++ gboolean have_video; ++ gboolean streamable; ++ ++ GstTagList *tags; ++ GList *index; ++ guint64 byte_count; ++ guint64 duration; ++} GstFlvMux; ++ ++ ++GstFlvMuxClass ++typedef struct _GstFlvMuxClass { ++ GstElementClass parent; ++} GstFlvMuxClass; ++ ++ ++gst_flv_mux_get_type ++GType ++void ++ ++ ++GstFlxDecState ++typedef enum { ++ GST_FLXDEC_READ_HEADER, ++ GST_FLXDEC_PLAYING, ++} GstFlxDecState; ++ ++ ++GstFlxDec ++ ++ ++GstFlxDec ++struct _GstFlxDec { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ ++ gboolean active, new_meta; ++ ++ GstBuffer *delta, *frame; ++ GstAdapter *adapter; ++ gulong size; ++ GstFlxDecState state; ++ gint64 frame_time; ++ gint64 next_time; ++ gint64 duration; ++ ++ FlxColorSpaceConverter *converter; ++ ++ FlxHeader hdr; ++}; ++ ++ ++GstFlxDecClass ++ ++ ++GstFlxDecClass ++struct _GstFlxDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++GST_TYPE_FLXDEC ++#define GST_TYPE_FLXDEC \ ++ (gst_flxdec_get_type()) ++ ++ ++GST_FLXDEC ++#define GST_FLXDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLXDEC,GstFlxDec)) ++ ++ ++GST_FLXDEC_CLASS ++#define GST_FLXDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLXDEC,GstFlxDecClass)) ++ ++ ++GST_IS_FLXDEC ++#define GST_IS_FLXDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLXDEC)) ++ ++ ++GST_IS_FLXDEC_CLASS ++#define GST_IS_FLXDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLXDEC)) ++ ++ ++gst_flxdec_get_type ++GType ++void ++ ++ ++GOOM_SAMPLES ++#define GOOM_SAMPLES 512 ++ ++ ++GST_TYPE_GOOM ++#define GST_TYPE_GOOM (gst_goom_get_type()) ++ ++ ++GST_GOOM ++#define GST_GOOM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GOOM,GstGoom)) ++ ++ ++GST_GOOM_CLASS ++#define GST_GOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GOOM,GstGoomClass)) ++ ++ ++GST_IS_GOOM ++#define GST_IS_GOOM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GOOM)) ++ ++ ++GST_IS_GOOM_CLASS ++#define GST_IS_GOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GOOM)) ++ ++ ++GstGoom ++ ++ ++GstGoomClass ++ ++ ++GstGoom ++struct _GstGoom ++{ ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad, *srcpad; ++ GstAdapter *adapter; ++ ++ /* input tracking */ ++ gint rate; ++ gint channels; ++ guint bps; ++ ++ /* video state */ ++ gint fps_n; ++ gint fps_d; ++ gint width; ++ gint height; ++ GstClockTime duration; ++ guint outsize; ++ ++ /* samples per frame */ ++ guint spf; ++ /* bytes per frame */ ++ guint bpf; ++ ++ /* goom stuff */ ++ gint16 datain[2][GOOM_SAMPLES]; ++ PluginInfo *plugin; ++ ++ /* segment state */ ++ GstSegment segment; ++ ++ /* the timestamp of the next frame */ ++ GstClockTime next_ts; ++ ++ /* QoS stuff *//* with LOCK */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++}; ++ ++ ++GstGoomClass ++struct _GstGoomClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_goom_get_type ++GType ++void ++ ++ ++GOOM_SAMPLES ++#define GOOM_SAMPLES 512 ++ ++ ++GST_TYPE_GOOM ++#define GST_TYPE_GOOM (gst_goom_get_type()) ++ ++ ++GST_GOOM ++#define GST_GOOM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GOOM,GstGoom)) ++ ++ ++GST_GOOM_CLASS ++#define GST_GOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GOOM,GstGoomClass)) ++ ++ ++GST_IS_GOOM ++#define GST_IS_GOOM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GOOM)) ++ ++ ++GST_IS_GOOM_CLASS ++#define GST_IS_GOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GOOM)) ++ ++ ++GstGoom ++ ++ ++GstGoomClass ++ ++ ++GstGoom ++struct _GstGoom ++{ ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad, *srcpad; ++ GstAdapter *adapter; ++ ++ /* input tracking */ ++ gint rate; ++ gint channels; ++ guint bps; ++ ++ /* video state */ ++ gint fps_n; ++ gint fps_d; ++ gint width; ++ gint height; ++ GstClockTime duration; ++ guint outsize; ++ ++ /* samples per frame */ ++ guint spf; ++ /* bytes per frame */ ++ guint bpf; ++ ++ /* goom stuff */ ++ gint16 datain[2][GOOM_SAMPLES]; ++ GoomData goomdata; ++ ++ /* segment state */ ++ GstSegment segment; ++ ++ /* the timestamp of the next frame */ ++ GstClockTime next_ts; ++ ++ /* QoS stuff *//* with LOCK */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++}; ++ ++ ++GstGoomClass ++struct _GstGoomClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_goom_get_type ++GType ++void ++ ++ ++GST_TYPE_ALAW_DEC ++#define GST_TYPE_ALAW_DEC \ ++ (gst_alaw_dec_get_type()) ++ ++ ++GST_ALAW_DEC ++#define GST_ALAW_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALAW_DEC,GstALawDec)) ++ ++ ++GST_ALAW_DEC_CLASS ++#define GST_ALAW_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALAW_DEC,GstALawDecClass)) ++ ++ ++GST_IS_ALAW_DEC ++#define GST_IS_ALAW_DEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALAW_DEC)) ++ ++ ++GST_IS_ALAW_DEC_CLASS ++#define GST_IS_ALAW_DEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALAW_DEC)) ++ ++ ++GstALawDec ++ ++ ++GstALawDecClass ++ ++ ++GstALawDec ++struct _GstALawDec { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ gint rate; ++ gint channels; ++}; ++ ++ ++GstALawDecClass ++struct _GstALawDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_alaw_dec_get_type ++GType ++void ++ ++ ++GST_TYPE_ALAW_ENC ++#define GST_TYPE_ALAW_ENC \ ++ (gst_alaw_enc_get_type()) ++ ++ ++GST_ALAW_ENC ++#define GST_ALAW_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALAW_ENC,GstALawEnc)) ++ ++ ++GST_ALAW_ENC_CLASS ++#define GST_ALAW_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALAW_ENC,GstALawEncClass)) ++ ++ ++GST_IS_ALAW_ENC ++#define GST_IS_ALAW_ENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALAW_ENC)) ++ ++ ++GST_IS_ALAW_ENC_CLASS ++#define GST_IS_ALAW_ENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALAW_ENC)) ++ ++ ++GstALawEnc ++ ++ ++GstALawEncClass ++ ++ ++GstALawEnc ++struct _GstALawEnc { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ ++ gint channels; ++ gint rate; ++}; ++ ++ ++GstALawEncClass ++struct _GstALawEncClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_alaw_enc_get_type ++GType ++void ++ ++ ++GST_TYPE_MULAWDEC ++#define GST_TYPE_MULAWDEC \ ++ (gst_mulawdec_get_type()) ++ ++ ++GST_MULAWDEC ++#define GST_MULAWDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULAWDEC,GstMuLawDec)) ++ ++ ++GST_MULAWDEC_CLASS ++#define GST_MULAWDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULAWDEC,GstMuLawDecClass)) ++ ++ ++GST_IS_MULAWDEC ++#define GST_IS_MULAWDEC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULAWDEC)) ++ ++ ++GST_IS_MULAWDEC_CLASS ++#define GST_IS_MULAWDEC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULAWDEC)) ++ ++ ++GstMuLawDec ++ ++ ++GstMuLawDecClass ++ ++ ++GstMuLawDec ++struct _GstMuLawDec { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ ++ gint rate; ++ gint channels; ++}; ++ ++ ++GstMuLawDecClass ++struct _GstMuLawDecClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_mulawdec_get_type ++GType ++void ++ ++ ++GST_TYPE_MULAWENC ++#define GST_TYPE_MULAWENC \ ++ (gst_mulawenc_get_type()) ++ ++ ++GST_MULAWENC ++#define GST_MULAWENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULAWENC,GstMuLawEnc)) ++ ++ ++GST_MULAWENC_CLASS ++#define GST_MULAWENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULAWENC,GstMuLawEncClass)) ++ ++ ++GST_IS_MULAWENC ++#define GST_IS_MULAWENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULAWENC)) ++ ++ ++GST_IS_MULAWENC_CLASS ++#define GST_IS_MULAWENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULAWENC)) ++ ++ ++GstMuLawEnc ++ ++ ++GstMuLawEncClass ++ ++ ++GstMuLawEnc ++struct _GstMuLawEnc { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ ++ gint channels; ++ gint rate; ++}; ++ ++ ++GstMuLawEncClass ++struct _GstMuLawEncClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_mulawenc_get_type ++GType ++void ++ ++ ++GST_TYPE_ICYDEMUX ++#define GST_TYPE_ICYDEMUX \ ++ (gst_icydemux_get_type()) ++ ++ ++GST_ICYDEMUX ++#define GST_ICYDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ICYDEMUX,GstICYDemux)) ++ ++ ++GST_ICYDEMUX_CLASS ++#define GST_ICYDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ICYDEMUX,GstICYDemuxClass)) ++ ++ ++GST_IS_ICYDEMUX ++#define GST_IS_ICYDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ICYDEMUX)) ++ ++ ++GST_IS_ICYDEMUX_CLASS ++#define GST_IS_ICYDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ICYDEMUX)) ++ ++ ++GstICYDemux ++ ++ ++GstICYDemuxClass ++ ++ ++GstICYDemux ++struct _GstICYDemux ++{ ++ GstElement element; ++ ++ GstPad *sinkpad, *srcpad; ++ ++ /* Interval between metadata updates */ ++ gint meta_interval; ++ ++ /* Remaining bytes until the next metadata update */ ++ gint remaining; ++ ++ /* When 'remaining' is zero, this holds the number of bytes of metadata we ++ * still need to read, or zero if we don't yet know (which means we need to ++ * read one byte, after which we can initialise this properly) */ ++ gint meta_remaining; ++ ++ /* Caps for the data enclosed */ ++ GstCaps *src_caps; ++ ++ /* True if we're still typefinding */ ++ gboolean typefinding; ++ ++ GstTagList *cached_tags; ++ GList *cached_events; ++ ++ GstAdapter *meta_adapter; ++ ++ GstBuffer *typefind_buf; ++ ++ /* upstream HTTP Content-Type */ ++ gchar *content_type; ++}; ++ ++ ++GstICYDemuxClass ++struct _GstICYDemuxClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_icydemux_get_type ++GType ++void ++ ++ ++GST_TYPE_ID3DEMUX ++#define GST_TYPE_ID3DEMUX \ ++ (gst_id3demux_get_type()) ++ ++ ++GST_ID3DEMUX ++#define GST_ID3DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ID3DEMUX,GstID3Demux)) ++ ++ ++GST_ID3DEMUX_CLASS ++#define GST_ID3DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ID3DEMUX,GstID3DemuxClass)) ++ ++ ++GST_IS_ID3DEMUX ++#define GST_IS_ID3DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ID3DEMUX)) ++ ++ ++GST_IS_ID3DEMUX_CLASS ++#define GST_IS_ID3DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ID3DEMUX)) ++ ++ ++GstID3Demux ++ ++ ++GstID3DemuxClass ++ ++ ++GstID3Demux ++struct _GstID3Demux ++{ ++ GstTagDemux tagdemux; ++ ++ gboolean prefer_v1; /* prefer ID3v1 tags over ID3v2 tags? */ ++}; ++ ++ ++GstID3DemuxClass ++struct _GstID3DemuxClass ++{ ++ GstTagDemuxClass parent_class; ++}; ++ ++ ++gst_id3demux_get_type ++GType ++void ++ ++ ++GST_TYPE_IMAGE_FREEZE ++#define GST_TYPE_IMAGE_FREEZE \ ++ (gst_image_freeze_get_type()) ++ ++ ++GST_IMAGE_FREEZE ++#define GST_IMAGE_FREEZE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IMAGE_FREEZE,GstImageFreeze)) ++ ++ ++GST_IMAGE_FREEZE_CLASS ++#define GST_IMAGE_FREEZE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IMAGE_FREEZE,GstImageFreezeClass)) ++ ++ ++GST_IMAGE_FREEZE_GET_CLASS ++#define GST_IMAGE_FREEZE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_IMAGE_FREEZE,GstImageFreezeClass)) ++ ++ ++GST_IS_IMAGE_FREEZE ++#define GST_IS_IMAGE_FREEZE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IMAGE_FREEZE)) ++ ++ ++GST_IS_IMAGE_FREEZE_CLASS ++#define GST_IS_IMAGE_FREEZE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IMAGE_FREEZE)) ++ ++ ++GstImageFreeze ++ ++ ++GstImageFreezeClass ++ ++ ++GstImageFreeze ++struct _GstImageFreeze ++{ ++ GstElement parent; ++ ++ /* < private > */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstBuffer *buffer; ++ gint fps_n, fps_d; ++ ++ GstSegment segment; ++ gboolean need_segment; ++ GstEvent *close_segment; ++ ++ guint64 offset; ++}; ++ ++ ++GstImageFreezeClass ++struct _GstImageFreezeClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_image_freeze_get_type ++GType ++void ++ ++ ++GST_TYPE_DEINTERLEAVE ++#define GST_TYPE_DEINTERLEAVE (gst_deinterleave_get_type()) ++ ++ ++GST_DEINTERLEAVE ++#define GST_DEINTERLEAVE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DEINTERLEAVE,GstDeinterleave)) ++ ++ ++GST_DEINTERLEAVE_CLASS ++#define GST_DEINTERLEAVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DEINTERLEAVE,GstDeinterleaveClass)) ++ ++ ++GST_DEINTERLEAVE_GET_CLASS ++#define GST_DEINTERLEAVE_GET_CLASS(obj) \ ++ (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_DEINTERLEAVE,GstDeinterleaveClass)) ++ ++ ++GST_IS_DEINTERLEAVE ++#define GST_IS_DEINTERLEAVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DEINTERLEAVE)) ++ ++ ++GST_IS_DEINTERLEAVE_CLASS ++#define GST_IS_DEINTERLEAVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DEINTERLEAVE)) ++ ++ ++GstDeinterleave ++ ++ ++GstDeinterleaveClass ++ ++ ++GstDeinterleaveFunc ++void ++gpointer out, gpointer in, guint stride, guint nframes ++ ++ ++GstDeinterleave ++struct _GstDeinterleave ++{ ++ GstElement element; ++ ++ /*< private > */ ++ GList *srcpads; ++ GstCaps *sinkcaps; ++ gint channels; ++ GstAudioChannelPosition *pos; ++ gboolean keep_positions; ++ ++ GstPad *sink; ++ ++ gint width; ++ GstDeinterleaveFunc func; ++ ++ GList *pending_events; ++}; ++ ++ ++GstDeinterleaveClass ++struct _GstDeinterleaveClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_deinterleave_get_type ++GType ++void ++ ++ ++GST_TYPE_INTERLEAVE ++#define GST_TYPE_INTERLEAVE (gst_interleave_get_type()) ++ ++ ++GST_INTERLEAVE ++#define GST_INTERLEAVE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_INTERLEAVE,GstInterleave)) ++ ++ ++GST_INTERLEAVE_CLASS ++#define GST_INTERLEAVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_INTERLEAVE,GstInterleaveClass)) ++ ++ ++GST_INTERLEAVE_GET_CLASS ++#define GST_INTERLEAVE_GET_CLASS(obj) \ ++ (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_INTERLEAVE,GstInterleaveClass)) ++ ++ ++GST_IS_INTERLEAVE ++#define GST_IS_INTERLEAVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_INTERLEAVE)) ++ ++ ++GST_IS_INTERLEAVE_CLASS ++#define GST_IS_INTERLEAVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_INTERLEAVE)) ++ ++ ++GstInterleave ++ ++ ++GstInterleaveClass ++ ++ ++GstInterleaveFunc ++void ++gpointer out, gpointer in, guint stride, guint nframes ++ ++ ++GstInterleave ++struct _GstInterleave ++{ ++ GstElement element; ++ ++ /*< private >*/ ++ GstCollectPads *collect; ++ ++ gint channels; ++ gint padcounter; ++ gint rate; ++ gint width; ++ ++ GValueArray *channel_positions; ++ GValueArray *input_channel_positions; ++ gboolean channel_positions_from_input; ++ ++ GstCaps *sinkcaps; ++ ++ GstClockTime timestamp; ++ guint64 offset; ++ ++ gboolean segment_pending; ++ guint64 segment_position; ++ gdouble segment_rate; ++ GstSegment segment; ++ ++ GstPadEventFunction collect_event; ++ ++ GstInterleaveFunc func; ++ ++ GstPad *src; ++}; ++ ++ ++GstInterleaveClass ++struct _GstInterleaveClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_interleave_get_type ++GType ++void ++ ++ ++GST_TYPE_LEVEL ++#define GST_TYPE_LEVEL \ ++ (gst_level_get_type()) ++ ++ ++GST_LEVEL ++#define GST_LEVEL(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_LEVEL,GstLevel)) ++ ++ ++GST_LEVEL_CLASS ++#define GST_LEVEL_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_LEVEL,GstLevelClass)) ++ ++ ++GST_LEVEL_GET_CLASS ++#define GST_LEVEL_GET_CLASS(obj) \ ++ (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_LEVEL,GstLevelClass)) ++ ++ ++GST_IS_LEVEL ++#define GST_IS_LEVEL(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_LEVEL)) ++ ++ ++GST_IS_LEVEL_CLASS ++#define GST_IS_LEVEL_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_LEVEL)) ++ ++ ++GstLevel ++ ++ ++GstLevelClass ++ ++ ++GstLevel ++struct _GstLevel { ++ GstBaseTransform element; ++ ++ gboolean message; /* whether or not to post messages */ ++ guint64 interval; /* how many seconds between emits */ ++ ++ gint rate; /* caps variables */ ++ gint width; ++ gint channels; ++ ++ gdouble decay_peak_ttl; /* time to live for peak in seconds */ ++ gdouble decay_peak_falloff; /* falloff in dB/sec */ ++ gint num_frames; /* frame count (1 sample per channel) ++ * since last emit */ ++ gint interval_frames; /* after how many frame to sent a message */ ++ GstClockTime message_ts; /* starttime for next message */ ++ ++ /* per-channel arrays for intermediate values */ ++ gdouble *CS; /* normalized Cumulative Square */ ++ gdouble *peak; /* normalized Peak value over buffer */ ++ gdouble *last_peak; /* last normalized Peak value over interval */ ++ gdouble *decay_peak; /* running decaying normalized Peak */ ++ gdouble *decay_peak_base; /* value of last peak we are decaying from */ ++ gdouble *MS; /* normalized Mean Square of buffer */ ++ gdouble *RMS_dB; /* RMS in dB to emit */ ++ GstClockTime *decay_peak_age; /* age of last peak */ ++ ++ void (*process)(gpointer, guint, guint, gdouble*, gdouble*); ++}; ++ ++ ++GstLevelClass ++struct _GstLevelClass { ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_level_get_type ++GType ++void ++ ++ ++GST_TYPE_MATROSKA_DEMUX ++#define GST_TYPE_MATROSKA_DEMUX \ ++ (gst_matroska_demux_get_type ()) ++ ++ ++GST_MATROSKA_DEMUX ++#define GST_MATROSKA_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MATROSKA_DEMUX, GstMatroskaDemux)) ++ ++ ++GST_MATROSKA_DEMUX_CLASS ++#define GST_MATROSKA_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_MATROSKA_DEMUX, GstMatroskaDemuxClass)) ++ ++ ++GST_IS_MATROSKA_DEMUX ++#define GST_IS_MATROSKA_DEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MATROSKA_DEMUX)) ++ ++ ++GST_IS_MATROSKA_DEMUX_CLASS ++#define GST_IS_MATROSKA_DEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MATROSKA_DEMUX)) ++ ++ ++GstMatroskaDemuxState ++typedef enum { ++ GST_MATROSKA_DEMUX_STATE_START, ++ GST_MATROSKA_DEMUX_STATE_SEGMENT, ++ GST_MATROSKA_DEMUX_STATE_HEADER, ++ GST_MATROSKA_DEMUX_STATE_DATA, ++ GST_MATROSKA_DEMUX_STATE_SEEK, ++ GST_MATROSKA_DEMUX_STATE_SCANNING ++} GstMatroskaDemuxState; ++ ++ ++GstMatroskaDemux ++typedef struct _GstMatroskaDemux { ++ GstElement parent; ++ ++ /* < private > */ ++ ++ GstIndex *element_index; ++ gint element_index_writer_id; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ GPtrArray *src; ++ GstClock *clock; ++ guint num_streams; ++ guint num_v_streams; ++ guint num_a_streams; ++ guint num_t_streams; ++ ++ /* metadata */ ++ gchar *muxing_app; ++ gchar *writing_app; ++ gint64 created; ++ ++ /* state */ ++ gboolean streaming; ++ GstMatroskaDemuxState state; ++ guint level_up; ++ guint64 seek_block; ++ gboolean seek_first; ++ ++ /* did we parse cues/tracks/segmentinfo already? */ ++ gboolean index_parsed; ++ gboolean tracks_parsed; ++ gboolean segmentinfo_parsed; ++ gboolean attachments_parsed; ++ GList *tags_parsed; ++ GList *seek_parsed; ++ ++ /* start-of-segment */ ++ guint64 ebml_segment_start; ++ ++ /* a cue (index) table */ ++ GArray *index; ++ ++ /* timescale in the file */ ++ guint64 time_scale; ++ ++ /* keeping track of playback position */ ++ GstSegment segment; ++ gboolean segment_running; ++ GstClockTime last_stop_end; ++ ++ GstEvent *close_segment; ++ GstEvent *new_segment; ++ GstTagList *global_tags; ++ ++ /* pull mode caching */ ++ GstBuffer *cached_buffer; ++ ++ /* push and pull mode */ ++ guint64 offset; ++ /* some state saving */ ++ GstClockTime cluster_time; ++ guint64 cluster_offset; ++ guint64 first_cluster_offset; ++ ++ /* push based mode usual suspects */ ++ GstAdapter *adapter; ++ /* index stuff */ ++ gboolean seekable; ++ gboolean building_index; ++ guint64 index_offset; ++ GstEvent *seek_event; ++ gboolean need_newsegment; ++ ++ /* reverse playback */ ++ GArray *seek_index; ++ gint seek_entry; ++} GstMatroskaDemux; ++ ++ ++GstMatroskaDemuxClass ++typedef struct _GstMatroskaDemuxClass { ++ GstElementClass parent; ++} GstMatroskaDemuxClass; ++ ++ ++gst_matroska_demux_plugin_init ++gboolean ++GstPlugin *plugin ++ ++ ++GST_TYPE_MATROSKA_MUX ++#define GST_TYPE_MATROSKA_MUX \ ++ (gst_matroska_mux_get_type ()) ++ ++ ++GST_MATROSKA_MUX ++#define GST_MATROSKA_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MATROSKA_MUX, GstMatroskaMux)) ++ ++ ++GST_MATROSKA_MUX_CLASS ++#define GST_MATROSKA_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_MATROSKA_MUX, GstMatroskaMuxClass)) ++ ++ ++GST_IS_MATROSKA_MUX ++#define GST_IS_MATROSKA_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MATROSKA_MUX)) ++ ++ ++GST_IS_MATROSKA_MUX_CLASS ++#define GST_IS_MATROSKA_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MATROSKA_MUX)) ++ ++ ++GstMatroskaMuxState ++typedef enum { ++ GST_MATROSKA_MUX_STATE_START, ++ GST_MATROSKA_MUX_STATE_HEADER, ++ GST_MATROSKA_MUX_STATE_DATA, ++} GstMatroskaMuxState; ++ ++ ++GstMatroskaMetaSeekIndex ++typedef struct _GstMatroskaMetaSeekIndex { ++ guint32 id; ++ guint64 pos; ++} GstMatroskaMetaSeekIndex; ++ ++ ++GstMatroskaMux ++typedef struct _GstMatroskaMux { ++ GstElement element; ++ ++ /* < private > */ ++ ++ /* pads */ ++ GstPad *srcpad; ++ GstCollectPads *collect; ++ GstPadEventFunction collect_event; ++ GstEbmlWrite *ebml_write; ++ ++ guint num_streams, ++ num_v_streams, num_a_streams, num_t_streams; ++ ++ /* Application name (for the writing application header element) */ ++ gchar *writing_app; ++ ++ /* EBML DocType. */ ++ const gchar *doctype; ++ ++ /* DocType version. */ ++ guint doctype_version; ++ ++ /* state */ ++ GstMatroskaMuxState state; ++ ++ /* a cue (index) table */ ++ GstMatroskaIndex *index; ++ guint num_indexes; ++ GstClockTimeDiff min_index_interval; ++ gboolean streamable; ++ ++ /* timescale in the file */ ++ guint64 time_scale; ++ /* based on timescale, limit of nanoseconds you can have in a cluster */ ++ guint64 max_cluster_duration; ++ ++ /* length, position (time, ns) */ ++ guint64 duration; ++ ++ /* byte-positions of master-elements (for replacing contents) */ ++ guint64 segment_pos, ++ seekhead_pos, ++ cues_pos, ++ tags_pos, ++ info_pos, ++ tracks_pos, ++ duration_pos, ++ meta_pos; ++ guint64 segment_master; ++ ++ /* current cluster */ ++ guint64 cluster, ++ cluster_time, ++ cluster_pos, ++ prev_cluster_size; ++ ++} GstMatroskaMux; ++ ++ ++GstMatroskaMuxClass ++typedef struct _GstMatroskaMuxClass { ++ GstElementClass parent; ++} GstMatroskaMuxClass; ++ ++ ++gst_matroska_mux_get_type ++GType ++void ++ ++ ++GST_TYPE_WEBM_MUX ++#define GST_TYPE_WEBM_MUX \ ++ (gst_webm_mux_get_type ()) ++ ++ ++GST_WEBM_MUX ++#define GST_WEBM_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_WEBM_MUX, GstWebMMux)) ++ ++ ++GST_WEBM_MUX_CLASS ++#define GST_WEBM_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_WEBM_MUX, GstWebMMuxClass)) ++ ++ ++GST_IS_WEBM_MUX ++#define GST_IS_WEBM_MUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_WEBM_MUX)) ++ ++ ++GST_IS_WEBM_MUX_CLASS ++#define GST_IS_WEBM_MUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_WEBM_MUX)) ++ ++ ++GstWebMMux ++ ++ ++GstWebMMuxClass ++ ++ ++GstWebMMux ++struct _GstWebMMux { ++ GstMatroskaMux matroskamux; ++}; ++ ++ ++GstWebMMuxClass ++struct _GstWebMMuxClass { ++ GstMatroskaMuxClass matroskamuxclass; ++}; ++ ++ ++gst_webm_mux_get_type ++GType ++void ++ ++ ++GST_TYPE_MONOSCOPE ++#define GST_TYPE_MONOSCOPE (gst_monoscope_get_type()) ++ ++ ++GST_MONOSCOPE ++#define GST_MONOSCOPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MONOSCOPE,GstMonoscope)) ++ ++ ++GST_MONOSCOPE_CLASS ++#define GST_MONOSCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MONOSCOPE,GstMonoscopeClass)) ++ ++ ++GST_IS_MONOSCOPE ++#define GST_IS_MONOSCOPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MONOSCOPE)) ++ ++ ++GST_IS_MONOSCOPE_CLASS ++#define GST_IS_MONOSCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MONOSCOPE)) ++ ++ ++GstMonoscope ++ ++ ++GstMonoscopeClass ++ ++ ++GstMonoscope ++struct _GstMonoscope ++{ ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ GstAdapter *adapter; ++ ++ guint64 next_ts; /* expected timestamp of the next frame */ ++ guint64 frame_duration; /* video frame duration */ ++ gint rate; /* sample rate */ ++ guint bps; /* bytes per sample */ ++ guint spf; /* samples per video frame */ ++ ++ GstSegment segment; ++ ++ /* QoS stuff *//* with LOCK */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++ ++ /* video state */ ++ gint fps_num; ++ gint fps_denom; ++ gint width; ++ gint height; ++ guint outsize; ++ ++ /* visualisation state */ ++ struct monoscope_state *visstate; ++}; ++ ++ ++GstMonoscopeClass ++struct _GstMonoscopeClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_monoscope_get_type ++GType ++void ++ ++ ++GST_TYPE_MULTI_FILE_SINK ++#define GST_TYPE_MULTI_FILE_SINK \ ++ (gst_multi_file_sink_get_type()) ++ ++ ++GST_MULTI_FILE_SINK ++#define GST_MULTI_FILE_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTI_FILE_SINK,GstMultiFileSink)) ++ ++ ++GST_MULTI_FILE_SINK_CLASS ++#define GST_MULTI_FILE_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTI_FILE_SINK,GstMultiFileSinkClass)) ++ ++ ++GST_IS_MULTI_FILE_SINK ++#define GST_IS_MULTI_FILE_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTI_FILE_SINK)) ++ ++ ++GST_IS_MULTI_FILE_SINK_CLASS ++#define GST_IS_MULTI_FILE_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTI_FILE_SINK)) ++ ++ ++GstMultiFileSink ++ ++ ++GstMultiFileSinkClass ++ ++ ++GstMultiFileSinkNext ++typedef enum { ++ GST_MULTI_FILE_SINK_NEXT_BUFFER, ++ GST_MULTI_FILE_SINK_NEXT_DISCONT, ++ GST_MULTI_FILE_SINK_NEXT_KEY_FRAME ++} GstMultiFileSinkNext; ++ ++ ++GstMultiFileSink ++struct _GstMultiFileSink ++{ ++ GstBaseSink parent; ++ ++ gchar *filename; ++ gint index; ++ gboolean post_messages; ++ GstMultiFileSinkNext next_file; ++ FILE *file; ++ ++ gint64 next_segment; ++}; ++ ++ ++GstMultiFileSinkClass ++struct _GstMultiFileSinkClass ++{ ++ GstBaseSinkClass parent_class; ++}; ++ ++ ++gst_multi_file_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_MULTI_FILE_SRC ++#define GST_TYPE_MULTI_FILE_SRC \ ++ (gst_multi_file_src_get_type()) ++ ++ ++GST_MULTI_FILE_SRC ++#define GST_MULTI_FILE_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTI_FILE_SRC,GstMultiFileSrc)) ++ ++ ++GST_MULTI_FILE_SRC_CLASS ++#define GST_MULTI_FILE_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTI_FILE_SRC,GstMultiFileSrcClass)) ++ ++ ++GST_IS_MULTI_FILE_SRC ++#define GST_IS_MULTI_FILE_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTI_FILE_SRC)) ++ ++ ++GST_IS_MULTI_FILE_SRC_CLASS ++#define GST_IS_MULTI_FILE_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTI_FILE_SRC)) ++ ++ ++GstMultiFileSrc ++ ++ ++GstMultiFileSrcClass ++ ++ ++GstMultiFileSrc ++struct _GstMultiFileSrc ++{ ++ GstPushSrc parent; ++ ++ gchar *filename; ++ int index; ++ ++ int offset; ++ ++ GstCaps *caps; ++ gboolean successful_read; ++}; ++ ++ ++GstMultiFileSrcClass ++struct _GstMultiFileSrcClass ++{ ++ GstPushSrcClass parent_class; ++}; ++ ++ ++gst_multi_file_src_get_type ++GType ++void ++ ++ ++GST_TYPE_MULTIPART_DEMUX ++#define GST_TYPE_MULTIPART_DEMUX (gst_multipart_demux_get_type()) ++ ++ ++GST_MULTIPART_DEMUX ++#define GST_MULTIPART_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTIPART_DEMUX, GstMultipartDemux)) ++ ++ ++GST_MULTIPART_DEMUX_CLASS ++#define GST_MULTIPART_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTIPART_DEMUX, GstMultipartDemux)) ++ ++ ++GST_MULTIPART_DEMUX_GET_CLASS ++#define GST_MULTIPART_DEMUX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_MULTIPART_DEMUX, GstMultipartDemuxClass)) ++ ++ ++GST_IS_MULTIPART_DEMUX ++#define GST_IS_MULTIPART_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTIPART_DEMUX)) ++ ++ ++GST_IS_MULTIPART_DEMUX_CLASS ++#define GST_IS_MULTIPART_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTIPART_DEMUX)) ++ ++ ++GstMultipartDemux ++ ++ ++GstMultipartDemuxClass ++ ++ ++MULTIPART_NEED_MORE_DATA ++#define MULTIPART_NEED_MORE_DATA -1 ++ ++ ++MULTIPART_DATA_ERROR ++#define MULTIPART_DATA_ERROR -2 ++ ++ ++MULTIPART_DATA_EOS ++#define MULTIPART_DATA_EOS -3 ++ ++ ++GstMultipartDemux ++struct _GstMultipartDemux ++{ ++ GstElement element; ++ ++ /* pad */ ++ GstPad *sinkpad; ++ ++ GSList *srcpads; ++ gint numpads; ++ ++ GstAdapter *adapter; ++ ++ /* Header information of the current frame */ ++ gboolean header_completed; ++ gchar *boundary; ++ guint boundary_len; ++ gchar *mime_type; ++ gint content_length; ++ ++ /* deprecated, unused */ ++ gboolean autoscan; ++ ++ /* Index inside the current data when manually looking for the boundary */ ++ gint scanpos; ++}; ++ ++ ++GstMultipartDemuxClass ++struct _GstMultipartDemuxClass ++{ ++ GstElementClass parent_class; ++ ++ GHashTable *gstnames; ++}; ++ ++ ++gst_multipart_demux_get_type ++GType ++void ++ ++ ++gst_multipart_demux_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_MULTIPART_MUX ++#define GST_TYPE_MULTIPART_MUX (gst_multipart_mux_get_type()) ++ ++ ++GST_MULTIPART_MUX ++#define GST_MULTIPART_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTIPART_MUX, GstMultipartMux)) ++ ++ ++GST_MULTIPART_MUX_CLASS ++#define GST_MULTIPART_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTIPART_MUX, GstMultipartMux)) ++ ++ ++GST_MULTIPART_MUX_GET_CLASS ++#define GST_MULTIPART_MUX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_MULTIPART_MUX, GstMultipartMuxClass)) ++ ++ ++GST_IS_MULTIPART_MUX ++#define GST_IS_MULTIPART_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTIPART_MUX)) ++ ++ ++GST_IS_MULTIPART_MUX_CLASS ++#define GST_IS_MULTIPART_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTIPART_MUX)) ++ ++ ++GstMultipartMux ++ ++ ++GstMultipartMuxClass ++ ++ ++GstMultipartMux ++struct _GstMultipartMux ++{ ++ GstElement element; ++ ++ /* pad */ ++ GstPad *srcpad; ++ ++ /* sinkpads */ ++ GstCollectPads *collect; ++ ++ gint numpads; ++ ++ /* offset in stream */ ++ guint64 offset; ++ ++ /* boundary string */ ++ gchar *boundary; ++ ++ gboolean negotiated; ++ gboolean need_segment; ++}; ++ ++ ++GstMultipartMuxClass ++struct _GstMultipartMuxClass ++{ ++ GstElementClass parent_class; ++ ++ GHashTable *mimetypes; ++}; ++ ++ ++gst_multipart_mux_get_type ++GType ++void ++ ++ ++gst_multipart_mux_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_CAT_DEFAULT ++#define GST_CAT_DEFAULT qtdemux_debug ++ ++ ++GST_TYPE_QTDEMUX ++#define GST_TYPE_QTDEMUX \ ++ (gst_qtdemux_get_type()) ++ ++ ++GST_QTDEMUX ++#define GST_QTDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QTDEMUX,GstQTDemux)) ++ ++ ++GST_QTDEMUX_CLASS ++#define GST_QTDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QTDEMUX,GstQTDemuxClass)) ++ ++ ++GST_IS_QTDEMUX ++#define GST_IS_QTDEMUX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QTDEMUX)) ++ ++ ++GST_IS_QTDEMUX_CLASS ++#define GST_IS_QTDEMUX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QTDEMUX)) ++ ++ ++GST_QTDEMUX_CAST ++#define GST_QTDEMUX_CAST(obj) ((GstQTDemux *)(obj)) ++ ++ ++GST_QT_DEMUX_PRIVATE_TAG ++#define GST_QT_DEMUX_PRIVATE_TAG "private-qt-tag" ++ ++ ++GST_QT_DEMUX_CLASSIFICATION_TAG ++#define GST_QT_DEMUX_CLASSIFICATION_TAG "classification" ++ ++ ++GST_QTDEMUX_MAX_STREAMS ++#define GST_QTDEMUX_MAX_STREAMS 8 ++ ++ ++GstQTDemux ++ ++ ++GstQTDemuxClass ++ ++ ++QtDemuxStream ++ ++ ++GstQTDemux ++struct _GstQTDemux { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *sinkpad; ++ ++ QtDemuxStream *streams[GST_QTDEMUX_MAX_STREAMS]; ++ gint n_streams; ++ gint n_video_streams; ++ gint n_audio_streams; ++ gint n_sub_streams; ++ ++ guint major_brand; ++ GstBuffer *comp_brands; ++ GNode *moov_node; ++ GNode *moov_node_compressed; ++ ++ guint32 timescale; ++ guint64 duration; ++ ++ gint state; ++ ++ gboolean pullbased; ++ gboolean posted_redirect; ++ ++ /* push based variables */ ++ guint neededbytes; ++ guint todrop; ++ GstAdapter *adapter; ++ GstBuffer *mdatbuffer; ++ ++ /* offset of the media data (i.e.: Size of header) */ ++ guint64 offset; ++ /* offset of the mdat atom */ ++ guint64 mdatoffset; ++ guint64 first_mdat; ++ gboolean got_moov; ++ ++ GstTagList *tag_list; ++ ++ /* configured playback region */ ++ GstSegment segment; ++ gboolean segment_running; ++ GstEvent *pending_newsegment; ++ ++ /* gst index support */ ++ GstIndex *element_index; ++ gint index_id; ++ ++ gint64 requested_seek_time; ++ guint64 seek_offset; ++}; ++ ++ ++GstQTDemuxClass ++struct _GstQTDemuxClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_qtdemux_get_type ++GType ++void ++ ++ ++GST_TYPE_RG_ANALYSIS ++#define GST_TYPE_RG_ANALYSIS \ ++ (gst_rg_analysis_get_type()) ++ ++ ++GST_RG_ANALYSIS ++#define GST_RG_ANALYSIS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RG_ANALYSIS,GstRgAnalysis)) ++ ++ ++GST_RG_ANALYSIS_CLASS ++#define GST_RG_ANALYSIS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RG_ANALYSIS,GstRgAnalysisClass)) ++ ++ ++GST_IS_RG_ANALYSIS ++#define GST_IS_RG_ANALYSIS(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RG_ANALYSIS)) ++ ++ ++GST_IS_RG_ANALYSIS_CLASS ++#define GST_IS_RG_ANALYSIS_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RG_ANALYSIS)) ++ ++ ++GstRgAnalysis ++ ++ ++GstRgAnalysisClass ++ ++ ++GstRgAnalysis ++struct _GstRgAnalysis ++{ ++ GstBaseTransform element; ++ ++ /*< private >*/ ++ ++ RgAnalysisCtx *ctx; ++ void (*analyze) (RgAnalysisCtx * ctx, gconstpointer data, gsize size, ++ guint depth); ++ gint depth; ++ ++ /* Property values. */ ++ guint num_tracks; ++ gdouble reference_level; ++ gboolean forced; ++ gboolean message; ++ ++ /* State machinery for skipping. */ ++ gboolean ignore_tags; ++ gboolean skip; ++ gboolean has_track_gain; ++ gboolean has_track_peak; ++ gboolean has_album_gain; ++ gboolean has_album_peak; ++}; ++ ++ ++GstRgAnalysisClass ++struct _GstRgAnalysisClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_rg_analysis_get_type ++GType ++void ++ ++ ++GST_TYPE_RG_LIMITER ++#define GST_TYPE_RG_LIMITER \ ++ (gst_rg_limiter_get_type()) ++ ++ ++GST_RG_LIMITER ++#define GST_RG_LIMITER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RG_LIMITER,GstRgLimiter)) ++ ++ ++GST_RG_LIMITER_CLASS ++#define GST_RG_LIMITER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RG_LIMITER,GstRgLimiterClass)) ++ ++ ++GST_IS_RG_LIMITER ++#define GST_IS_RG_LIMITER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RG_LIMITER)) ++ ++ ++GST_IS_RG_LIMITER_CLASS ++#define GST_IS_RG_LIMITER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RG_LIMITER)) ++ ++ ++GstRgLimiter ++ ++ ++GstRgLimiterClass ++ ++ ++GstRgLimiter ++struct _GstRgLimiter ++{ ++ GstBaseTransform element; ++ ++ /*< private >*/ ++ ++ gboolean enabled; ++}; ++ ++ ++GstRgLimiterClass ++struct _GstRgLimiterClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_rg_limiter_get_type ++GType ++void ++ ++ ++GST_TYPE_RG_VOLUME ++#define GST_TYPE_RG_VOLUME \ ++ (gst_rg_volume_get_type()) ++ ++ ++GST_RG_VOLUME ++#define GST_RG_VOLUME(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RG_VOLUME,GstRgVolume)) ++ ++ ++GST_RG_VOLUME_CLASS ++#define GST_RG_VOLUME_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RG_VOLUME,GstRgVolumeClass)) ++ ++ ++GST_IS_RG_VOLUME ++#define GST_IS_RG_VOLUME(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RG_VOLUME)) ++ ++ ++GST_IS_RG_VOLUME_CLASS ++#define GST_IS_RG_VOLUME_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RG_VOLUME)) ++ ++ ++GstRgVolume ++ ++ ++GstRgVolumeClass ++ ++ ++GstRgVolume ++struct _GstRgVolume ++{ ++ GstBin bin; ++ ++ /*< private >*/ ++ ++ GstElement *volume_element; ++ gdouble max_volume; ++ ++ gboolean album_mode; ++ gdouble headroom; ++ gdouble pre_amp; ++ gdouble fallback_gain; ++ ++ gdouble target_gain; ++ gdouble result_gain; ++ ++ gdouble track_gain; ++ gdouble track_peak; ++ gdouble album_gain; ++ gdouble album_peak; ++ ++ gboolean has_track_gain; ++ gboolean has_track_peak; ++ gboolean has_album_gain; ++ gboolean has_album_peak; ++ ++ gdouble reference_level; ++}; ++ ++ ++GstRgVolumeClass ++struct _GstRgVolumeClass ++{ ++ GstBinClass parent_class; ++}; ++ ++ ++gst_rg_volume_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_J2K_PAY ++#define GST_TYPE_RTP_J2K_PAY \ ++ (gst_rtp_j2k_pay_get_type()) ++ ++ ++GST_RTP_J2K_PAY ++#define GST_RTP_J2K_PAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_J2K_PAY,GstRtpJ2KPay)) ++ ++ ++GST_RTP_J2K_PAY_CLASS ++#define GST_RTP_J2K_PAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_J2K_PAY,GstRtpJ2KPayClass)) ++ ++ ++GST_IS_RTP_J2K_PAY ++#define GST_IS_RTP_J2K_PAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_J2K_PAY)) ++ ++ ++GST_IS_RTP_J2K_PAY_CLASS ++#define GST_IS_RTP_J2K_PAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_J2K_PAY)) ++ ++ ++GstRtpJ2KPay ++ ++ ++GstRtpJ2KPayClass ++ ++ ++GstRtpJ2KPay ++struct _GstRtpJ2KPay ++{ ++ GstBaseRTPPayload payload; ++ ++ gint height; ++ gint width; ++}; ++ ++ ++GstRtpJ2KPayClass ++struct _GstRtpJ2KPayClass ++{ ++ GstBaseRTPPayloadClass parent_class; ++}; ++ ++ ++gst_rtp_j2k_pay_get_type ++GType ++void ++ ++ ++gst_rtp_j2k_pay_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_RTP_JPEG_PAY ++#define GST_TYPE_RTP_JPEG_PAY \ ++ (gst_rtp_jpeg_pay_get_type()) ++ ++ ++GST_RTP_JPEG_PAY ++#define GST_RTP_JPEG_PAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_JPEG_PAY,GstRtpJPEGPay)) ++ ++ ++GST_RTP_JPEG_PAY_CLASS ++#define GST_RTP_JPEG_PAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_JPEG_PAY,GstRtpJPEGPayClass)) ++ ++ ++GST_IS_RTP_JPEG_PAY ++#define GST_IS_RTP_JPEG_PAY(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_JPEG_PAY)) ++ ++ ++GST_IS_RTP_JPEG_PAY_CLASS ++#define GST_IS_RTP_JPEG_PAY_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_JPEG_PAY)) ++ ++ ++GstRtpJPEGPay ++ ++ ++GstRtpJPEGPayClass ++ ++ ++GstRtpJPEGPay ++struct _GstRtpJPEGPay ++{ ++ GstBaseRTPPayload payload; ++ ++ guint8 quality; ++ guint8 type; ++ ++ gint height; ++ gint width; ++ ++ gboolean buffer_list; ++ ++ guint8 quant; ++}; ++ ++ ++GstRtpJPEGPayClass ++struct _GstRtpJPEGPayClass ++{ ++ GstBaseRTPPayloadClass parent_class; ++}; ++ ++ ++gst_rtp_jpeg_pay_get_type ++GType ++void ++ ++ ++gst_rtp_jpeg_pay_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_RTP_BIN ++#define GST_TYPE_RTP_BIN \ ++ (gst_rtp_bin_get_type()) ++ ++ ++GST_RTP_BIN ++#define GST_RTP_BIN(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_BIN,GstRtpBin)) ++ ++ ++GST_RTP_BIN_CLASS ++#define GST_RTP_BIN_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_BIN,GstRtpBinClass)) ++ ++ ++GST_IS_RTP_BIN ++#define GST_IS_RTP_BIN(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_BIN)) ++ ++ ++GST_IS_RTP_BIN_CLASS ++#define GST_IS_RTP_BIN_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_BIN)) ++ ++ ++GstRtpBin ++ ++ ++GstRtpBinClass ++ ++ ++GstRtpBinPrivate ++ ++ ++GstRtpBin ++struct _GstRtpBin { ++ GstBin bin; ++ ++ /*< private >*/ ++ /* default latency for sessions */ ++ guint latency_ms; ++ guint64 latency_ns; ++ gboolean do_lost; ++ gboolean ignore_pt; ++ RTPJitterBufferMode buffer_mode; ++ gboolean buffering; ++ GstClockTime buffer_start; ++ /* a list of session */ ++ GSList *sessions; ++ ++ /* a list of clients, these are streams with the same CNAME */ ++ GSList *clients; ++ ++ /* the default SDES items for sessions */ ++ GstStructure *sdes; ++ ++ /*< private >*/ ++ GstRtpBinPrivate *priv; ++}; ++ ++ ++GstRtpBinClass ++struct _GstRtpBinClass { ++ GstBinClass parent_class; ++ ++ /* get the caps for pt */ ++ GstCaps* (*request_pt_map) (GstRtpBin *rtpbin, guint session, guint pt); ++ ++ void (*payload_type_change) (GstRtpBin *rtpbin, guint session, guint pt); ++ ++ /* action signals */ ++ void (*clear_pt_map) (GstRtpBin *rtpbin); ++ void (*reset_sync) (GstRtpBin *rtpbin); ++ RTPSession* (*get_internal_session) (GstRtpBin *rtpbin, guint session_id); ++ ++ /* session manager signals */ ++ void (*on_new_ssrc) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_ssrc_collision) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_ssrc_validated) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_ssrc_active) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_ssrc_sdes) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_bye_ssrc) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_bye_timeout) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_timeout) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_sender_timeout) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++ void (*on_npt_stop) (GstRtpBin *rtpbin, guint session, guint32 ssrc); ++}; ++ ++ ++gst_rtp_bin_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_JITTER_BUFFER ++#define GST_TYPE_RTP_JITTER_BUFFER \ ++ (gst_rtp_jitter_buffer_get_type()) ++ ++ ++GST_RTP_JITTER_BUFFER ++#define GST_RTP_JITTER_BUFFER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), \ ++ GST_TYPE_RTP_JITTER_BUFFER,GstRtpJitterBuffer)) ++ ++ ++GST_RTP_JITTER_BUFFER_CLASS ++#define GST_RTP_JITTER_BUFFER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), \ ++ GST_TYPE_RTP_JITTER_BUFFER,GstRtpJitterBufferClass)) ++ ++ ++GST_IS_RTP_JITTER_BUFFER ++#define GST_IS_RTP_JITTER_BUFFER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_JITTER_BUFFER)) ++ ++ ++GST_IS_RTP_JITTER_BUFFER_CLASS ++#define GST_IS_RTP_JITTER_BUFFER_CLASS(obj) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_JITTER_BUFFER)) ++ ++ ++GstRtpJitterBuffer ++ ++ ++GstRtpJitterBufferClass ++ ++ ++GstRtpJitterBufferPrivate ++ ++ ++GstRtpJitterBuffer ++struct _GstRtpJitterBuffer ++{ ++ GstElement parent; ++ ++ /*< private >*/ ++ GstRtpJitterBufferPrivate *priv; /* FIXME: remove? */ ++}; ++ ++ ++GstRtpJitterBufferClass ++struct _GstRtpJitterBufferClass ++{ ++ GstElementClass parent_class; ++ ++ /* signals */ ++ GstCaps* (*request_pt_map) (GstRtpJitterBuffer *buffer, guint pt); ++ ++ void (*handle_sync) (GstRtpJitterBuffer *buffer, GstStructure *s); ++ void (*on_npt_stop) (GstRtpJitterBuffer *buffer); ++ ++ /* actions */ ++ void (*clear_pt_map) (GstRtpJitterBuffer *buffer); ++ ++ GstClockTime (*set_active) (GstRtpJitterBuffer *buffer, gboolean active, guint64 elapsed); ++}; ++ ++ ++gst_rtp_jitter_buffer_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_PT_DEMUX ++#define GST_TYPE_RTP_PT_DEMUX (gst_rtp_pt_demux_get_type()) ++ ++ ++GST_RTP_PT_DEMUX ++#define GST_RTP_PT_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_PT_DEMUX,GstRtpPtDemux)) ++ ++ ++GST_RTP_PT_DEMUX_CLASS ++#define GST_RTP_PT_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_PT_DEMUX,GstRtpPtDemuxClass)) ++ ++ ++GST_IS_RTP_PT_DEMUX ++#define GST_IS_RTP_PT_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_PT_DEMUX)) ++ ++ ++GST_IS_RTP_PT_DEMUX_CLASS ++#define GST_IS_RTP_PT_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_PT_DEMUX)) ++ ++ ++GstRtpPtDemux ++ ++ ++GstRtpPtDemuxClass ++ ++ ++GstRtpPtDemuxPad ++ ++ ++GstRtpPtDemux ++struct _GstRtpPtDemux ++{ ++ GstElement parent; /**< parent class */ ++ ++ GstPad *sink; /**< the sink pad */ ++ guint16 last_pt; /**< pt of the last packet 0xFFFF if none */ ++ GSList *srcpads; /**< a linked list of GstRtpPtDemuxPad objects */ ++}; ++ ++ ++GstRtpPtDemuxClass ++struct _GstRtpPtDemuxClass ++{ ++ GstElementClass parent_class; ++ ++ /* get the caps for pt */ ++ GstCaps* (*request_pt_map) (GstRtpPtDemux *demux, guint pt); ++ ++ /* signal emmited when a new PT is found from the incoming stream */ ++ void (*new_payload_type) (GstRtpPtDemux *demux, guint pt, GstPad * pad); ++ ++ /* signal emitted when the payload type changes */ ++ void (*payload_type_change) (GstRtpPtDemux *demux, guint pt); ++ ++ void (*clear_pt_map) (GstRtpPtDemux *demux); ++}; ++ ++ ++gst_rtp_pt_demux_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_SESSION ++#define GST_TYPE_RTP_SESSION \ ++ (gst_rtp_session_get_type()) ++ ++ ++GST_RTP_SESSION ++#define GST_RTP_SESSION(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SESSION,GstRtpSession)) ++ ++ ++GST_RTP_SESSION_CLASS ++#define GST_RTP_SESSION_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SESSION,GstRtpSessionClass)) ++ ++ ++GST_IS_RTP_SESSION ++#define GST_IS_RTP_SESSION(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_SESSION)) ++ ++ ++GST_IS_RTP_SESSION_CLASS ++#define GST_IS_RTP_SESSION_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_SESSION)) ++ ++ ++GST_RTP_SESSION_CAST ++#define GST_RTP_SESSION_CAST(obj) ((GstRtpSession *)(obj)) ++ ++ ++GstRtpSession ++ ++ ++GstRtpSessionClass ++ ++ ++GstRtpSessionPrivate ++ ++ ++GstRtpSession ++struct _GstRtpSession { ++ GstElement element; ++ ++ /*< private >*/ ++ GstPad *recv_rtp_sink; ++ GstSegment recv_rtp_seg; ++ GstPad *recv_rtcp_sink; ++ GstPad *send_rtp_sink; ++ GstSegment send_rtp_seg; ++ ++ GstPad *recv_rtp_src; ++ GstPad *sync_src; ++ GstPad *send_rtp_src; ++ GstPad *send_rtcp_src; ++ ++ GstRtpSessionPrivate *priv; ++}; ++ ++ ++GstRtpSessionClass ++struct _GstRtpSessionClass { ++ GstElementClass parent_class; ++ ++ /* signals */ ++ GstCaps* (*request_pt_map) (GstRtpSession *sess, guint pt); ++ void (*clear_pt_map) (GstRtpSession *sess); ++ ++ void (*on_new_ssrc) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_ssrc_collision) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_ssrc_validated) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_ssrc_active) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_ssrc_sdes) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_bye_ssrc) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_bye_timeout) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_timeout) (GstRtpSession *sess, guint32 ssrc); ++ void (*on_sender_timeout) (GstRtpSession *sess, guint32 ssrc); ++}; ++ ++ ++gst_rtp_session_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_SSRC_DEMUX ++#define GST_TYPE_RTP_SSRC_DEMUX (gst_rtp_ssrc_demux_get_type()) ++ ++ ++GST_RTP_SSRC_DEMUX ++#define GST_RTP_SSRC_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SSRC_DEMUX,GstRtpSsrcDemux)) ++ ++ ++GST_RTP_SSRC_DEMUX_CLASS ++#define GST_RTP_SSRC_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SSRC_DEMUX,GstRtpSsrcDemuxClass)) ++ ++ ++GST_IS_RTP_SSRC_DEMUX ++#define GST_IS_RTP_SSRC_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_SSRC_DEMUX)) ++ ++ ++GST_IS_RTP_SSRC_DEMUX_CLASS ++#define GST_IS_RTP_SSRC_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_SSRC_DEMUX)) ++ ++ ++GstRtpSsrcDemux ++ ++ ++GstRtpSsrcDemuxClass ++ ++ ++GstRtpSsrcDemuxPad ++ ++ ++GstRtpSsrcDemux ++struct _GstRtpSsrcDemux ++{ ++ GstElement parent; ++ ++ GstSegment segment; ++ ++ GstPad *rtp_sink; ++ GstPad *rtcp_sink; ++ ++ GMutex *padlock; ++ GSList *srcpads; ++}; ++ ++ ++GstRtpSsrcDemuxClass ++struct _GstRtpSsrcDemuxClass ++{ ++ GstElementClass parent_class; ++ ++ /* signals */ ++ void (*new_ssrc_pad) (GstRtpSsrcDemux *demux, guint32 ssrc, GstPad *pad); ++ void (*removed_ssrc_pad) (GstRtpSsrcDemux *demux, guint32 ssrc, GstPad *pad); ++ ++ /* actions */ ++ void (*clear_ssrc) (GstRtpSsrcDemux *demux, guint32 ssrc); ++}; ++ ++ ++gst_rtp_ssrc_demux_get_type ++GType ++void ++ ++ ++GST_TYPE_RTP_DEC ++#define GST_TYPE_RTP_DEC (gst_rtp_dec_get_type()) ++ ++ ++GST_IS_RTP_DEC ++#define GST_IS_RTP_DEC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_DEC)) ++ ++ ++GST_IS_RTP_DEC_CLASS ++#define GST_IS_RTP_DEC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_DEC)) ++ ++ ++GST_RTP_DEC ++#define GST_RTP_DEC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_DEC, GstRTPDec)) ++ ++ ++GST_RTP_DEC_CLASS ++#define GST_RTP_DEC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_DEC, GstRTPDecClass)) ++ ++ ++GstRTPDec ++ ++ ++GstRTPDecClass ++ ++ ++GstRTPDecSession ++ ++ ++GstRTPDec ++struct _GstRTPDec { ++ GstElement element; ++ ++ guint latency; ++ GSList *sessions; ++ GstClock *provided_clock; ++}; ++ ++ ++GstRTPDecClass ++struct _GstRTPDecClass { ++ GstElementClass parent_class; ++ ++ /* get the caps for pt */ ++ GstCaps* (*request_pt_map) (GstRTPDec *rtpdec, guint session, guint pt); ++ ++ void (*clear_pt_map) (GstRTPDec *rtpdec); ++ ++ void (*on_new_ssrc) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++ void (*on_ssrc_collision) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++ void (*on_ssrc_validated) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++ void (*on_bye_ssrc) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++ void (*on_bye_timeout) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++ void (*on_timeout) (GstRTPDec *rtpdec, guint session, guint32 ssrc); ++}; ++ ++ ++gst_rtp_dec_get_type ++GType ++void ++ ++ ++GST_TYPE_RTSPSRC ++#define GST_TYPE_RTSPSRC \ ++ (gst_rtspsrc_get_type()) ++ ++ ++GST_RTSPSRC ++#define GST_RTSPSRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTSPSRC,GstRTSPSrc)) ++ ++ ++GST_RTSPSRC_CLASS ++#define GST_RTSPSRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTSPSRC,GstRTSPSrcClass)) ++ ++ ++GST_IS_RTSPSRC ++#define GST_IS_RTSPSRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTSPSRC)) ++ ++ ++GST_IS_RTSPSRC_CLASS ++#define GST_IS_RTSPSRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTSPSRC)) ++ ++ ++GST_RTSPSRC_CAST ++#define GST_RTSPSRC_CAST(obj) \ ++ ((GstRTSPSrc *)(obj)) ++ ++ ++GstRTSPSrc ++ ++ ++GstRTSPSrcClass ++ ++ ++GST_RTSP_STATE_GET_LOCK ++#define GST_RTSP_STATE_GET_LOCK(rtsp) (GST_RTSPSRC_CAST(rtsp)->state_rec_lock) ++ ++ ++GST_RTSP_STATE_LOCK ++#define GST_RTSP_STATE_LOCK(rtsp) (g_static_rec_mutex_lock (GST_RTSP_STATE_GET_LOCK(rtsp))) ++ ++ ++GST_RTSP_STATE_UNLOCK ++#define GST_RTSP_STATE_UNLOCK(rtsp) (g_static_rec_mutex_unlock (GST_RTSP_STATE_GET_LOCK(rtsp))) ++ ++ ++GST_RTSP_STREAM_GET_LOCK ++#define GST_RTSP_STREAM_GET_LOCK(rtsp) (GST_RTSPSRC_CAST(rtsp)->stream_rec_lock) ++ ++ ++GST_RTSP_STREAM_LOCK ++#define GST_RTSP_STREAM_LOCK(rtsp) (g_static_rec_mutex_lock (GST_RTSP_STREAM_GET_LOCK(rtsp))) ++ ++ ++GST_RTSP_STREAM_UNLOCK ++#define GST_RTSP_STREAM_UNLOCK(rtsp) (g_static_rec_mutex_unlock (GST_RTSP_STREAM_GET_LOCK(rtsp))) ++ ++ ++GST_RTSP_CONN_GET_LOCK ++#define GST_RTSP_CONN_GET_LOCK(rtsp) (GST_RTSPSRC_CAST(rtsp)->conn_rec_lock) ++ ++ ++GST_RTSP_CONN_LOCK ++#define GST_RTSP_CONN_LOCK(rtsp) (g_static_rec_mutex_lock (GST_RTSP_CONN_GET_LOCK(rtsp))) ++ ++ ++GST_RTSP_CONN_UNLOCK ++#define GST_RTSP_CONN_UNLOCK(rtsp) (g_static_rec_mutex_unlock (GST_RTSP_CONN_GET_LOCK(rtsp))) ++ ++ ++GstRTSPConnInfo ++ ++ ++GstRTSPConnInfo ++struct _GstRTSPConnInfo { ++ gchar *location; ++ GstRTSPUrl *url; ++ gchar *url_str; ++ GstRTSPConnection *connection; ++ gboolean connected; ++}; ++ ++ ++GstRTSPStream ++ ++ ++GstRTSPStream ++struct _GstRTSPStream { ++ gint id; ++ ++ GstRTSPSrc *parent; /* parent, no extra ref to parent is taken */ ++ ++ /* pad we expose or NULL when it does not have an actual pad */ ++ GstPad *srcpad; ++ GstFlowReturn last_ret; ++ gboolean added; ++ gboolean disabled; ++ gboolean eos; ++ gboolean discont; ++ ++ /* for interleaved mode */ ++ guint8 channel[2]; ++ GstCaps *caps; ++ GstPad *channelpad[2]; ++ ++ /* our udp sources */ ++ GstElement *udpsrc[2]; ++ GstPad *blockedpad; ++ gboolean is_ipv6; ++ ++ /* our udp sinks back to the server */ ++ GstElement *udpsink[2]; ++ GstPad *rtcppad; ++ ++ /* fakesrc for sending dummy data */ ++ GstElement *fakesrc; ++ ++ /* state */ ++ gint pt; ++ guint port; ++ gboolean container; ++ /* original control url */ ++ gchar *control_url; ++ guint32 ssrc; ++ guint32 seqbase; ++ guint64 timebase; ++ ++ /* per stream connection */ ++ GstRTSPConnInfo conninfo; ++ ++ /* bandwidth */ ++ guint as_bandwidth; ++ guint rs_bandwidth; ++ guint rr_bandwidth; ++ ++ /* destination */ ++ gchar *destination; ++ guint ttl; ++}; ++ ++ ++GstRTSPNatMethod ++typedef enum ++{ ++ GST_RTSP_NAT_NONE, ++ GST_RTSP_NAT_DUMMY ++} GstRTSPNatMethod; ++ ++ ++GstRTSPSrc ++struct _GstRTSPSrc { ++ GstBin parent; ++ ++ /* task and mutex for interleaved mode */ ++ gboolean interleaved; ++ GstTask *task; ++ GStaticRecMutex *stream_rec_lock; ++ GstSegment segment; ++ gboolean running; ++ gboolean need_range; ++ gboolean skip; ++ gint free_channel; ++ GstEvent *close_segment; ++ GstEvent *start_segment; ++ GstClockTime base_time; ++ ++ /* UDP mode loop */ ++ gint loop_cmd; ++ gboolean ignore_timeout; ++ ++ /* mutex for protecting state changes */ ++ GStaticRecMutex *state_rec_lock; ++ ++ /* mutex for protecting the connection */ ++ GStaticRecMutex *conn_rec_lock; ++ ++ GstSDPMessage *sdp; ++ gint numstreams; ++ GList *streams; ++ GstStructure *props; ++ gboolean need_activate; ++ ++ /* properties */ ++ GstRTSPLowerTrans protocols; ++ gboolean debug; ++ guint retry; ++ guint64 udp_timeout; ++ GTimeVal tcp_timeout; ++ GTimeVal *ptcp_timeout; ++ guint latency; ++ guint connection_speed; ++ GstRTSPNatMethod nat_method; ++ gboolean do_rtcp; ++ gchar *proxy_host; ++ guint proxy_port; ++ gchar *proxy_user; ++ gchar *proxy_passwd; ++ guint rtp_blocksize; ++ gchar *user_id; ++ gchar *user_pw; ++ gint buffer_mode; ++ GstRTSPRange client_port_range; ++ ++ /* state */ ++ GstRTSPState state; ++ gchar *content_base; ++ GstRTSPLowerTrans cur_protocols; ++ gboolean tried_url_auth; ++ gchar *addr; ++ gboolean need_redirect; ++ GstRTSPTimeRange *range; ++ gchar *control; ++ guint next_port_num; ++ ++ /* supported methods */ ++ gint methods; ++ ++ /* session management */ ++ GstElement *session; ++ gulong session_sig_id; ++ gulong session_ptmap_id; ++ ++ GstRTSPConnInfo conninfo; ++ ++ /* a list of RTSP extensions as GstElement */ ++ GstRTSPExtensionList *extensions; ++}; ++ ++ ++GstRTSPSrcClass ++struct _GstRTSPSrcClass { ++ GstBinClass parent_class; ++}; ++ ++ ++gst_rtspsrc_get_type ++GType ++void ++ ++ ++GST_TYPE_SHAPE_WIPE ++#define GST_TYPE_SHAPE_WIPE \ ++ (gst_shape_wipe_get_type()) ++ ++ ++GST_SHAPE_WIPE ++#define GST_SHAPE_WIPE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SHAPE_WIPE,GstShapeWipe)) ++ ++ ++GST_SHAPE_WIPE_CLASS ++#define GST_SHAPE_WIPE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SHAPE_WIPE,GstShapeWipeClass)) ++ ++ ++GST_SHAPE_WIPE_GET_CLASS ++#define GST_SHAPE_WIPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_SHAPE_WIPE,GstShapeWipeClass)) ++ ++ ++GST_IS_SHAPE_WIPE ++#define GST_IS_SHAPE_WIPE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SHAPE_WIPE)) ++ ++ ++GST_IS_SHAPE_WIPE_CLASS ++#define GST_IS_SHAPE_WIPE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SHAPE_WIPE)) ++ ++ ++GstShapeWipe ++ ++ ++GstShapeWipeClass ++ ++ ++GstShapeWipe ++struct _GstShapeWipe ++{ ++ GstElement parent; ++ ++ /* private */ ++ GstPad *video_sinkpad; ++ GstPad *mask_sinkpad; ++ ++ GstPad *srcpad; ++ ++ GstSegment segment; ++ ++ GstBuffer *mask; ++ gfloat mask_position; ++ gfloat mask_border; ++ GMutex *mask_mutex; ++ GCond *mask_cond; ++ gint mask_bpp; ++ ++ GstVideoFormat fmt; ++ gint width, height; ++ ++ gboolean shutdown; ++ ++ gdouble proportion; ++ GstClockTime earliest_time; ++ GstClockTime frame_duration; ++}; ++ ++ ++GstShapeWipeClass ++struct _GstShapeWipeClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_shape_wipe_get_type ++GType ++void ++ ++ ++GST_TYPE_SMPTE ++#define GST_TYPE_SMPTE \ ++ (gst_smpte_get_type()) ++ ++ ++GST_SMPTE ++#define GST_SMPTE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMPTE,GstSMPTE)) ++ ++ ++GST_SMPTE_CLASS ++#define GST_SMPTE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMPTE,GstSMPTEClass)) ++ ++ ++GST_IS_SMPTE ++#define GST_IS_SMPTE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMPTE)) ++ ++ ++GST_IS_SMPTE_CLASS ++#define GST_IS_SMPTE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMPTE)) ++ ++ ++GstSMPTE ++ ++ ++GstSMPTEClass ++ ++ ++GstSMPTE ++struct _GstSMPTE { ++ GstElement element; ++ ++ /* pads */ ++ GstPad *srcpad, ++ *sinkpad1, ++ *sinkpad2; ++ GstCollectPads *collect; ++ ++ /* properties */ ++ gint type; ++ gint border; ++ gint depth; ++ guint64 duration; ++ gboolean invert; ++ ++ /* negotiated format */ ++ gint format; ++ gint width; ++ gint height; ++ gdouble fps; ++ gint fps_num; ++ gint fps_denom; ++ ++ /* state of the effect */ ++ gint position; ++ gint end_position; ++ GstMask *mask; ++}; ++ ++ ++GstSMPTEClass ++struct _GstSMPTEClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_smpte_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_SMPTE_ALPHA ++#define GST_TYPE_SMPTE_ALPHA \ ++ (gst_smpte_alpha_get_type()) ++ ++ ++GST_SMPTE_ALPHA ++#define GST_SMPTE_ALPHA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMPTE_ALPHA,GstSMPTEAlpha)) ++ ++ ++GST_SMPTE_ALPHA_CLASS ++#define GST_SMPTE_ALPHA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMPTE_ALPHA,GstSMPTEAlphaClass)) ++ ++ ++GST_IS_SMPTE_ALPHA ++#define GST_IS_SMPTE_ALPHA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMPTE_ALPHA)) ++ ++ ++GST_IS_SMPTE_ALPHA_CLASS ++#define GST_IS_SMPTE_ALPHA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMPTE_ALPHA)) ++ ++ ++GstSMPTEAlpha ++ ++ ++GstSMPTEAlphaClass ++ ++ ++GstSMPTEAlpha ++struct _GstSMPTEAlpha { ++ GstVideoFilter element; ++ ++ /* properties */ ++ gint type; ++ gint border; ++ gint depth; ++ gdouble position; ++ gboolean invert; ++ ++ /* negotiated format */ ++ GstVideoFormat in_format, out_format; ++ gint width; ++ gint height; ++ ++ /* state of the effect */ ++ GstMask *mask; ++ ++ /* processing function */ ++ void (*process) (GstSMPTEAlpha * smpte, const guint8 * in, guint8 * out, ++ GstMask * mask, gint width, gint height, gint border, gint pos); ++}; ++ ++ ++GstSMPTEAlphaClass ++struct _GstSMPTEAlphaClass { ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_smpte_alpha_get_type ++GType ++void ++ ++ ++gst_smpte_alpha_plugin_init ++gboolean ++GstPlugin * plugin ++ ++ ++GST_TYPE_SPECTRUM ++#define GST_TYPE_SPECTRUM (gst_spectrum_get_type()) ++ ++ ++GST_SPECTRUM ++#define GST_SPECTRUM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPECTRUM,GstSpectrum)) ++ ++ ++GST_IS_SPECTRUM ++#define GST_IS_SPECTRUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPECTRUM)) ++ ++ ++GST_SPECTRUM_CLASS ++#define GST_SPECTRUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_SPECTRUM,GstSpectrumClass)) ++ ++ ++GST_IS_SPECTRUM_CLASS ++#define GST_IS_SPECTRUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_SPECTRUM)) ++ ++ ++GstSpectrum ++ ++ ++GstSpectrumClass ++ ++ ++GstSpectrum ++struct _GstSpectrum ++{ ++ GstAudioFilter parent; ++ ++ /* properties */ ++ gboolean post_messages; /* whether or not to post messages */ ++ gboolean message_magnitude; ++ gboolean message_phase; ++ guint64 interval; /* how many nanoseconds between emits */ ++ guint64 frames_per_interval; /* how many frames per interval */ ++ guint bands; /* number of spectrum bands */ ++ gint threshold; /* energy level treshold */ ++ ++ guint64 num_frames; /* frame count (1 sample per channel) ++ * since last emit */ ++ guint64 num_fft; /* number of FFTs since last emit */ ++ GstClockTime message_ts; /* starttime for next message */ ++ ++ /* */ ++ gfloat *input; ++ guint input_pos; ++ gfloat *input_tmp; ++ GstFFTF32Complex *freqdata; ++ gfloat *spect_magnitude; ++ gfloat *spect_phase; ++ GstFFTF32 *fft_ctx; ++ ++ guint64 error_per_interval; ++ guint64 accumulated_error; ++}; ++ ++ ++GstSpectrumClass ++struct _GstSpectrumClass ++{ ++ GstAudioFilterClass parent_class; ++}; ++ ++ ++gst_spectrum_get_type ++GType ++void ++ ++ ++GST_TYPE_MULTIUDPSINK ++#define GST_TYPE_MULTIUDPSINK (gst_multiudpsink_get_type()) ++ ++ ++GST_MULTIUDPSINK ++#define GST_MULTIUDPSINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTIUDPSINK,GstMultiUDPSink)) ++ ++ ++GST_MULTIUDPSINK_CLASS ++#define GST_MULTIUDPSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTIUDPSINK,GstMultiUDPSinkClass)) ++ ++ ++GST_IS_MULTIUDPSINK ++#define GST_IS_MULTIUDPSINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTIUDPSINK)) ++ ++ ++GST_IS_MULTIUDPSINK_CLASS ++#define GST_IS_MULTIUDPSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTIUDPSINK)) ++ ++ ++GstMultiUDPSink ++ ++ ++GstMultiUDPSinkClass ++ ++ ++GstUDPClient ++typedef struct { ++ int *sock; ++ ++ struct sockaddr_storage theiraddr; ++ ++ gchar *host; ++ gint port; ++ ++ /* Per-client stats */ ++ guint64 bytes_sent; ++ guint64 packets_sent; ++ guint64 connect_time; ++ guint64 disconnect_time; ++} GstUDPClient; ++ ++ ++GstMultiUDPSink ++struct _GstMultiUDPSink { ++ GstBaseSink parent; ++ ++ int sock; ++ ++ GMutex *client_lock; ++ GList *clients; ++ ++ /* properties */ ++ guint64 bytes_to_serve; ++ guint64 bytes_served; ++ int sockfd; ++ gboolean closefd; ++ ++ gboolean externalfd; ++ ++ gboolean auto_multicast; ++ gint ttl; ++ gint ttl_mc; ++ gboolean loop; ++ gint qos_dscp; ++ guint16 ss_family; ++}; ++ ++ ++GstMultiUDPSinkClass ++struct _GstMultiUDPSinkClass { ++ GstBaseSinkClass parent_class; ++ ++ /* element methods */ ++ void (*add) (GstMultiUDPSink *sink, const gchar *host, gint port); ++ void (*remove) (GstMultiUDPSink *sink, const gchar *host, gint port); ++ void (*clear) (GstMultiUDPSink *sink); ++ GValueArray* (*get_stats) (GstMultiUDPSink *sink, const gchar *host, gint port); ++ ++ /* signals */ ++ void (*client_added) (GstElement *element, const gchar *host, gint port); ++ void (*client_removed) (GstElement *element, const gchar *host, gint port); ++}; ++ ++ ++gst_multiudpsink_get_type ++GType ++void ++ ++ ++gst_multiudpsink_add ++void ++GstMultiUDPSink *sink, const gchar *host, gint port ++ ++ ++gst_multiudpsink_remove ++void ++GstMultiUDPSink *sink, const gchar *host, gint port ++ ++ ++gst_multiudpsink_clear ++void ++GstMultiUDPSink *sink ++ ++ ++gst_multiudpsink_get_stats ++GValueArray* ++GstMultiUDPSink *sink, const gchar *host, gint port ++ ++ ++GST_TYPE_UDPSRC ++#define GST_TYPE_UDPSRC \ ++ (gst_udpsrc_get_type()) ++ ++ ++GST_UDPSRC ++#define GST_UDPSRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_UDPSRC,GstUDPSrc)) ++ ++ ++GST_UDPSRC_CLASS ++#define GST_UDPSRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_UDPSRC,GstUDPSrcClass)) ++ ++ ++GST_IS_UDPSRC ++#define GST_IS_UDPSRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_UDPSRC)) ++ ++ ++GST_IS_UDPSRC_CLASS ++#define GST_IS_UDPSRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_UDPSRC)) ++ ++ ++GST_UDPSRC_CAST ++#define GST_UDPSRC_CAST(obj) ((GstUDPSrc *)(obj)) ++ ++ ++GstUDPSrc ++ ++ ++GstUDPSrcClass ++ ++ ++GstUDPSrc ++struct _GstUDPSrc { ++ GstPushSrc parent; ++ ++ /* properties */ ++ GstUDPUri uri; ++ gchar *multi_iface; ++ gint ttl; ++ GstCaps *caps; ++ gint buffer_size; ++ guint64 timeout; ++ gint skip_first_bytes; ++ int sockfd; ++ gboolean closefd; ++ gboolean auto_multicast; ++ gboolean reuse; ++ ++ /* our sockets */ ++ GstPollFD sock; ++ GstPoll *fdset; ++ gboolean externalfd; ++ gboolean is_ipv6; ++ ++ struct sockaddr_storage myaddr; ++ ++ gchar *uristr; ++}; ++ ++ ++GstUDPSrcClass ++struct _GstUDPSrcClass { ++ GstPushSrcClass parent_class; ++}; ++ ++ ++gst_udpsrc_get_type ++GType ++void ++ ++ ++GST_TYPE_UDPSINK ++#define GST_TYPE_UDPSINK (gst_udpsink_get_type()) ++ ++ ++GST_UDPSINK ++#define GST_UDPSINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_UDPSINK,GstUDPSink)) ++ ++ ++GST_UDPSINK_CLASS ++#define GST_UDPSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_UDPSINK,GstUDPSinkClass)) ++ ++ ++GST_IS_UDPSINK ++#define GST_IS_UDPSINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_UDPSINK)) ++ ++ ++GST_IS_UDPSINK_CLASS ++#define GST_IS_UDPSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_UDPSINK)) ++ ++ ++GstUDPSink ++ ++ ++GstUDPSinkClass ++ ++ ++GstUDPSink ++struct _GstUDPSink { ++ GstMultiUDPSink parent; ++ ++ GstUDPUri uri; ++ gchar *uristr; ++}; ++ ++ ++GstUDPSinkClass ++struct _GstUDPSinkClass { ++ GstMultiUDPSinkClass parent_class; ++}; ++ ++ ++gst_udpsink_get_type ++GType ++void ++ ++ ++GST_TYPE_VIDEO_BOX ++#define GST_TYPE_VIDEO_BOX \ ++ (gst_video_box_get_type()) ++ ++ ++GST_VIDEO_BOX ++#define GST_VIDEO_BOX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_BOX,GstVideoBox)) ++ ++ ++GST_VIDEO_BOX_CLASS ++#define GST_VIDEO_BOX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_BOX,GstVideoBoxClass)) ++ ++ ++GST_IS_VIDEO_BOX ++#define GST_IS_VIDEO_BOX(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_BOX)) ++ ++ ++GST_IS_VIDEO_BOX_CLASS ++#define GST_IS_VIDEO_BOX_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_BOX)) ++ ++ ++GstVideoBox ++ ++ ++GstVideoBoxClass ++ ++ ++GstVideoBoxFill ++typedef enum ++{ ++ VIDEO_BOX_FILL_BLACK, ++ VIDEO_BOX_FILL_GREEN, ++ VIDEO_BOX_FILL_BLUE, ++ VIDEO_BOX_FILL_RED, ++ VIDEO_BOX_FILL_YELLOW, ++ VIDEO_BOX_FILL_WHITE, ++ VIDEO_BOX_FILL_LAST ++} ++GstVideoBoxFill; ++ ++ ++GstVideoBox ++struct _GstVideoBox ++{ ++ GstBaseTransform element; ++ ++ /* */ ++ ++ /* Guarding everything below */ ++ GMutex *mutex; ++ /* caps */ ++ GstVideoFormat in_format; ++ gint in_width, in_height; ++ gboolean in_sdtv; ++ GstVideoFormat out_format; ++ gint out_width, out_height; ++ gboolean out_sdtv; ++ ++ gint box_left, box_right, box_top, box_bottom; ++ ++ gint border_left, border_right, border_top, border_bottom; ++ gint crop_left, crop_right, crop_top, crop_bottom; ++ ++ gdouble alpha; ++ gdouble border_alpha; ++ ++ GstVideoBoxFill fill_type; ++ ++ gboolean autocrop; ++ ++ void (*fill) (GstVideoBoxFill fill_type, guint b_alpha, GstVideoFormat format, guint8 *dest, gboolean sdtv, gint width, gint height); ++ void (*copy) (guint i_alpha, GstVideoFormat dest_format, guint8 *dest, gboolean dest_sdtv, gint dest_width, gint dest_height, gint dest_x, gint dest_y, GstVideoFormat src_format, const guint8 *src, gboolean src_sdtv, gint src_width, gint src_height, gint src_x, gint src_y, gint w, gint h); ++}; ++ ++ ++GstVideoBoxClass ++struct _GstVideoBoxClass ++{ ++ GstBaseTransformClass parent_class; ++}; ++ ++ ++gst_video_box_get_type ++GType ++void ++ ++ ++GST_TYPE_VIDEO_CROP ++#define GST_TYPE_VIDEO_CROP \ ++ (gst_video_crop_get_type()) ++ ++ ++GST_VIDEO_CROP ++#define GST_VIDEO_CROP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_CROP,GstVideoCrop)) ++ ++ ++GST_VIDEO_CROP_CLASS ++#define GST_VIDEO_CROP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_CROP,GstVideoCropClass)) ++ ++ ++GST_IS_VIDEO_CROP ++#define GST_IS_VIDEO_CROP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_CROP)) ++ ++ ++GST_IS_VIDEO_CROP_CLASS ++#define GST_IS_VIDEO_CROP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_CROP)) ++ ++ ++VideoCropPixelFormat ++typedef enum { ++ VIDEO_CROP_PIXEL_FORMAT_PACKED_SIMPLE = 0, /* RGBx, AYUV */ ++ VIDEO_CROP_PIXEL_FORMAT_PACKED_COMPLEX, /* UYVY, YVYU */ ++ VIDEO_CROP_PIXEL_FORMAT_PLANAR /* I420, YV12 */ ++} VideoCropPixelFormat; ++ ++ ++GstVideoCropImageDetails ++ ++ ++GstVideoCropImageDetails ++struct _GstVideoCropImageDetails ++{ ++ /*< private >*/ ++ VideoCropPixelFormat packing; ++ ++ guint width; ++ guint height; ++ guint size; ++ ++ /* for packed RGB and YUV */ ++ guint stride; ++ guint bytes_per_pixel; ++ guint8 macro_y_off; /* for YUY2, YVYU, UYVY, Y offset within macropixel in bytes */ ++ ++ /* for planar YUV */ ++ guint y_stride, y_off; ++ guint u_stride, u_off; ++ guint v_stride, v_off; ++}; ++ ++ ++GstVideoCrop ++ ++ ++GstVideoCropClass ++ ++ ++GstVideoCrop ++struct _GstVideoCrop ++{ ++ GstBaseTransform basetransform; ++ ++ /*< private >*/ ++ gint crop_left; ++ gint crop_right; ++ gint crop_top; ++ gint crop_bottom; ++ ++ GstVideoCropImageDetails in; /* details of input image */ ++ GstVideoCropImageDetails out; /* details of output image */ ++}; ++ ++ ++GstVideoCropClass ++struct _GstVideoCropClass ++{ ++ GstBaseTransformClass basetransform_class; ++}; ++ ++ ++gst_video_crop_get_type ++GType ++void ++ ++ ++GST_TYPE_ASPECT_RATIO_CROP ++#define GST_TYPE_ASPECT_RATIO_CROP \ ++ (gst_aspect_ratio_crop_get_type()) ++ ++ ++GST_ASPECT_RATIO_CROP ++#define GST_ASPECT_RATIO_CROP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ASPECT_RATIO_CROP,GstAspectRatioCrop)) ++ ++ ++GST_ASPECT_RATIO_CROP_CLASS ++#define GST_ASPECT_RATIO_CROP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ASPECT_RATIO_CROP,GstAspectRatioCropClass)) ++ ++ ++GST_IS_ASPECT_RATIO_CROP ++#define GST_IS_ASPECT_RATIO_CROP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ASPECT_RATIO_CROP)) ++ ++ ++GST_IS_ASPECT_RATIO_CROP_CLASS ++#define GST_IS_ASPECT_RATIO_CROP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ASPECT_RATIO_CROP)) ++ ++ ++GstAspectRatioCrop ++ ++ ++GstAspectRatioCropClass ++ ++ ++GstAspectRatioCrop ++struct _GstAspectRatioCrop ++{ ++ GstBin parent; ++ ++ /* our videocrop element */ ++ GstElement *videocrop; ++ ++ GstPad *sink; ++ ++ /* target aspect ratio */ ++ gint ar_num; /* if < 1 then don't change ar */ ++ gint ar_denom; ++ ++ GMutex *crop_lock; ++}; ++ ++ ++GstAspectRatioCropClass ++struct _GstAspectRatioCropClass ++{ ++ GstBinClass parent_class; ++}; ++ ++ ++gst_aspect_ratio_crop_get_type ++GType ++void ++ ++ ++GST_TYPE_GAMMA ++#define GST_TYPE_GAMMA \ ++ (gst_gamma_get_type()) ++ ++ ++GST_GAMMA ++#define GST_GAMMA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GAMMA,GstGamma)) ++ ++ ++GST_GAMMA_CLASS ++#define GST_GAMMA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GAMMA,GstGammaClass)) ++ ++ ++GST_IS_GAMMA ++#define GST_IS_GAMMA(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GAMMA)) ++ ++ ++GST_IS_GAMMA_CLASS ++#define GST_IS_GAMMA_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GAMMA)) ++ ++ ++GstGamma ++ ++ ++GstGammaClass ++ ++ ++GstGamma ++struct _GstGamma ++{ ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ /* format */ ++ GstVideoFormat format; ++ gint width; ++ gint height; ++ gint size; ++ ++ /* properties */ ++ gdouble gamma; ++ ++ /* tables */ ++ guint8 gamma_table[256]; ++ ++ void (*process) (GstGamma *gamma, guint8 *data); ++}; ++ ++ ++GstGammaClass ++struct _GstGammaClass ++{ ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_gamma_get_type ++GType ++void ++ ++ ++GST_TYPE_VIDEO_BALANCE ++#define GST_TYPE_VIDEO_BALANCE \ ++ (gst_video_balance_get_type()) ++ ++ ++GST_VIDEO_BALANCE ++#define GST_VIDEO_BALANCE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_BALANCE,GstVideoBalance)) ++ ++ ++GST_VIDEO_BALANCE_CLASS ++#define GST_VIDEO_BALANCE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_BALANCE,GstVideoBalanceClass)) ++ ++ ++GST_IS_VIDEO_BALANCE ++#define GST_IS_VIDEO_BALANCE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_BALANCE)) ++ ++ ++GST_IS_VIDEO_BALANCE_CLASS ++#define GST_IS_VIDEO_BALANCE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_BALANCE)) ++ ++ ++GstVideoBalance ++ ++ ++GstVideoBalanceClass ++ ++ ++GstVideoBalance ++struct _GstVideoBalance { ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ ++ /* channels for interface */ ++ GList *channels; ++ ++ /* properties */ ++ gdouble contrast; ++ gdouble brightness; ++ gdouble hue; ++ gdouble saturation; ++ ++ /* format */ ++ GstVideoFormat format; ++ gint width; ++ gint height; ++ gint size; ++ ++ /* tables */ ++ guint8 tabley[256]; ++ guint8 *tableu[256]; ++ guint8 *tablev[256]; ++ ++ void (*process) (GstVideoBalance *balance, guint8 *data); ++}; ++ ++ ++GstVideoBalanceClass ++struct _GstVideoBalanceClass { ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_video_balance_get_type ++GType ++void ++ ++ ++GstVideoFlipMethod ++typedef enum { ++ GST_VIDEO_FLIP_METHOD_IDENTITY, ++ GST_VIDEO_FLIP_METHOD_90R, ++ GST_VIDEO_FLIP_METHOD_180, ++ GST_VIDEO_FLIP_METHOD_90L, ++ GST_VIDEO_FLIP_METHOD_HORIZ, ++ GST_VIDEO_FLIP_METHOD_VERT, ++ GST_VIDEO_FLIP_METHOD_TRANS, ++ GST_VIDEO_FLIP_METHOD_OTHER ++} GstVideoFlipMethod; ++ ++ ++GST_TYPE_VIDEO_FLIP ++#define GST_TYPE_VIDEO_FLIP \ ++ (gst_video_flip_get_type()) ++ ++ ++GST_VIDEO_FLIP ++#define GST_VIDEO_FLIP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_FLIP,GstVideoFlip)) ++ ++ ++GST_VIDEO_FLIP_CLASS ++#define GST_VIDEO_FLIP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_FLIP,GstVideoFlipClass)) ++ ++ ++GST_IS_VIDEO_FLIP ++#define GST_IS_VIDEO_FLIP(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_FLIP)) ++ ++ ++GST_IS_VIDEO_FLIP_CLASS ++#define GST_IS_VIDEO_FLIP_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_FLIP)) ++ ++ ++GstVideoFlip ++ ++ ++GstVideoFlipClass ++ ++ ++GstVideoFlip ++struct _GstVideoFlip { ++ GstVideoFilter videofilter; ++ ++ /* < private > */ ++ GstVideoFormat format; ++ gint from_width, from_height; ++ gint to_width, to_height; ++ ++ GstVideoFlipMethod method; ++ void (*process) (GstVideoFlip *videoflip, guint8 *dest, const guint8 *src); ++}; ++ ++ ++GstVideoFlipClass ++struct _GstVideoFlipClass { ++ GstVideoFilterClass parent_class; ++}; ++ ++ ++gst_video_flip_get_type ++GType ++void ++ ++ ++GST_TYPE_VIDEO_MIXER ++#define GST_TYPE_VIDEO_MIXER (gst_videomixer_get_type()) ++ ++ ++GST_VIDEO_MIXER ++#define GST_VIDEO_MIXER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_MIXER, GstVideoMixer)) ++ ++ ++GST_VIDEO_MIXER_CLASS ++#define GST_VIDEO_MIXER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_MIXER, GstVideoMixerClass)) ++ ++ ++GST_IS_VIDEO_MIXER ++#define GST_IS_VIDEO_MIXER(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_MIXER)) ++ ++ ++GST_IS_VIDEO_MIXER_CLASS ++#define GST_IS_VIDEO_MIXER_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_MIXER)) ++ ++ ++GstVideoMixer ++ ++ ++GstVideoMixerClass ++ ++ ++GstVideoMixerBackground ++typedef enum ++{ ++ VIDEO_MIXER_BACKGROUND_CHECKER, ++ VIDEO_MIXER_BACKGROUND_BLACK, ++ VIDEO_MIXER_BACKGROUND_WHITE ++} ++GstVideoMixerBackground; ++ ++ ++GstVideoMixer ++struct _GstVideoMixer ++{ ++ GstElement element; ++ ++ /* pad */ ++ GstPad *srcpad; ++ ++ /* Lock to prevent the state to change while blending */ ++ GMutex *state_lock; ++ /* Sink pads using Collect Pads from core's base library */ ++ GstCollectPads *collect; ++ /* sinkpads, a GSList of GstVideoMixerPads */ ++ GSList *sinkpads; ++ ++ gint numpads; ++ ++ GstClockTime last_ts; ++ GstClockTime last_duration; ++ ++ /* the master pad */ ++ GstVideoMixerPad *master; ++ ++ GstVideoFormat fmt; ++ ++ gint in_width, in_height; ++ gint out_width, out_height; ++ gboolean setcaps; ++ gboolean sendseg; ++ ++ GstVideoMixerBackground background; ++ ++ gint fps_n; ++ gint fps_d; ++ ++ gint par_n; ++ gint par_d; ++ ++ /* Next available sinkpad index */ ++ gint next_sinkpad; ++ ++ /* sink event handling */ ++ GstPadEventFunction collect_event; ++ guint64 segment_position; ++ ++ /* Current downstream segment */ ++ GstSegment segment; ++ ++ /* QoS stuff */ ++ gdouble proportion; ++ GstClockTime earliest_time; ++ ++ BlendFunction blend; ++ FillCheckerFunction fill_checker; ++ FillColorFunction fill_color; ++ ++ gboolean flush_stop_pending; ++}; ++ ++ ++GstVideoMixerClass ++struct _GstVideoMixerClass ++{ ++ GstElementClass parent_class; ++}; ++ ++ ++gst_video_mixer_get_type ++GType ++void ++ ++ ++GST_TYPE_VIDEO_MIXER_PAD ++#define GST_TYPE_VIDEO_MIXER_PAD (gst_videomixer_pad_get_type()) ++ ++ ++GST_VIDEO_MIXER_PAD ++#define GST_VIDEO_MIXER_PAD(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_MIXER_PAD, GstVideoMixerPad)) ++ ++ ++GST_VIDEO_MIXER_PAD_CLASS ++#define GST_VIDEO_MIXER_PAD_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_MIXER_PAD, GstVideoMixerPadiClass)) ++ ++ ++GST_IS_VIDEO_MIXER_PAD ++#define GST_IS_VIDEO_MIXER_PAD(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_MIXER_PAD)) ++ ++ ++GST_IS_VIDEO_MIXER_PAD_CLASS ++#define GST_IS_VIDEO_MIXER_PAD_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_MIXER_PAD)) ++ ++ ++GstVideoMixerPad ++ ++ ++GstVideoMixerPadClass ++ ++ ++GstVideoMixerCollect ++ ++ ++GstVideoMixerCollect ++struct _GstVideoMixerCollect ++{ ++ GstCollectData collect; /* we extend the CollectData */ ++ ++ GstBuffer *buffer; /* the queued buffer for this pad */ ++ ++ GstVideoMixerPad *mixpad; ++}; ++ ++ ++GstVideoMixerPad ++struct _GstVideoMixerPad ++{ ++ GstPad parent; /* subclass the pad */ ++ ++ gint64 queued; ++ ++ guint in_width, in_height; ++ gint fps_n; ++ gint fps_d; ++ gint par_n; ++ gint par_d; ++ ++ gint xpos, ypos; ++ guint zorder; ++ gint blend_mode; ++ gdouble alpha; ++ ++ GstVideoMixerCollect *mixcol; ++}; ++ ++ ++GstVideoMixerPadClass ++struct _GstVideoMixerPadClass ++{ ++ GstPadClass parent_class; ++}; ++ ++ ++GST_TYPE_WAVENC ++#define GST_TYPE_WAVENC \ ++ (gst_wavenc_get_type()) ++ ++ ++GST_WAVENC ++#define GST_WAVENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVENC,GstWavEnc)) ++ ++ ++GST_WAVENC_CLASS ++#define GST_WAVENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVENC,GstWavEncClass)) ++ ++ ++GST_IS_WAVENC ++#define GST_IS_WAVENC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVENC)) ++ ++ ++GST_IS_WAVENC_CLASS ++#define GST_IS_WAVENC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVENC)) ++ ++ ++GstWavEnc ++ ++ ++GstWavEncClass ++ ++ ++GstWavEnc ++struct _GstWavEnc { ++ GstElement element; ++ ++ GstPad *sinkpad; ++ GstPad *srcpad; ++ ++ /* useful audio data */ ++ guint16 format; ++ guint width; ++ guint rate; ++ guint channels; ++ guint32 length; ++ ++ gboolean sent_header; ++ gboolean finished_properly; ++}; ++ ++ ++GstWavEncClass ++struct _GstWavEncClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_wavenc_get_type ++GType ++void ++ ++ ++GST_TYPE_WAVPARSE ++#define GST_TYPE_WAVPARSE \ ++ (gst_wavparse_get_type()) ++ ++ ++GST_WAVPARSE ++#define GST_WAVPARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVPARSE,GstWavParse)) ++ ++ ++GST_WAVPARSE_CLASS ++#define GST_WAVPARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVPARSE,GstWavParseClass)) ++ ++ ++GST_IS_WAVPARSE ++#define GST_IS_WAVPARSE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVPARSE)) ++ ++ ++GST_IS_WAVPARSE_CLASS ++#define GST_IS_WAVPARSE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVPARSE)) ++ ++ ++GstWavParseState ++typedef enum { ++ GST_WAVPARSE_START, ++ GST_WAVPARSE_HEADER, ++ GST_WAVPARSE_DATA ++} GstWavParseState; ++ ++ ++GstWavParse ++ ++ ++GstWavParseClass ++ ++ ++GstWavParse ++struct _GstWavParse { ++ GstElement parent; ++ ++ /* pads */ ++ GstPad *sinkpad,*srcpad; ++ ++ /* for delayed source pad creation for when ++ * we have the first chunk of data and know ++ * the format for sure */ ++ GstCaps *caps; ++ GstTagList *tags; ++ GstEvent *close_segment; ++ GstEvent *start_segment; ++ ++ /* WAVE decoding state */ ++ GstWavParseState state; ++ gboolean abort_buffering; ++ ++ /* format of audio, see defines below */ ++ gint format; ++ ++ /* useful audio data */ ++ guint16 depth; ++ guint32 rate; ++ guint16 channels; ++ guint16 blockalign; ++ guint16 width; ++ guint32 av_bps; ++ guint32 fact; ++ ++ /* real bps used or 0 when no bitrate is known */ ++ guint32 bps; ++ gboolean vbr; ++ ++ guint bytes_per_sample; ++ ++ /* position in data part */ ++ guint64 offset; ++ guint64 end_offset; ++ guint64 dataleft; ++ /* offset/length of data part */ ++ guint64 datastart; ++ guint64 datasize; ++ /* duration in time */ ++ guint64 duration; ++ ++ /* pending seek */ ++ GstEvent *seek_event; ++ ++ /* For streaming */ ++ GstAdapter *adapter; ++ gboolean got_fmt; ++ gboolean streaming; ++ ++ /* configured segment, start/stop expressed in time */ ++ GstSegment segment; ++ gboolean segment_running; ++ ++ /* for late pad configuration */ ++ gboolean first; ++ /* discont after seek */ ++ gboolean discont; ++}; ++ ++ ++GstWavParseClass ++struct _GstWavParseClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_wavparse_get_type ++GType ++void ++ ++ ++GST_TYPE_Y4M_ENCODE ++#define GST_TYPE_Y4M_ENCODE \ ++ (gst_y4m_encode_get_type()) ++ ++ ++GST_Y4M_ENCODE ++#define GST_Y4M_ENCODE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_Y4M_ENCODE, GstY4mEncode)) ++ ++ ++GST_Y4M_ENCODE_CLASS ++#define GST_Y4M_ENCODE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_Y4M_ENCODE, GstY4mEncodeClass)) ++ ++ ++GST_Y4M_ENCODE_GET_CLASS ++#define GST_Y4M_ENCODE_GET_CLASS(obj) \ ++ (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_Y4M_ENCODE, GstY4mEncodeClass)) ++ ++ ++GST_IS_Y4M_ENCODE ++#define GST_IS_Y4M_ENCODE(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_Y4M_ENCODE)) ++ ++ ++GST_IS_Y4M_ENCODE_CLASS ++#define GST_IS_Y4M_ENCODE_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_Y4M_ENCODE)) ++ ++ ++GstY4mEncode ++ ++ ++GstY4mEncodeClass ++ ++ ++GstY4mEncode ++struct _GstY4mEncode { ++ GstElement element; ++ ++ GstPad *sinkpad,*srcpad; ++ ++ /* caps information */ ++ gint width, height; ++ gint fps_num, fps_den; ++ gint par_num, par_den; ++ gboolean interlaced; ++ gboolean top_field_first; ++ const gchar *colorspace; ++ /* state information */ ++ gboolean header; ++}; ++ ++ ++GstY4mEncodeClass ++struct _GstY4mEncodeClass { ++ GstElementClass parent_class; ++}; ++ ++ ++gst_y4m_encode_get_type ++GType ++void ++ ++ ++GST_TYPE_DIRECTSOUND_SINK ++#define GST_TYPE_DIRECTSOUND_SINK (gst_directsound_sink_get_type()) ++ ++ ++GST_DIRECTSOUND_SINK ++#define GST_DIRECTSOUND_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DIRECTSOUND_SINK,GstDirectSoundSink)) ++ ++ ++GST_DIRECTSOUND_SINK_CLASS ++#define GST_DIRECTSOUND_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DIRECTSOUND_SINK,GstDirectSoundSinkClass)) ++ ++ ++GST_IS_DIRECTSOUND_SINK ++#define GST_IS_DIRECTSOUND_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DIRECTSOUND_SINK)) ++ ++ ++GST_IS_DIRECTSOUND_SINK_CLASS ++#define GST_IS_DIRECTSOUND_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DIRECTSOUND_SINK)) ++ ++ ++GstDirectSoundSink ++ ++ ++GstDirectSoundSinkClass ++ ++ ++GST_DSOUND_LOCK ++#define GST_DSOUND_LOCK(obj) (g_mutex_lock (obj->dsound_lock)) ++ ++ ++GST_DSOUND_UNLOCK ++#define GST_DSOUND_UNLOCK(obj) (g_mutex_unlock (obj->dsound_lock)) ++ ++ ++GstDirectSoundSink ++struct _GstDirectSoundSink ++{ ++ GstAudioSink sink; ++ ++ /* directsound object interface pointer */ ++ LPDIRECTSOUND pDS; ++ ++ /* directsound sound object interface pointer */ ++ LPDIRECTSOUNDBUFFER pDSBSecondary; ++ ++ /* directSound buffer size */ ++ guint buffer_size; ++ ++ /* offset of the circular buffer where we must write next */ ++ guint current_circular_offset; ++ ++ guint bytes_per_sample; ++ ++ /* current volume setup by mixer interface */ ++ glong volume; ++ ++ /* tracks list of our mixer interface implementation */ ++ GList *tracks; ++ ++ GstCaps *cached_caps; ++ ++ /* lock used to protect writes and resets */ ++ GMutex *dsound_lock; ++ ++ gboolean first_buffer_after_reset; ++ ++ GstBufferFormat buffer_format; ++}; ++ ++ ++GstDirectSoundSinkClass ++struct _GstDirectSoundSinkClass ++{ ++ GstAudioSinkClass parent_class; ++}; ++ ++ ++gst_directsound_sink_get_type ++GType ++void ++ ++ ++GST_OSS4_MIXER ++#define GST_OSS4_MIXER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS4_MIXER,GstOss4Mixer)) ++ ++ ++GST_OSS4_MIXER_CAST ++#define GST_OSS4_MIXER_CAST(obj) ((GstOss4Mixer *)(obj)) ++ ++ ++GST_OSS4_MIXER_CLASS ++#define GST_OSS4_MIXER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS4_MIXER,GstOss4MixerClass)) ++ ++ ++GST_IS_OSS4_MIXER ++#define GST_IS_OSS4_MIXER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS4_MIXER)) ++ ++ ++GST_IS_OSS4_MIXER_CLASS ++#define GST_IS_OSS4_MIXER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS4_MIXER)) ++ ++ ++GST_TYPE_OSS4_MIXER ++#define GST_TYPE_OSS4_MIXER (gst_oss4_mixer_get_type()) ++ ++ ++GST_OSS4_MIXER_IS_OPEN ++#define GST_OSS4_MIXER_IS_OPEN(obj) (GST_OSS4_MIXER(obj)->fd != -1) ++ ++ ++GstOss4Mixer ++ ++ ++GstOss4MixerClass ++ ++ ++GstOss4Mixer ++struct _GstOss4Mixer { ++ GstElement element; ++ ++ /*< private >*/ ++ ++ /* element bits'n'bops */ ++ gchar * device; ++ ++ /* mixer details */ ++ gint fd; /* file descriptor if open, or -1 */ ++ gchar * device_name; /* device description, or NULL */ ++ gchar * open_device; /* the device we opened */ ++ ++ GList * tracks; /* list of available tracks */ ++ GList * controls; /* list of available controls */ ++ gboolean need_update; /* re-read list of available tracks? */ ++ ++ oss_mixext last_mixext; /* we keep this around so we can ++ * easily check if the mixer ++ * interface has changed */ ++ ++ GThread * watch_thread; /* thread watching for value changes */ ++ GCond * watch_cond; ++ gint watch_shutdown; ++ gint modify_counter; /* from MIXERINFO */ ++ ++ /* for property probe interface */ ++ GList * property_probe_list; ++}; ++ ++ ++GstOss4MixerClass ++struct _GstOss4MixerClass { ++ GstElementClass element_class; ++}; ++ ++ ++GstOss4MixerControl ++ ++ ++GstOss4MixerControl ++struct _GstOss4MixerControl { ++ oss_mixext mixext; ++ GstOss4MixerControl *parent; /* NULL if root */ ++ GstOss4MixerControl *mute; /* sibling with mute function, or NULL */ ++ GList *mute_group; /* group of mute controls, or NULL */ ++ GList *children; /* GstOss4MixerControls (no ownership) */ ++ ++ GQuark *enum_vals; /* 0-terminated array of values or NULL */ ++ int enum_version; /* 0 = list won't change */ ++ ++ int last_val; /* last value seen */ ++ ++ gboolean is_virtual : 1; /* is a vmix control with dynamic label */ ++ gboolean is_master : 1; ++ gboolean is_slider : 1; /* represent as slider */ ++ gboolean is_switch : 1; /* represent as switch */ ++ gboolean is_enum : 1; /* represent as combo/enumeration */ ++ gboolean no_list : 1; /* enumeration with no list available */ ++ gboolean is_input : 1; /* is an input-related control */ ++ gboolean is_output : 1; /* is an output-related control */ ++ gboolean used : 1; /* whether we know what to do with this */ ++ ++ gboolean changed : 1; /* transient flag used by watch thread */ ++ gboolean list_changed : 1; /* transient flag used by watch thread */ ++}; ++ ++ ++MIXEXT_IS_ROOT ++#define MIXEXT_IS_ROOT(me) ((me).parent == -1 || (me).parent == (me).ctrl) ++ ++ ++MIXEXT_IS_SLIDER ++#define MIXEXT_IS_SLIDER(me) ((me).type == MIXT_MONOSLIDER || \ ++ (me).type == MIXT_STEREOSLIDER || (me).type == MIXT_MONOSLIDER16 || \ ++ (me).type == MIXT_STEREOSLIDER16 || (me).type == MIXT_SLIDER) ++ ++ ++MIXEXT_HAS_DESCRIPTION ++#define MIXEXT_HAS_DESCRIPTION(me) (((me).flags & MIXF_DESCR) != 0) ++ ++ ++MIXEXT_ENUM_IS_AVAILABLE ++#define MIXEXT_ENUM_IS_AVAILABLE(me,num) \ ++ (((me).enum_present[num/8]) & (1 << (num % 8))) ++ ++ ++gst_oss4_mixer_get_type ++GType ++void ++ ++ ++gst_oss4_mixer_get_control_val ++gboolean ++GstOss4Mixer * mixer, GstOss4MixerControl * mc, int * val ++ ++ ++gst_oss4_mixer_set_control_val ++gboolean ++GstOss4Mixer * mixer, GstOss4MixerControl * mc, int val ++ ++ ++GST_TYPE_OSS4_SINK ++#define GST_TYPE_OSS4_SINK (gst_oss4_sink_get_type()) ++ ++ ++GST_OSS4_SINK ++#define GST_OSS4_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS4_SINK,GstOss4Sink)) ++ ++ ++GST_OSS4_SINK_CAST ++#define GST_OSS4_SINK_CAST(obj) ((GstOss4Sink *)(obj)) ++ ++ ++GST_OSS4_SINK_CLASS ++#define GST_OSS4_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS4_SINK,GstOss4SinkClass)) ++ ++ ++GST_IS_OSS4_SINK ++#define GST_IS_OSS4_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS4_SINK)) ++ ++ ++GST_IS_OSS4_SINK_CLASS ++#define GST_IS_OSS4_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS4_SINK)) ++ ++ ++GstOss4Sink ++ ++ ++GstOss4SinkClass ++ ++ ++GstOss4Sink ++struct _GstOss4Sink { ++ GstAudioSink audio_sink; ++ ++ gchar * device; /* NULL if none was set */ ++ gchar * open_device; /* the device we opened */ ++ gchar * device_name; /* set if the device is open */ ++ gint fd; /* -1 if not open */ ++ gint bytes_per_sample; ++ gint mute_volume; ++ ++ GstCaps * probed_caps; ++ ++ GList * property_probe_list; ++}; ++ ++ ++GstOss4SinkClass ++struct _GstOss4SinkClass { ++ GstAudioSinkClass audio_sink_class; ++}; ++ ++ ++gst_oss4_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_OSS4_SOURCE ++#define GST_TYPE_OSS4_SOURCE (gst_oss4_source_get_type()) ++ ++ ++GST_OSS4_SOURCE ++#define GST_OSS4_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS4_SOURCE,GstOss4Source)) ++ ++ ++GST_OSS4_SOURCE_CAST ++#define GST_OSS4_SOURCE_CAST(obj) ((GstOss4Source *)(obj)) ++ ++ ++GST_OSS4_SOURCE_CLASS ++#define GST_OSS4_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS4_SOURCE,GstOss4SourceClass)) ++ ++ ++GST_IS_OSS4_SOURCE ++#define GST_IS_OSS4_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS4_SOURCE)) ++ ++ ++GST_IS_OSS4_SOURCE_CLASS ++#define GST_IS_OSS4_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS4_SOURCE)) ++ ++ ++GstOss4Source ++ ++ ++GstOss4SourceClass ++ ++ ++GstOss4Source ++struct _GstOss4Source { ++ GstAudioSrc audiosrc; ++ ++ gchar * device; /* NULL if none was set */ ++ gchar * open_device; /* the device we opened */ ++ gchar * device_name; /* set if the device is open */ ++ gint fd; /* -1 if not open */ ++ gint bytes_per_sample; ++ ++ GstCaps * probed_caps; ++ ++ /* property probe interface */ ++ GList * property_probe_list; ++ ++ /* mixer interface */ ++ GList * tracks; ++ gboolean tracks_static; /* FALSE if the list of inputs may change */ ++}; ++ ++ ++GstOss4SourceClass ++struct _GstOss4SourceClass { ++ GstAudioSrcClass audiosrc_class; ++}; ++ ++ ++gst_oss4_source_get_type ++GType ++void ++ ++ ++GST_TYPE_OSS4_SOURCE_INPUT ++#define GST_TYPE_OSS4_SOURCE_INPUT (gst_oss4_source_input_get_type()) ++ ++ ++GST_OSS4_SOURCE_INPUT ++#define GST_OSS4_SOURCE_INPUT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS4_SOURCE_INPUT,GstOss4SourceInput)) ++ ++ ++GST_OSS4_SOURCE_INPUT_CLASS ++#define GST_OSS4_SOURCE_INPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS4_SOURCE_INPUT,GstOss4SourceInputClass)) ++ ++ ++GST_IS_OSS4_SOURCE_INPUT ++#define GST_IS_OSS4_SOURCE_INPUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS4_SOURCE_INPUT)) ++ ++ ++GST_IS_OSS4_SOURCE_INPUT_CLASS ++#define GST_IS_OSS4_SOURCE_INPUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS4_SOURCE_INPUT)) ++ ++ ++GstOss4SourceInput ++ ++ ++GstOss4SourceInputClass ++ ++ ++GstOss4SourceInput ++struct _GstOss4SourceInput { ++ GstMixerTrack mixer_track; ++ ++ int route; /* number for SNDCTL_DSP_SET_RECSRC etc. */ ++}; ++ ++ ++GstOss4SourceInputClass ++struct _GstOss4SourceInputClass { ++ GstMixerTrackClass mixer_track_class; ++}; ++ ++ ++gst_oss4_source_input_get_type ++GType ++void ++ ++ ++GST_OSS_MIXER_ELEMENT ++#define GST_OSS_MIXER_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS_MIXER_ELEMENT,GstOssMixerElement)) ++ ++ ++GST_OSS_MIXER_ELEMENT_CLASS ++#define GST_OSS_MIXER_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS_MIXER_ELEMENT,GstOssMixerElementClass)) ++ ++ ++GST_IS_OSS_MIXER_ELEMENT ++#define GST_IS_OSS_MIXER_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS_MIXER_ELEMENT)) ++ ++ ++GST_IS_OSS_MIXER_ELEMENT_CLASS ++#define GST_IS_OSS_MIXER_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS_MIXER_ELEMENT)) ++ ++ ++GST_TYPE_OSS_MIXER_ELEMENT ++#define GST_TYPE_OSS_MIXER_ELEMENT (gst_oss_mixer_element_get_type()) ++ ++ ++GstOssMixerElement ++ ++ ++GstOssMixerElementClass ++ ++ ++GstOssMixerElement ++struct _GstOssMixerElement { ++ GstElement parent; ++ ++ gchar *device; ++ GstOssMixer *mixer; ++}; ++ ++ ++GstOssMixerElementClass ++struct _GstOssMixerElementClass { ++ GstElementClass parent; ++}; ++ ++ ++gst_oss_mixer_element_get_type ++GType ++void ++ ++ ++GST_TYPE_OSSSINK ++#define GST_TYPE_OSSSINK (gst_oss_sink_get_type()) ++ ++ ++GST_OSSSINK ++#define GST_OSSSINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSSSINK,GstOssSink)) ++ ++ ++GST_OSSSINK_CLASS ++#define GST_OSSSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSSSINK,GstOssSinkClass)) ++ ++ ++GST_IS_OSSSINK ++#define GST_IS_OSSSINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSSSINK)) ++ ++ ++GST_IS_OSSSINK_CLASS ++#define GST_IS_OSSSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSSSINK)) ++ ++ ++GstOssSink ++ ++ ++GstOssSinkClass ++ ++ ++GstOssSink ++struct _GstOssSink { ++ GstAudioSink sink; ++ ++ gchar *device; ++ gint fd; ++ gint bytes_per_sample; ++ ++ GstCaps *probed_caps; ++}; ++ ++ ++GstOssSinkClass ++struct _GstOssSinkClass { ++ GstAudioSinkClass parent_class; ++}; ++ ++ ++gst_oss_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_OSS_SRC ++#define GST_TYPE_OSS_SRC (gst_oss_src_get_type()) ++ ++ ++GST_OSS_SRC ++#define GST_OSS_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSS_SRC,GstOssSrc)) ++ ++ ++GST_OSS_SRC_CLASS ++#define GST_OSS_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSS_SRC,GstOssSrcClass)) ++ ++ ++GST_IS_OSS_SRC ++#define GST_IS_OSS_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OSS_SRC)) ++ ++ ++GST_IS_OSS_SRC_CLASS ++#define GST_IS_OSS_SRC_CLASS(klas) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OSS_SRC)) ++ ++ ++GstOssSrc ++ ++ ++GstOssSrcClass ++ ++ ++GstOssSrc ++struct _GstOssSrc { ++ GstAudioSrc src; ++ ++ gint fd; ++ gint bytes_per_sample; ++ ++ gchar *device; ++ gchar *device_name; ++ ++ GstCaps *probed_caps; ++ ++ GstOssMixer *mixer; ++}; ++ ++ ++GstOssSrcClass ++struct _GstOssSrcClass { ++ GstAudioSrcClass parent_class; ++}; ++ ++ ++gst_oss_src_get_type ++GType ++void ++ ++ ++GST_TYPE_OSX_AUDIO_SRC ++#define GST_TYPE_OSX_AUDIO_SRC \ ++ (gst_osx_audio_src_get_type()) ++ ++ ++GST_OSX_AUDIO_SRC ++#define GST_OSX_AUDIO_SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSX_AUDIO_SRC,GstOsxAudioSrc)) ++ ++ ++GST_OSX_AUDIO_SRC_CLASS ++#define GST_OSX_AUDIO_SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSX_AUDIO_SRC,GstOsxAudioSrcClass)) ++ ++ ++GstOsxAudioSrc ++ ++ ++GstOsxAudioSrcClass ++ ++ ++GstOsxAudioSrc ++struct _GstOsxAudioSrc ++{ ++ GstBaseAudioSrc src; ++ ++ AudioDeviceID device_id; ++ ++ /* actual number of channels reported by input device */ ++ int deviceChannels; ++}; ++ ++ ++GstOsxAudioSrcClass ++struct _GstOsxAudioSrcClass ++{ ++ GstBaseAudioSrcClass parent_class; ++}; ++ ++ ++gst_osx_audio_src_get_type ++GType ++void ++ ++ ++GST_TYPE_OSX_AUDIO_SINK ++#define GST_TYPE_OSX_AUDIO_SINK \ ++ (gst_osx_audio_sink_get_type()) ++ ++ ++GST_OSX_AUDIO_SINK ++#define GST_OSX_AUDIO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OSX_AUDIO_SINK,GstOsxAudioSink)) ++ ++ ++GST_OSX_AUDIO_SINK_CLASS ++#define GST_OSX_AUDIO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OSX_AUDIO_SINK,GstOsxAudioSinkClass)) ++ ++ ++GstOsxAudioSink ++ ++ ++GstOsxAudioSinkClass ++ ++ ++GstOsxAudioSink ++struct _GstOsxAudioSink ++{ ++ GstBaseAudioSink sink; ++ ++ AudioDeviceID device_id; ++ AudioUnit audiounit; ++ double volume; ++}; ++ ++ ++GstOsxAudioSinkClass ++struct _GstOsxAudioSinkClass ++{ ++ GstBaseAudioSinkClass parent_class; ++}; ++ ++ ++gst_osx_audio_sink_get_type ++GType ++void ++ ++ ++GST_CAT_DEFAULT ++#define GST_CAT_DEFAULT gst_debug_osx_video_sink ++ ++ ++GST_TYPE_OSX_VIDEO_SINK ++#define GST_TYPE_OSX_VIDEO_SINK \ ++ (gst_osx_video_sink_get_type()) ++ ++ ++GST_OSX_VIDEO_SINK ++#define GST_OSX_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_OSX_VIDEO_SINK, GstOSXVideoSink)) ++ ++ ++GST_OSX_VIDEO_SINK_CLASS ++#define GST_OSX_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_OSX_VIDEO_SINK, GstOSXVideoSinkClass)) ++ ++ ++GST_IS_OSX_VIDEO_SINK ++#define GST_IS_OSX_VIDEO_SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_OSX_VIDEO_SINK)) ++ ++ ++GST_IS_OSX_VIDEO_SINK_CLASS ++#define GST_IS_OSX_VIDEO_SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_OSX_VIDEO_SINK)) ++ ++ ++GstOSXWindow ++ ++ ++GstOSXVideoSink ++ ++ ++GstOSXVideoSinkClass ++ ++ ++GST_TYPE_OSXVIDEOBUFFER ++#define GST_TYPE_OSXVIDEOBUFFER (gst_osxvideobuffer_get_type()) ++ ++ ++GstOSXWindow ++struct _GstOSXWindow { ++ gint width, height; ++ gboolean internal; ++ GstGLView* gstview; ++}; ++ ++ ++GstOSXVideoSink ++struct _GstOSXVideoSink { ++ /* Our element stuff */ ++ GstVideoSink videosink; ++ GstOSXWindow *osxwindow; ++ NSView *superview; ++}; ++ ++ ++GstOSXVideoSinkClass ++struct _GstOSXVideoSinkClass { ++ GstVideoSinkClass parent_class; ++}; ++ ++ ++gst_osx_video_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_V4L2SRC ++#define GST_TYPE_V4L2SRC \ ++ (gst_v4l2src_get_type()) ++ ++ ++GST_V4L2SRC ++#define GST_V4L2SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_V4L2SRC,GstV4l2Src)) ++ ++ ++GST_V4L2SRC_CLASS ++#define GST_V4L2SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_V4L2SRC,GstV4l2SrcClass)) ++ ++ ++GST_IS_V4L2SRC ++#define GST_IS_V4L2SRC(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_V4L2SRC)) ++ ++ ++GST_IS_V4L2SRC_CLASS ++#define GST_IS_V4L2SRC_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_V4L2SRC)) ++ ++ ++GstV4l2Src ++ ++ ++GstV4l2SrcClass ++ ++ ++GstV4l2SrcGetFunc ++GstFlowReturn ++GstV4l2Src * v4l2src, GstBuffer ** buf ++ ++ ++GstV4l2Src ++struct _GstV4l2Src ++{ ++ GstPushSrc pushsrc; ++ ++ /*< private >*/ ++ GstV4l2Object * v4l2object; ++ ++ /* pads */ ++ GstCaps *probed_caps; ++ ++ /* buffer handling */ ++ GstV4l2BufferPool *pool; ++ ++ guint32 num_buffers; ++ gboolean use_mmap; ++ guint32 frame_byte_size; ++ ++ /* if the buffer will be or not used from directly mmap */ ++ gboolean always_copy; ++ ++ /* True if we want to stop */ ++ gboolean quit; ++ gboolean is_capturing; ++ ++ guint64 offset; ++ ++ gint fps_d, fps_n; /* framerate if device is open */ ++ GstClockTime duration; /* duration of one frame */ ++ ++ GstV4l2SrcGetFunc get_frame; ++}; ++ ++ ++GstV4l2SrcClass ++struct _GstV4l2SrcClass ++{ ++ GstPushSrcClass parent_class; ++ ++ GList *v4l2_class_devices; ++}; ++ ++ ++gst_v4l2src_get_type ++GType ++void ++ ++ ++GST_TYPE_V4L2SINK ++#define GST_TYPE_V4L2SINK \ ++ (gst_v4l2sink_get_type()) ++ ++ ++GST_V4L2SINK ++#define GST_V4L2SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_V4L2SINK, GstV4l2Sink)) ++ ++ ++GST_V4L2SINK_CLASS ++#define GST_V4L2SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_V4L2SINK, GstV4l2SinkClass)) ++ ++ ++GST_IS_V4L2SINK ++#define GST_IS_V4L2SINK(obj) \ ++ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_V4L2SINK)) ++ ++ ++GST_IS_V4L2SINK_CLASS ++#define GST_IS_V4L2SINK_CLASS(klass) \ ++ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_V4L2SINK)) ++ ++ ++GstV4l2Sink ++ ++ ++GstV4l2SinkClass ++ ++ ++GstV4l2Sink ++struct _GstV4l2Sink { ++ GstVideoSink videosink; ++ ++ /*< private >*/ ++ GstV4l2Object * v4l2object; ++ GstCaps *probed_caps; /* all supported caps of underlying v4l2 device */ ++ GstCaps *current_caps; /* the current negotiated caps */ ++ GstV4l2BufferPool *pool; ++ guint32 num_buffers; ++ ++ /* ++ * field to store requested overlay-top/left/width/height props: ++ * note, could maybe be combined with 'vwin' field in GstV4l2Object? ++ */ ++ struct v4l2_rect overlay; ++ ++ /* ++ * bitmask to track which 'overlay' fields user has requested by ++ * setting properties: ++ */ ++ guint8 overlay_fields_set; ++ ++ guint8 state; ++}; ++ ++ ++GstV4l2SinkClass ++struct _GstV4l2SinkClass { ++ GstVideoSinkClass parent_class; ++ ++ GList *v4l2_class_devices; ++}; ++ ++ ++gst_v4l2sink_get_type ++GType ++void ++ ++ ++WAVE_FORMAT_96M08 ++#define WAVE_FORMAT_96M08 0x00001000 /* 96 kHz, Mono, 8-bit */ ++ ++ ++WAVE_FORMAT_96S08 ++#define WAVE_FORMAT_96S08 0x00002000 /* 96 kHz, Stereo, 8-bit */ ++ ++ ++WAVE_FORMAT_96M16 ++#define WAVE_FORMAT_96M16 0x00004000 /* 96 kHz, Mono, 16-bit */ ++ ++ ++WAVE_FORMAT_96S16 ++#define WAVE_FORMAT_96S16 0x00008000 /* 96 kHz, Stereo, 16-bit */ ++ ++ ++ERROR_LENGTH ++#define ERROR_LENGTH MAXERRORLENGTH+50 ++ ++ ++BUFFER_COUNT ++#define BUFFER_COUNT 20 ++ ++ ++BUFFER_SIZE ++#define BUFFER_SIZE 8192 ++ ++ ++GST_TYPE_WAVEFORM_SINK ++#define GST_TYPE_WAVEFORM_SINK (gst_waveform_sink_get_type()) ++ ++ ++GST_WAVEFORM_SINK ++#define GST_WAVEFORM_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_WAVEFORM_SINK,GstWaveFormSink)) ++ ++ ++GST_WAVEFORM_SINK_CLASS ++#define GST_WAVEFORM_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_WAVEFORM_SINK,GstWaveFormSinkClass)) ++ ++ ++GST_IS_WAVEFORM_SINK ++#define GST_IS_WAVEFORM_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_WAVEFORM_SINK)) ++ ++ ++GST_IS_WAVEFORM_SINK_CLASS ++#define GST_IS_WAVEFORM_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_WAVEFORM_SINK)) ++ ++ ++GstWaveFormSink ++ ++ ++GstWaveFormSinkClass ++ ++ ++GstWaveFormSink ++struct _GstWaveFormSink ++{ ++ /* parent object */ ++ GstAudioSink sink; ++ ++ /* supported caps */ ++ GstCaps *cached_caps; ++ ++ /* handle to the waveform-audio output device */ ++ HWAVEOUT hwaveout; ++ ++ /* table of buffer headers */ ++ WAVEHDR *wave_buffers; ++ ++ /* critical section protecting access to the number of free buffers */ ++ CRITICAL_SECTION critic_wave; ++ ++ /* number of free buffers available */ ++ guint free_buffers_count; ++ ++ /* current free buffer where you have to write incoming data */ ++ guint write_buffer; ++ ++ /* size of buffers streamed to the device */ ++ guint buffer_size; ++ ++ /* number of buffers streamed to the device */ ++ guint buffer_count; ++ ++ /* total of bytes in queue before they are written to the device */ ++ guint bytes_in_queue; ++ ++ /* bytes per sample from setcaps used to evaluate the number samples returned by delay */ ++ guint bytes_per_sample; ++ ++ /* wave form error string */ ++ gchar error_string[ERROR_LENGTH]; ++}; ++ ++ ++GstWaveFormSinkClass ++struct _GstWaveFormSinkClass ++{ ++ GstAudioSinkClass parent_class; ++}; ++ ++ ++gst_waveform_sink_get_type ++GType ++void ++ ++ ++GST_TYPE_XIMAGE_SRC ++#define GST_TYPE_XIMAGE_SRC (gst_ximage_src_get_type()) ++ ++ ++GST_XIMAGE_SRC ++#define GST_XIMAGE_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_XIMAGE_SRC,GstXImageSrc)) ++ ++ ++GST_XIMAGE_SRC_CLASS ++#define GST_XIMAGE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_XIMAGE_SRC,GstXImageSrc)) ++ ++ ++GST_IS_XIMAGE_SRC ++#define GST_IS_XIMAGE_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_XIMAGE_SRC)) ++ ++ ++GST_IS_XIMAGE_SRC_CLASS ++#define GST_IS_XIMAGE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_XIMAGE_SRC)) ++ ++ ++GstXImageSrc ++ ++ ++GstXImageSrcClass ++ ++ ++gst_ximage_src_get_type ++GType ++void ++ ++ ++GstXImageSrc ++struct _GstXImageSrc ++{ ++ GstPushSrc parent; ++ ++ /* Information on display */ ++ GstXContext *xcontext; ++ gint width; ++ gint height; ++ ++ Window xwindow; ++ gchar *display_name; ++ guint screen_num; ++ ++ /* Desired output framerate */ ++ gint fps_n; ++ gint fps_d; ++ ++ /* for framerate sync */ ++ GstClockID clock_id; ++ gint64 last_frame_no; ++ ++ /* Protect X Windows calls */ ++ GMutex *x_lock; ++ ++ /* Gathered pool of emitted buffers */ ++ GMutex *pool_lock; ++ GSList *buffer_pool; ++ ++ /* XFixes and XDamage support */ ++ gboolean have_xfixes; ++ gboolean have_xdamage; ++ gboolean show_pointer; ++ gboolean use_damage; ++ ++ /* co-ordinates for start and end */ ++ guint startx; ++ guint starty; ++ guint endx; ++ guint endy; ++ ++#ifdef HAVE_XFIXES ++ int fixes_event_base; ++ XFixesCursorImage *cursor_image; ++#endif ++#ifdef HAVE_XDAMAGE ++ Damage damage; ++ int damage_event_base; ++ XserverRegion damage_region; ++ GC damage_copy_gc; ++ GstXImageSrcBuffer *last_ximage; ++#endif ++}; ++ ++ ++GstXImageSrcClass ++struct _GstXImageSrcClass ++{ ++ GstPushSrcClass parent_class; ++}; ++ +--- /dev/null ++++ gst-plugins-good0.10-0.10.25/win32/common/config.h-new +@@ -0,0 +1,438 @@ ++/* Autogenerated config.h created for win32 Visual Studio builds */ ++ ++/* PREFIX -- specifically added for Windows for easier moving */ ++#define PREFIX "C:\\gstreamer" ++ ++#define GST_INSTALL_PLUGINS_HELPER PREFIX "\\libexec\\gst-install-plugins-helper.exe" ++ ++/* Define if building universal (internal helper macro) */ ++#undef AC_APPLE_UNIVERSAL_BUILD ++ ++/* Default audio sink */ ++#define DEFAULT_AUDIOSINK "directaudiosink" ++ ++/* Default audio source */ ++#define DEFAULT_AUDIOSRC "audiotestsrc" ++ ++/* Default video sink */ ++#undef DEFAULT_VIDEOSINK ++ ++/* Default video source */ ++#define DEFAULT_VIDEOSRC "videotestsrc" ++ ++/* Default visualizer */ ++#define DEFAULT_VISUALIZER "goom" ++ ++/* Disable Orc */ ++#undef DISABLE_ORC ++ ++/* Define to 1 if translation of program messages to the user's native ++ language is requested. */ ++#undef ENABLE_NLS ++ ++/* gettext package name */ ++#define GETTEXT_PACKAGE "gst-plugins-good-0.10" ++ ++/* Defined if gcov is enabled to force a rebuild due to config.h changing */ ++#undef GST_GCOV_ENABLED ++ ++/* Default errorlevel to use */ ++#define GST_LEVEL_DEFAULT GST_LEVEL_ERROR ++ ++/* GStreamer license */ ++#define GST_LICENSE "LGPL" ++ ++/* package name in plugins */ ++#define GST_PACKAGE_NAME "GStreamer Good Plugins (Ubuntu)" ++ ++/* package origin */ ++#define GST_PACKAGE_ORIGIN "Unknown package origin" ++ ++/* struct v4l2_buffer missing */ ++#undef GST_V4L2_MISSING_BUFDECL ++ ++/* I know the API is subject to change. */ ++#undef G_UDEV_API_IS_SUBJECT_TO_CHANGE ++ ++/* Define to enable aalib ASCII Art library (used by aasink). */ ++#undef HAVE_AALIB ++ ++/* Define to enable XML library (used by annodex). */ ++#undef HAVE_ANNODEX ++ ++/* Define to 1 if you have the `asinh' function. */ ++#undef HAVE_ASINH ++ ++/* Define to enable bz2 library for matroska . */ ++#undef HAVE_BZ2 ++ ++/* Define to enable Cairo graphics rendering (used by cairo). */ ++#undef HAVE_CAIRO ++ ++/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the ++ CoreFoundation framework. */ ++#undef HAVE_CFLOCALECOPYCURRENT ++ ++/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in ++ the CoreFoundation framework. */ ++#undef HAVE_CFPREFERENCESCOPYAPPVALUE ++ ++/* Define to 1 if you have the `cosh' function. */ ++#undef HAVE_COSH ++ ++/* Define if the host CPU is an Alpha */ ++#undef HAVE_CPU_ALPHA ++ ++/* Define if the host CPU is an ARM */ ++#undef HAVE_CPU_ARM ++ ++/* Define if the host CPU is a CRIS */ ++#undef HAVE_CPU_CRIS ++ ++/* Define if the host CPU is a CRISv32 */ ++#undef HAVE_CPU_CRISV32 ++ ++/* Define if the host CPU is a HPPA */ ++#undef HAVE_CPU_HPPA ++ ++/* Define if the host CPU is an x86 */ ++#define HAVE_CPU_I386 1 ++ ++/* Define if the host CPU is a IA64 */ ++#undef HAVE_CPU_IA64 ++ ++/* Define if the host CPU is a M68K */ ++#undef HAVE_CPU_M68K ++ ++/* Define if the host CPU is a MIPS */ ++#undef HAVE_CPU_MIPS ++ ++/* Define if the host CPU is a PowerPC */ ++#undef HAVE_CPU_PPC ++ ++/* Define if the host CPU is a 64 bit PowerPC */ ++#undef HAVE_CPU_PPC64 ++ ++/* Define if the host CPU is a S390 */ ++#undef HAVE_CPU_S390 ++ ++/* Define if the host CPU is a SPARC */ ++#undef HAVE_CPU_SPARC ++ ++/* Define if the host CPU is a x86_64 */ ++#undef HAVE_CPU_X86_64 ++ ++/* Define if the GNU dcgettext() function is already present or preinstalled. ++ */ ++#undef HAVE_DCGETTEXT ++ ++/* Define to enable DirectSound plug-in (used by directsoundsink). */ ++#undef HAVE_DIRECTSOUND ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_DLFCN_H ++ ++/* define for working do while(0) macros */ ++#undef HAVE_DOWHILE_MACROS ++ ++/* Define to enable raw1394 and avc1394 library (used by 1394). */ ++#undef HAVE_DV1394 ++ ++/* Define to enable ESounD sound daemon (used by esdsink). */ ++#undef HAVE_ESD ++ ++/* Define to enable building of experimental plug-ins. */ ++#undef HAVE_EXPERIMENTAL ++ ++/* Define to enable building of plug-ins with external deps. */ ++#undef HAVE_EXTERNAL ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_FCNTL_H ++ ++/* FIONREAD ioctl found in sys/filio.h */ ++#undef HAVE_FIONREAD_IN_SYS_FILIO ++ ++/* FIONREAD ioctl found in sys/ioclt.h */ ++#undef HAVE_FIONREAD_IN_SYS_IOCTL ++ ++/* Define to enable FLAC lossless audio (used by flac). */ ++#undef HAVE_FLAC ++ ++/* Define to 1 if you have the `fpclass' function. */ ++#undef HAVE_FPCLASS ++ ++/* Define if compiler supports gcc inline assembly */ ++#undef HAVE_GCC_ASM ++ ++/* Define to enable GConf libraries (used by gconfelements). */ ++#undef HAVE_GCONF ++ ++/* Define to enable GConf schemas. */ ++#undef HAVE_GCONFTOOL ++ ++/* Define to enable GDK pixbuf (used by gdkpixbuf). */ ++#undef HAVE_GDK_PIXBUF ++ ++/* Define to 1 if you have the `getpagesize' function. */ ++#undef HAVE_GETPAGESIZE ++ ++/* Define if the GNU gettext() function is already present or preinstalled. */ ++#undef HAVE_GETTEXT ++ ++/* Define to enable Video 4 Linux 2 (used by v4l2src). */ ++#undef HAVE_GST_V4L2 ++ ++/* Whether gudev is available for device detection */ ++#undef HAVE_GUDEV ++ ++/* Define to enable HAL libraries (used by halelements). */ ++#undef HAVE_HAL ++ ++/* Define if you have the iconv() function and it works. */ ++#undef HAVE_ICONV ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_INTTYPES_H ++ ++/* Define if we have struct ip_mreqn */ ++#undef HAVE_IP_MREQN ++ ++/* Define to 1 if you have the `isinf' function. */ ++#undef HAVE_ISINF ++ ++/* Define to enable jpeg library (used by jpeg). */ ++#undef HAVE_JPEG ++ ++/* Define to enable libcaca coloured ASCII art (used by cacasink). */ ++#undef HAVE_LIBCACA ++ ++/* Define to enable libdv DV demuxer/decoder (used by dv). */ ++#undef HAVE_LIBDV ++ ++/* Define to enable Portable Network Graphics library (used by png). */ ++#undef HAVE_LIBPNG ++ ++/* Define to 1 if you have the `socket' library (-lsocket). */ ++#undef HAVE_LIBSOCKET ++ ++/* soup gnome integration */ ++#undef HAVE_LIBSOUP_GNOME ++ ++/* Whether libv4l2 is available for video buffer conversion */ ++#undef HAVE_LIBV4L2 ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_MEMORY_H ++ ++/* Define to 1 if you have a working `mmap' system call. */ ++#undef HAVE_MMAP ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_NETINET_IN_H ++ ++/* Use Orc */ ++#undef HAVE_ORC ++ ++/* Define to enable OSS audio (used by ossaudio). */ ++#undef HAVE_OSS ++ ++/* Define to enable Open Sound System 4 (used by oss4). */ ++#undef HAVE_OSS4 ++ ++/* Define if OSS includes are in /machine/ */ ++#undef HAVE_OSS_INCLUDE_IN_MACHINE ++ ++/* Define if OSS includes are in / */ ++#undef HAVE_OSS_INCLUDE_IN_ROOT ++ ++/* Define if OSS includes are in /sys/ */ ++#undef HAVE_OSS_INCLUDE_IN_SYS ++ ++/* Define to enable OSX audio (used by osxaudio). */ ++#undef HAVE_OSX_AUDIO ++ ++/* Define to enable OSX video (used by osxvideosink). */ ++#undef HAVE_OSX_VIDEO ++ ++/* Define to enable pulseaudio plug-in (used by pulseaudio). */ ++#undef HAVE_PULSE ++ ++/* defined if pulseaudio >= 0.9.11 is available */ ++#undef HAVE_PULSE_0_9_11 ++ ++/* defined if pulseaudio >= 0.9.12 is available */ ++#undef HAVE_PULSE_0_9_12 ++ ++/* defined if pulseaudio >= 0.9.13 is available */ ++#undef HAVE_PULSE_0_9_13 ++ ++/* defined if pulseaudio >= 0.9.15 is available */ ++#undef HAVE_PULSE_0_9_15 ++ ++/* defined if pulseaudio >= 0.9.16 is available */ ++#undef HAVE_PULSE_0_9_16 ++ ++/* defined if pulseaudio >= 0.9.20 is available */ ++#undef HAVE_PULSE_0_9_20 ++ ++/* Define if RDTSC is available */ ++#undef HAVE_RDTSC ++ ++/* Define to 1 if you have the `rint' function. */ ++#undef HAVE_RINT ++ ++/* Define to enable Shoutcast/Icecast client library (used by shout2). */ ++#undef HAVE_SHOUT2 ++ ++/* Define to 1 if you have the `sinh' function. */ ++#undef HAVE_SINH ++ ++/* Define to enable soup http client plugin (2.4) (used by souphttpsrc). */ ++#undef HAVE_SOUP ++ ++/* Define to enable speex speech codec (used by speex). */ ++#undef HAVE_SPEEX ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_STDINT_H ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_STDLIB_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_STRINGS_H ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_STRING_H 1 ++ ++/* Define to enable Sun Audio (used by sunaudio). */ ++#undef HAVE_SUNAUDIO ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_IOCTL_H ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_PARAM_H ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_SOCKET_H ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_SYS_STAT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_TIME_H ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_SYS_TYPES_H 1 ++ ++/* Define to enable taglib tagging library (used by taglib). */ ++#undef HAVE_TAGLIB ++ ++/* Define to 1 if you have the header file. */ ++#undef HAVE_UNISTD_H ++ ++/* Define if valgrind should be used */ ++#undef HAVE_VALGRIND ++ ++/* Define to enable wavpack plug-in (used by wavpack). */ ++#undef HAVE_WAVPACK ++ ++/* Define to 1 if you have the header file. */ ++#define HAVE_WINSOCK2_H 1 ++ ++/* Define to enable X libraries and plugins (used by ximagesrc). */ ++#undef HAVE_X ++ ++/* Define to enable X Shared Memory extension. */ ++#undef HAVE_XSHM ++ ++/* Define to enable X11 XVideo extensions. */ ++#undef HAVE_XVIDEO ++ ++/* Define to enable zlib support for id3demux/qtdemux/matroska. */ ++#undef HAVE_ZLIB ++ ++/* the host CPU */ ++#define HOST_CPU "i686" ++ ++/* gettext locale dir */ ++#define LOCALEDIR PREFIX "\\share\\locale" ++ ++/* Define to the sub-directory in which libtool stores uninstalled libraries. ++ */ ++#undef LT_OBJDIR ++ ++/* Define to 1 if your C compiler doesn't accept -c and -o together. */ ++#undef NO_MINUS_C_MINUS_O ++ ++/* Name of package */ ++#define PACKAGE "gst-plugins-good" ++ ++/* Define to the address where bug reports for this package should be sent. */ ++#define PACKAGE_BUGREPORT "http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer" ++ ++/* Define to the full name of this package. */ ++#define PACKAGE_NAME "GStreamer Good Plug-ins" ++ ++/* Define to the full name and version of this package. */ ++#define PACKAGE_STRING "GStreamer Good Plug-ins 0.10.25" ++ ++/* Define to the one symbol short name of this package. */ ++#define PACKAGE_TARNAME "gst-plugins-good" ++ ++/* Define to the home page for this package. */ ++#undef PACKAGE_URL ++ ++/* Define to the version of this package. */ ++#define PACKAGE_VERSION "0.10.25" ++ ++/* directory where plugins are located */ ++#ifdef _DEBUG ++# define PLUGINDIR PREFIX "\\debug\\lib\\gstreamer-0.10" ++#else ++# define PLUGINDIR PREFIX "\\lib\\gstreamer-0.10" ++#endif ++ ++/* The size of `char', as computed by sizeof. */ ++#undef SIZEOF_CHAR ++ ++/* The size of `int', as computed by sizeof. */ ++#undef SIZEOF_INT ++ ++/* The size of `long', as computed by sizeof. */ ++#undef SIZEOF_LONG ++ ++/* The size of `short', as computed by sizeof. */ ++#undef SIZEOF_SHORT ++ ++/* The size of `void*', as computed by sizeof. */ ++#undef SIZEOF_VOIDP ++ ++/* defined if speex 1.0.x API detected */ ++#undef SPEEX_1_0 ++ ++/* Define to 1 if you have the ANSI C header files. */ ++#undef STDC_HEADERS ++ ++/* Version number of package */ ++#define VERSION "0.10.25" ++ ++/* old wavpack API */ ++#undef WAVPACK_OLD_API ++ ++/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most ++ significant byte first (like Motorola and SPARC, unlike Intel). */ ++#if defined AC_APPLE_UNIVERSAL_BUILD ++# if defined __BIG_ENDIAN__ ++# define WORDS_BIGENDIAN 1 ++# endif ++#else ++# ifndef WORDS_BIGENDIAN ++# undef WORDS_BIGENDIAN ++# endif ++#endif ++ ++/* Define to 1 if the X Window System is missing or not being used. */ ++#undef X_DISPLAY_MISSING diff -Nru gst-plugins-good0.10-0.10.25/debian/patches/default-buffer-size.patch gst-plugins-good0.10-0.10.25/debian/patches/default-buffer-size.patch --- gst-plugins-good0.10-0.10.25/debian/patches/default-buffer-size.patch 1970-01-01 00:00:00.000000000 +0000 +++ gst-plugins-good0.10-0.10.25/debian/patches/default-buffer-size.patch 2010-12-13 03:05:18.000000000 +0000 @@ -0,0 +1,53 @@ +Index: gst-plugins-good0.10-0.10.25/ext/pulse/pulsesink.c +=================================================================== +--- gst-plugins-good0.10-0.10.25.orig/ext/pulse/pulsesink.c 2010-12-13 03:15:48.695254006 +0100 ++++ gst-plugins-good0.10-0.10.25/ext/pulse/pulsesink.c 2010-12-13 04:04:37.000000000 +0100 +@@ -1217,7 +1217,7 @@ + inr = in_samples - 1; + outr = out_samples - 1; + +- GST_DEBUG_OBJECT (psink, "in %d, out %d", inr, outr); ++ GST_DEBUG_OBJECT (psink, "in %d, out %d, bps %d", inr, outr, bps); + + /* data_end points to the last sample we have to write, not past it. This is + * needed to properly handle reverse playback: it points to the last sample. */ +@@ -1244,11 +1244,11 @@ + + towrite = out_samples * bps; + +- /* Only ever write segsize bytes at once. This will +- * also limit the PA shm buffer to segsize ++ /* Only ever write bufsize bytes at once. This will ++ * also limit the PA shm buffer to bufsize + */ +- if (towrite > buf->spec.segsize) +- towrite = buf->spec.segsize; ++ if (towrite > bufsize) ++ towrite = bufsize; + + if ((pbuf->m_writable < towrite) || (offset != pbuf->m_lastoffset)) { + /* if no room left or discontinuity in offset, +@@ -1297,9 +1297,9 @@ + } + + /* make sure we only buffer up latency-time samples */ +- if (pbuf->m_writable > buf->spec.segsize) { ++ if (pbuf->m_writable > bufsize) { + /* limit buffering to latency-time value */ +- pbuf->m_writable = buf->spec.segsize; ++ pbuf->m_writable = bufsize; + + GST_LOG_OBJECT (psink, "Limiting buffering to %" G_GSIZE_FORMAT, + pbuf->m_writable); +@@ -1318,9 +1318,9 @@ + pbuf->m_writable); + + /* Just to make sure that we didn't get more than requested */ +- if (pbuf->m_writable > buf->spec.segsize) { ++ if (pbuf->m_writable > bufsize) { + /* limit buffering to latency-time value */ +- pbuf->m_writable = buf->spec.segsize; ++ pbuf->m_writable = bufsize; + } + } + diff -Nru gst-plugins-good0.10-0.10.25/debian/patches/series gst-plugins-good0.10-0.10.25/debian/patches/series --- gst-plugins-good0.10-0.10.25/debian/patches/series 2010-12-10 13:01:49.000000000 +0000 +++ gst-plugins-good0.10-0.10.25/debian/patches/series 2010-12-13 02:52:57.000000000 +0000 @@ -7,3 +7,5 @@ 99_autoreconf.patch 99_ltmain_as-needed.patch no-uncork.patch +default-buffer-size.patch +debian-changes-0.10.25-4ubuntu3~diwic2