org.gstreamer.elements.good.RTPBin Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gstreamer-java Show documentation
Java binding for the Gstreamer framework (0.10 compatible)
The newest version!
/* 
 * Copyright (c) 2010 Levente Farkas 
 * 
 * This file is part of gstreamer-java.
 *
 * This code is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with this work.  If not, see .
 */
package org.gstreamer.elements.good;

import org.gstreamer.Bin;
import org.gstreamer.Caps;
import org.gstreamer.lowlevel.GstAPI.GstCallback;

/**
 * Java representation of gstreamer gstrtpbin
 */
public class RTPBin extends Bin {
    public static final String GST_NAME = "gstrtpbin";
    public static final String GTYPE_NAME = "GstRtpBin";
	
    public RTPBin(String name) {
        this(makeRawElement(GST_NAME, name));
    }

    public RTPBin(Initializer init) {
        super(init);
    }

	/**
     * Signal emitted when an SSRC that became inactive because of a BYE packet.
     * 
     * @see #connect(ON_BYE_SSRC)
     * @see #disconnect(ON_BYE_SSRC)
     */
    public static interface ON_BYE_SSRC {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onByeSsrc(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-bye-ssrc signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_BYE_SSRC listener) {
        connect(ON_BYE_SSRC.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onByeSsrc(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-bye-ssrc signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_BYE_SSRC listener) {
        disconnect(ON_BYE_SSRC.class, listener);
    }

	/**
     * Signal emitted when an SSRC that has timed out because of BYE.
     * 
     * @see #connect(ON_BYE_TIMEOUT)
     * @see #disconnect(ON_BYE_TIMEOUT)
     */
    public static interface ON_BYE_TIMEOUT {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onByeTimeout(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-bye-timeout signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_BYE_TIMEOUT listener) {
        connect(ON_BYE_TIMEOUT.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onByeTimeout(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-bye-timeout signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_BYE_TIMEOUT listener) {
        disconnect(ON_BYE_TIMEOUT.class, listener);
    }

	/**
     * Signal emitted when a new SSRC that entered session.
     * 
     * @see #connect(ON_NEW_SSRC)
     * @see #disconnect(ON_NEW_SSRC)
     */
    public static interface ON_NEW_SSRC {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onNewSsrc(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-new-ssrc signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_NEW_SSRC listener) {
        connect(ON_NEW_SSRC.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onNewSsrc(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-new-ssrc signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_NEW_SSRC listener) {
        disconnect(ON_NEW_SSRC.class, listener);
    }

	/**
     * Signal emitted when SSRC sender has sent data up to the configured NPT stop time.
     * 
     * @see #connect(ON_NPT_STOP)
     * @see #disconnect(ON_NPT_STOP)
     */
    public static interface ON_NPT_STOP {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onNptStop(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-npt-stop signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_NPT_STOP listener) {
        connect(ON_NPT_STOP.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onNptStop(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-npt-stop signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_NPT_STOP listener) {
        disconnect(ON_NPT_STOP.class, listener);
    }

	/**
     * Signal emitted when a sender SSRC that has timed out and became a receiver.
     * 
     * @see #connect(ON_SENDER_TIMEOUT)
     * @see #disconnect(ON_SENDER_TIMEOUT)
     */
    public static interface ON_SENDER_TIMEOUT {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onSenderTimeout(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-sender-timeout signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_SENDER_TIMEOUT listener) {
        connect(ON_SENDER_TIMEOUT.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onSenderTimeout(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-sender-timeout signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_SENDER_TIMEOUT listener) {
        disconnect(ON_SENDER_TIMEOUT.class, listener);
    }

	/**
     * Signal emitted when a SSRC that is active, i.e., sending RTCP.
     * 
     * @see #connect(ON_SSRC_ACTIVE)
     * @see #disconnect(ON_SSRC_ACTIVE)
     */
    public static interface ON_SSRC_ACTIVE {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onSsrcActive(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-ssrc-active signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_SSRC_ACTIVE listener) {
        connect(ON_SSRC_ACTIVE.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onSsrcActive(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-ssrc-active signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_SSRC_ACTIVE listener) {
        disconnect(ON_SSRC_ACTIVE.class, listener);
    }

	/**
     * Signal emitted when we have an SSRC collision.
     * 
     * @see #connect(ON_SSRC_COLLISION)
     * @see #disconnect(ON_SSRC_COLLISION)
     */
    public static interface ON_SSRC_COLLISION {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onSsrcCollision(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-ssrc-collision signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_SSRC_COLLISION listener) {
        connect(ON_SSRC_COLLISION.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onSsrcCollision(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-ssrc-collision signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_SSRC_COLLISION listener) {
        disconnect(ON_SSRC_COLLISION.class, listener);
    }
    
	/**
     * Signal emitted when a SSRC that is active, i.e., sending RTCP.
     * 
     * @see #connect(ON_SSRC_SDES)
     * @see #disconnect(ON_SSRC_SDES)
     */
    public static interface ON_SSRC_SDES {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onSsrcSdes(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-ssrc-sdes signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_SSRC_SDES listener) {
        connect(ON_SSRC_SDES.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onSsrcSdes(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-ssrc-sdes signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_SSRC_SDES listener) {
        disconnect(ON_SSRC_SDES.class, listener);
    }
    
	/**
     * Signal emitted when a new SSRC that became validated.
     * 
     * @see #connect(ON_SSRC_VALIDATED)
     * @see #disconnect(ON_SSRC_VALIDATED)
     */
    public static interface ON_SSRC_VALIDATED {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onSsrcValidated(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-ssrc-validated signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_SSRC_VALIDATED listener) {
        connect(ON_SSRC_VALIDATED.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onSsrcValidated(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-ssrc-validated signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_SSRC_VALIDATED listener) {
        disconnect(ON_SSRC_VALIDATED.class, listener);
    }
    
	/**
     * Signal emitted when an SSRC that has timed out.
     * 
     * @see #connect(ON_TIMEOUT)
     * @see #disconnect(ON_TIMEOUT)
     */
    public static interface ON_TIMEOUT {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param ssrc the SSRC
         */
        public void onTimeout(RTPBin rtpbin, int session, int ssrc);
    }
    /**
     * Add a listener for the on-timeout signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final ON_TIMEOUT listener) {
        connect(ON_TIMEOUT.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int ssrc) {
                listener.onTimeout(rtpbin, session, ssrc);
            }
        });
    }    
    /**
     * Disconnect the listener for the on-timeout signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(ON_TIMEOUT listener) {
        disconnect(ON_TIMEOUT.class, listener);
    }
    
	/**
     * Request the payload type as GstCaps for pt in session.
     * 
     * @see #connect(REQUEST_PT_MAP)
     * @see #disconnect(REQUEST_PT_MAP)
     */
    public static interface REQUEST_PT_MAP {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param pt the pt
         */
        public Caps requestPtMap(RTPBin rtpbin, int session, int pt);
    }
    /**
     * Add a listener for the request-pt-map signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final REQUEST_PT_MAP listener) {
        connect(REQUEST_PT_MAP.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public Caps callback(RTPBin rtpbin, int session, int pt) {
                return listener.requestPtMap(rtpbin, session, pt);
            }
        });
    }    
    /**
     * Disconnect the listener for the request-pt-map signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(REQUEST_PT_MAP listener) {
        disconnect(REQUEST_PT_MAP.class, listener);
    }
    
	/**
     * Signal emitted when the current payload type changed to pt in session.
     * 
     * @see #connect(PAYLOAD_TYPE_CHANGE)
     * @see #disconnect(PAYLOAD_TYPE_CHANGE)
     */
    public static interface PAYLOAD_TYPE_CHANGE {
        /**
         * @param rtpbin the object which received the signal
         * @param session the session
         * @param pt the pt
         */
        public void payloadTypeChange(RTPBin rtpbin, int session, int pt);
    }
    /**
     * Add a listener for the payload-type-change signal on this RTPBin
     * 
     * @param listener The listener to be called.
     */
    public void connect(final PAYLOAD_TYPE_CHANGE listener) {
        connect(PAYLOAD_TYPE_CHANGE.class, listener, new GstCallback() {
            @SuppressWarnings("unused")
            public void callback(RTPBin rtpbin, int session, int pt) {
                listener.payloadTypeChange(rtpbin, session, pt);
            }
        });
    }    
    /**
     * Disconnect the listener for the payload-type-change signal on this RTPBin
     * 
     * @param listener The listener that was registered to receive the signal.
     */
    public void disconnect(PAYLOAD_TYPE_CHANGE listener) {
        disconnect(PAYLOAD_TYPE_CHANGE.class, listener);
    }
}