home *** CD-ROM | disk | FTP | other *** search
/ ftp.muug.mb.ca / 2014.06.ftp.muug.mb.ca.tar / ftp.muug.mb.ca / pub / openh323.tar.gz / openh323.tar / openh323 / src / channels.cxx < prev    next >
Text File  |  2003-02-10  |  62KB  |  1,945 lines
  1. /*
  2.  * channels.cxx
  3.  *
  4.  * H.323 protocol handler
  5.  *
  6.  * Open H323 Library
  7.  *
  8.  * Copyright (c) 1998-2000 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Open H323 Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions of this code were written with the assisance of funding from
  25.  * Vovida Networks, Inc. http://www.vovida.com.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: channels.cxx,v $
  30.  * Revision 1.136  2003/02/10 05:36:13  robertj
  31.  * Fixed returning mediaControlChannel address in preference to mediaChannel
  32.  *   address as Cisco's just feed your own address back at you.
  33.  *
  34.  * Revision 1.135  2002/12/18 11:20:49  craigs
  35.  * Fixed problem with T.38 channels SEGVing thanks to Vyacheslav Frolov
  36.  *
  37.  * Revision 1.134  2002/12/17 08:48:09  robertj
  38.  * Set silence suppression mode earlier in codec life so gets correct
  39.  *   value for silenceSuppression in fast start OLC's.
  40.  *
  41.  * Revision 1.133  2002/12/16 08:20:04  robertj
  42.  * Fixed problem where a spurious RTP packet full of zeros could be sent
  43.  *   at the beginning of the transmission, thanks Bruce Fitzsimons
  44.  *
  45.  * Revision 1.132  2002/11/26 02:59:25  robertj
  46.  * Added logging to help find logical channel thread stop failures.
  47.  *
  48.  * Revision 1.131  2002/10/31 00:37:47  robertj
  49.  * Enhanced jitter buffer system so operates dynamically between minimum and
  50.  *   maximum values. Altered API to assure app writers note the change!
  51.  *
  52.  * Revision 1.130  2002/08/05 10:03:47  robertj
  53.  * Cosmetic changes to normalise the usage of pragma interface/implementation.
  54.  *
  55.  * Revision 1.129  2002/06/28 03:34:28  robertj
  56.  * Fixed issues with address translation on gatekeeper RAS channel.
  57.  *
  58.  * Revision 1.128  2002/06/25 08:30:12  robertj
  59.  * Changes to differentiate between stright G.723.1 and G.723.1 Annex A using
  60.  *   the OLC dataType silenceSuppression field so does not send SID frames
  61.  *   to receiver codecs that do not understand them.
  62.  *
  63.  * Revision 1.127  2002/06/24 00:07:31  robertj
  64.  * Fixed bandwidth usage being exactly opposite (adding when it should
  65.  *   be subtracting), thanks Saswat Praharaj.
  66.  *
  67.  * Revision 1.126  2002/05/23 04:53:57  robertj
  68.  * Added function to remove a filter from logical channel.
  69.  *
  70.  * Revision 1.125  2002/05/10 05:47:15  robertj
  71.  * Added session ID to the data logical channel class.
  72.  *
  73.  * Revision 1.124  2002/05/07 23:49:11  robertj
  74.  * Fixed incorrect setting of session ID in data channel OLC, caused an
  75.  *   incorrect optional field to be included, thanks Ulrich Findeisen.
  76.  *
  77.  * Revision 1.123  2002/05/03 00:07:24  robertj
  78.  * Fixed missing setting of isRunning flag in external RTP channels.
  79.  *
  80.  * Revision 1.122  2002/05/02 07:56:27  robertj
  81.  * Added automatic clearing of call if no media (RTP data) is transferred in a
  82.  *   configurable (default 5 minutes) amount of time.
  83.  *
  84.  * Revision 1.121  2002/05/02 06:28:53  robertj
  85.  * Fixed problem with external RTP channels not fast starting.
  86.  *
  87.  * Revision 1.120  2002/04/17 05:56:05  robertj
  88.  * Added trace output of H323Channel::Direction enum.
  89.  *
  90.  * Revision 1.119  2002/02/25 08:42:26  robertj
  91.  * Fixed comments on the real time requirements of the codec.
  92.  *
  93.  * Revision 1.118  2002/02/19 06:15:20  robertj
  94.  * Allowed for RTP filter functions to force output of packet, or prevent it
  95.  *   from being sent overriding the n frames per packet algorithm.
  96.  *
  97.  * Revision 1.117  2002/02/09 04:39:05  robertj
  98.  * Changes to allow T.38 logical channels to use single transport which is
  99.  *   now owned by the OpalT38Protocol object instead of H323Channel.
  100.  *
  101.  * Revision 1.116  2002/02/05 08:13:02  robertj
  102.  * Added ability to not have addresses when external RTP channel created.
  103.  *
  104.  * Revision 1.115  2002/02/04 06:04:19  robertj
  105.  * Fixed correct exit on terminating transmit channel, thanks Norwood Systems.
  106.  *
  107.  * Revision 1.114  2002/01/27 10:49:51  rogerh
  108.  * Catch a division by zero case in a PTRACE()
  109.  *
  110.  * Revision 1.113  2002/01/24 03:33:07  robertj
  111.  * Fixed payload type being incorrect for audio after sending RFC2833 packet.
  112.  *
  113.  * Revision 1.112  2002/01/22 22:48:25  robertj
  114.  * Fixed RFC2833 support (transmitter) requiring large rewrite
  115.  *
  116.  * Revision 1.111  2002/01/22 07:08:26  robertj
  117.  * Added IllegalPayloadType enum as need marker for none set
  118.  *   and MaxPayloadType is a legal value.
  119.  *
  120.  * Revision 1.110  2002/01/22 06:05:03  robertj
  121.  * Added ability for RTP payload type to be overridden at capability level.
  122.  *
  123.  * Revision 1.109  2002/01/17 07:05:03  robertj
  124.  * Added support for RFC2833 embedded DTMF in the RTP stream.
  125.  *
  126.  * Revision 1.108  2002/01/17 00:10:37  robertj
  127.  * Fixed double copy of rtpPayloadType in RTP channel, caused much confusion.
  128.  *
  129.  * Revision 1.107  2002/01/14 05:18:44  robertj
  130.  * Fixed typo on external RTP channel constructor.
  131.  *
  132.  * Revision 1.106  2002/01/10 05:13:54  robertj
  133.  * Added support for external RTP stacks, thanks NuMind Software Systems.
  134.  *
  135.  * Revision 1.105  2002/01/09 06:05:55  robertj
  136.  * Rearranged transmitter timestamp calculation to allow for a codec that has
  137.  *   variable number of timestamp units per call to Read().
  138.  *
  139.  * Revision 1.104  2001/12/22 01:50:47  robertj
  140.  * Fixed bug in data channel (T.38) negotiations, using wrong PDU subclass.
  141.  * Fixed using correct port number in data channel (T.38) negotiations.
  142.  * Improved trace logging.
  143.  *
  144.  * Revision 1.103  2001/11/28 00:09:14  dereks
  145.  * Additional information in PTRACE output.
  146.  *
  147.  * Revision 1.102  2001/11/09 05:39:54  craigs
  148.  * Added initial T.38 support thanks to Adam Lazur
  149.  *
  150.  * Revision 1.101  2001/10/24 00:55:49  robertj
  151.  * Made cosmetic changes to H.245 miscellaneous command function.
  152.  *
  153.  * Revision 1.100  2001/10/23 02:17:16  dereks
  154.  * Initial release of cu30 video codec.
  155.  *
  156.  * Revision 1.99  2001/09/13 08:20:27  robertj
  157.  * Fixed broken back out of rev 1.95, thanks Santiago Garcia Mantinan
  158.  *
  159.  * Revision 1.98  2001/09/11 00:21:23  robertj
  160.  * Fixed missing stack sizes in endpoint for cleaner thread and jitter thread.
  161.  *
  162.  * Revision 1.97  2001/08/28 09:28:28  robertj
  163.  * Backed out change in revision 1.95, not compatible with G.711
  164.  *
  165.  * Revision 1.96  2001/08/16 06:34:42  robertj
  166.  * Plugged memory leak if using trace level 5.
  167.  *
  168.  * Revision 1.95  2001/08/10 01:34:41  robertj
  169.  * Fixed problem with incorrect timestamp if codec returns more than one
  170.  *    frame in read, thanks Lee Kirchhoff.
  171.  *
  172.  * Revision 1.94  2001/08/06 05:36:00  robertj
  173.  * Fixed GNU warnings.
  174.  *
  175.  * Revision 1.93  2001/08/06 03:08:56  robertj
  176.  * Fission of h323.h to h323ep.h & h323con.h, h323.h now just includes files.
  177.  *
  178.  * Revision 1.92  2001/07/24 02:26:44  robertj
  179.  * Added start for handling reverse channels.
  180.  *
  181.  * Revision 1.91  2001/07/17 04:44:31  robertj
  182.  * Partial implementation of T.120 and T.38 logical channels.
  183.  *
  184.  * Revision 1.90  2001/07/12 07:28:41  yurik
  185.  * WinCE fix: Sleep(0) in Main to get system chance to digest
  186.  *
  187.  * Revision 1.89  2001/06/15 07:20:35  robertj
  188.  * Moved OnClosedLogicalChannel() to be after channels threads halted.
  189.  *
  190.  * Revision 1.88  2001/06/02 01:35:32  robertj
  191.  * Added thread names.
  192.  *
  193.  * Revision 1.87  2001/05/31 06:29:48  robertj
  194.  * Changed trace of RTP mismatch so only displays for first n packets then
  195.  *   does not dump messages any more. Was exactly the opposite.
  196.  *
  197.  * Revision 1.86  2001/04/20 02:32:07  robertj
  198.  * Improved logging of bandwith, used more intuitive units.
  199.  *
  200.  * Revision 1.85  2001/04/02 04:12:53  robertj
  201.  * Fixed trace output from packet transmit timing.
  202.  *
  203.  * Revision 1.84  2001/03/23 05:38:30  robertj
  204.  * Added PTRACE_IF to output trace if a conditional is TRUE.
  205.  *
  206.  * Revision 1.83  2001/02/09 05:13:55  craigs
  207.  * Added pragma implementation to (hopefully) reduce the executable image size
  208.  * under Linux
  209.  *
  210.  * Revision 1.82  2001/02/07 05:04:45  robertj
  211.  * Improved codec read analysis debug output.
  212.  *
  213.  * Revision 1.81  2001/02/06 07:40:46  robertj
  214.  * Added debugging for timing of codec read.
  215.  *
  216.  * Revision 1.80  2001/01/25 07:27:16  robertj
  217.  * Major changes to add more flexible OpalMediaFormat class to normalise
  218.  *   all information about media types, especially codecs.
  219.  *
  220.  * Revision 1.79  2000/12/20 00:50:42  robertj
  221.  * Fixed MSVC compatibility issues (No trace).
  222.  *
  223.  * Revision 1.78  2000/12/19 22:33:44  dereks
  224.  * Adjust so that the video channel is used for reading/writing raw video
  225.  * data, which better modularizes the video codec.
  226.  *
  227.  * Revision 1.77  2000/12/17 22:45:36  robertj
  228.  * Set media stream threads to highest unprivileged priority.
  229.  *
  230.  * Revision 1.76  2000/11/24 10:52:50  robertj
  231.  * Modified the ReadFrame/WriteFrame functions to allow for variable length codecs.
  232.  * Added support for G.729 annex B packetisation scheme in RTP.
  233.  * Fixed bug in fast started G.711 codec not working in one direction.
  234.  *
  235.  * Revision 1.75  2000/10/24 00:00:09  robertj
  236.  * Improved memory hogging hash function for logical channels.
  237.  *
  238.  * Revision 1.74  2000/10/19 04:05:01  robertj
  239.  * Added compare function for logical channel numbers, thanks Yuriy Ershov.
  240.  *
  241.  * Revision 1.73  2000/09/23 06:54:44  robertj
  242.  * Prevented call of OnClose call back if channel was never opened.
  243.  *
  244.  * Revision 1.72  2000/09/22 01:35:49  robertj
  245.  * Added support for handling LID's that only do symmetric codecs.
  246.  *
  247.  * Revision 1.71  2000/09/22 00:32:33  craigs
  248.  * Added extra logging
  249.  * Fixed problems with no fastConnect with tunelling
  250.  *
  251.  * Revision 1.70  2000/09/20 01:50:21  craigs
  252.  * Added ability to set jitter buffer on a per-connection basis
  253.  *
  254.  * Revision 1.69  2000/09/14 23:03:45  robertj
  255.  * Increased timeout on asserting because of driver lockup
  256.  *
  257.  * Revision 1.68  2000/08/31 08:15:40  robertj
  258.  * Added support for dynamic RTP payload types in H.245 OpenLogicalChannel negotiations.
  259.  *
  260.  * Revision 1.67  2000/08/30 06:33:01  craigs
  261.  * Add fix to ignore small runs of consectuive mismatched payload types
  262.  *
  263.  * Revision 1.66  2000/08/25 01:10:28  robertj
  264.  * Added assert if various thrads ever fail to terminate.
  265.  *
  266.  * Revision 1.65  2000/08/21 02:50:28  robertj
  267.  * Fixed race condition if close call just as slow start media channels are opening.
  268.  *
  269.  * Revision 1.64  2000/07/14 14:04:49  robertj
  270.  * Clarified a debug message.
  271.  *
  272.  * Revision 1.63  2000/07/14 12:47:36  robertj
  273.  * Added clarification to some logging messags.
  274.  *
  275.  * Revision 1.62  2000/07/13 16:05:47  robertj
  276.  * Removed time critical priority as it can totally slag a Win98 system.
  277.  * Fixed trace message displaying mismatched codecs in RTP packet around the wrong way.
  278.  *
  279.  * Revision 1.61  2000/07/11 11:15:52  robertj
  280.  * Fixed bug when terminating RTP receiver and not also terminating transmitter.
  281.  *
  282.  * Revision 1.60  2000/06/23 02:04:01  robertj
  283.  * Increased the priority of the media channels, only relevent for Win32 at this time.
  284.  *
  285.  * Revision 1.59  2000/06/15 01:46:15  robertj
  286.  * Added channel pause (aka mute) functions.
  287.  *
  288.  * Revision 1.58  2000/05/18 12:10:50  robertj
  289.  * Removed all Sleep() calls in codec as timing innacuracies make it unusable. All
  290.  *    codec implementations must thus have timing built into them, usually using I/O.
  291.  *
  292.  * Revision 1.57  2000/05/11 23:54:25  craigs
  293.  * Fixed the Windows fix with another Linux fix. But it worked OK on the Alpha!
  294.  *
  295.  * Revision 1.56  2000/05/11 09:56:46  robertj
  296.  * Win32 compatibility and addition of some extra debugging on codec timing.
  297.  *
  298.  * Revision 1.55  2000/05/11 02:27:18  robertj
  299.  * Added "fail safe" timer sleep on codec writes when on output of jitter buffer.
  300.  *
  301.  * Revision 1.54  2000/05/04 11:52:34  robertj
  302.  * Added Packets Too Late statistics, requiring major rearrangement of jitter
  303.  *    buffer code, not also changes semantics of codec Write() function slightly.
  304.  *
  305.  * Revision 1.53  2000/05/02 04:32:26  robertj
  306.  * Fixed copyright notice comment.
  307.  *
  308.  * Revision 1.52  2000/05/01 01:01:49  robertj
  309.  * Added flag for what to do with out of orer packets (use if jitter, don't if not).
  310.  *
  311.  * Revision 1.51  2000/04/28 13:01:44  robertj
  312.  * Fixed problem with adjusting tx/rx frame counts in capabilities during fast start.
  313.  *
  314.  * Revision 1.50  2000/04/10 19:45:49  robertj
  315.  * Changed RTP data receive tp be more forgiving, will process packet even if payload type is wrong.
  316.  *
  317.  * Revision 1.49  2000/03/31 20:04:28  robertj
  318.  * Fixed log message for start/end of transmitted talk burst.
  319.  *
  320.  * Revision 1.48  2000/03/29 04:36:38  robertj
  321.  * Improved some trace logging messages.
  322.  *
  323.  * Revision 1.47  2000/03/22 01:31:36  robertj
  324.  * Fixed transmitter loop so codec can return multiple frames (crash in G.711 mode)
  325.  *
  326.  * Revision 1.46  2000/03/21 03:58:00  robertj
  327.  * Fixed stuffed up RTP transmit loop after previous change.
  328.  *
  329.  * Revision 1.45  2000/03/21 03:06:49  robertj
  330.  * Changes to make RTP TX of exact numbers of frames in some codecs.
  331.  *
  332.  * Revision 1.44  2000/03/20 20:59:28  robertj
  333.  * Fixed possible buffer overrun problem in RTP_DataFrames
  334.  *
  335.  * Revision 1.43  2000/02/24 00:34:25  robertj
  336.  * Fixed possible endless loop on channel abort, thanks Yura Ershov
  337.  *
  338.  * Revision 1.42  2000/02/04 05:11:19  craigs
  339.  * Updated for new Makefiles and for new video transmission code
  340.  *
  341.  * Revision 1.41  2000/01/13 04:03:45  robertj
  342.  * Added video transmission
  343.  *
  344.  * Revision 1.40  2000/01/08 06:52:10  robertj
  345.  * Removed invalid assert
  346.  *
  347.  * Revision 1.39  1999/12/23 23:02:35  robertj
  348.  * File reorganision for separating RTP from H.323 and creation of LID for VPB support.
  349.  *
  350.  * Revision 1.38  1999/11/22 01:37:31  robertj
  351.  * Fixed channel closure so OnClosedLogicalChannel() only called if channel was actually started.
  352.  *
  353.  * Revision 1.37  1999/11/20 05:35:26  robertj
  354.  * Extra debugging
  355.  *
  356.  * Revision 1.36  1999/11/20 00:53:47  robertj
  357.  * Fixed ability to have variable sized frames in single RTP packet under G.723.1
  358.  *
  359.  * Revision 1.35  1999/11/19 09:06:25  robertj
  360.  * Changed to close down logical channel if get a transmit codec error.
  361.  *
  362.  * Revision 1.34  1999/11/11 23:28:46  robertj
  363.  * Added first cut silence detection algorithm.
  364.  *
  365.  * Revision 1.33  1999/11/06 11:01:37  robertj
  366.  * Extra debugging.
  367.  *
  368.  * Revision 1.32  1999/11/06 05:37:44  robertj
  369.  * Complete rewrite of termination of connection to avoid numerous race conditions.
  370.  *
  371.  * Revision 1.31  1999/11/01 00:47:46  robertj
  372.  * Added close of logical channel on write error
  373.  *
  374.  * Revision 1.30  1999/10/30 12:38:24  robertj
  375.  * Added more tracing of channel threads.
  376.  *
  377.  * Revision 1.29  1999/10/08 09:59:03  robertj
  378.  * Rewrite of capability for sending multiple audio frames
  379.  *
  380.  * Revision 1.28  1999/10/08 04:58:37  robertj
  381.  * Added capability for sending multiple audio frames in single RTP packet
  382.  *
  383.  * Revision 1.27  1999/09/23 07:25:12  robertj
  384.  * Added open audio and video function to connection and started multi-frame codec send functionality.
  385.  *
  386.  * Revision 1.26  1999/09/21 14:09:02  robertj
  387.  * Removed warnings when no tracing enabled.
  388.  *
  389.  * Revision 1.25  1999/09/18 13:24:38  craigs
  390.  * Added ability to disable jitter buffer
  391.  * Added ability to access entire RTP packet in codec Write
  392.  *
  393.  * Revision 1.24  1999/09/08 04:05:48  robertj
  394.  * Added support for video capabilities & codec, still needs the actual codec itself!
  395.  *
  396.  * Revision 1.23  1999/09/03 02:17:50  robertj
  397.  * Added more debugging
  398.  *
  399.  * Revision 1.22  1999/08/31 12:34:18  robertj
  400.  * Added gatekeeper support.
  401.  *
  402.  * Revision 1.21  1999/07/16 15:02:51  robertj
  403.  * Changed jitter buffer to throw away old packets if jitter exceeded.
  404.  *
  405.  * Revision 1.20  1999/07/16 00:51:03  robertj
  406.  * Some more debugging of fast start.
  407.  *
  408.  * Revision 1.19  1999/07/15 14:45:35  robertj
  409.  * Added propagation of codec open error to shut down logical channel.
  410.  * Fixed control channel start up bug introduced with tunnelling.
  411.  *
  412.  * Revision 1.18  1999/07/15 09:04:31  robertj
  413.  * Fixed some fast start bugs
  414.  *
  415.  * Revision 1.17  1999/07/14 06:04:04  robertj
  416.  * Fixed setting of channel number in fast start.
  417.  *
  418.  * Revision 1.16  1999/07/13 09:53:24  robertj
  419.  * Fixed some problems with jitter buffer and added more debugging.
  420.  *
  421.  * Revision 1.15  1999/07/13 02:50:58  craigs
  422.  * Changed semantics of SetPlayDevice/SetRecordDevice, only descendent
  423.  *    endpoint assumes PSoundChannel devices for audio codec.
  424.  *
  425.  * Revision 1.14  1999/07/10 03:01:48  robertj
  426.  * Removed debugging.
  427.  *
  428.  * Revision 1.13  1999/07/09 06:09:49  robertj
  429.  * Major implementation. An ENORMOUS amount of stuff added everywhere.
  430.  *
  431.  * Revision 1.12  1999/06/25 14:19:40  robertj
  432.  * Fixed termination race condition in logical channel tear down.
  433.  *
  434.  * Revision 1.11  1999/06/24 13:32:45  robertj
  435.  * Fixed ability to change sound device on codec and fixed NM3 G.711 compatibility
  436.  *
  437.  * Revision 1.10  1999/06/22 13:49:40  robertj
  438.  * Added GSM support and further RTP protocol enhancements.
  439.  *
  440.  * Revision 1.9  1999/06/14 05:15:55  robertj
  441.  * Changes for using RTP sessions correctly in H323 Logical Channel context
  442.  *
  443.  * Revision 1.8  1999/06/13 12:41:14  robertj
  444.  * Implement logical channel transmitter.
  445.  * Fixed H245 connect on receiving call.
  446.  *
  447.  * Revision 1.7  1999/06/09 06:18:00  robertj
  448.  * GCC compatibiltiy.
  449.  *
  450.  * Revision 1.6  1999/06/09 05:26:19  robertj
  451.  * Major restructuring of classes.
  452.  *
  453.  * Revision 1.5  1999/06/07 00:54:30  robertj
  454.  * Displayed error on SetOption for buffer size
  455.  *
  456.  * Revision 1.4  1999/06/06 06:06:36  robertj
  457.  * Changes for new ASN compiler and v2 protocol ASN files.
  458.  *
  459.  * Revision 1.3  1999/04/26 06:14:46  craigs
  460.  * Initial implementation for RTP decoding and lots of stuff
  461.  * As a whole, these changes are called "First Noise"
  462.  *
  463.  * Revision 1.2  1999/02/25 03:26:02  robertj
  464.  * BeOS compatibility
  465.  *
  466.  * Revision 1.1  1999/01/16 01:31:09  robertj
  467.  * Initial revision
  468.  *
  469.  */
  470.  
  471. #include <ptlib.h>
  472.  
  473. #ifdef __GNUC__
  474. #pragma implementation "channels.h"
  475. #endif
  476.  
  477. #include "channels.h"
  478.  
  479. #include "h323pdu.h"
  480. #include "h323ep.h"
  481. #include "h323rtp.h"
  482.  
  483.  
  484.  
  485. #define    MAX_PAYLOAD_TYPE_MISMATCHES 8
  486. #define RTP_TRACE_DISPLAY_RATE 16000 // 2 seconds
  487.  
  488.  
  489. class H323LogicalChannelThread : public PThread
  490. {
  491.     PCLASSINFO(H323LogicalChannelThread, PThread)
  492.   public:
  493.     H323LogicalChannelThread(H323EndPoint & endpoint, H323Channel & channel, BOOL rx);
  494.     void Main();
  495.   private:
  496.     H323Channel & channel;
  497.     BOOL receiver;
  498. };
  499.  
  500.  
  501. #define new PNEW
  502.  
  503.  
  504. #if PTRACING
  505.  
  506. ostream & operator<<(ostream & out, H323Channel::Directions dir)
  507. {
  508.   static const char * const DirNames[H323Channel::NumDirections] = {
  509.     "IsBidirectional", "IsTransmitter", "IsReceiver"
  510.   };
  511.  
  512.   if (dir < H323Channel::NumDirections && DirNames[dir] != NULL)
  513.     out << DirNames[dir];
  514.   else
  515.     out << "Direction<" << (unsigned)dir << '>';
  516.  
  517.   return out;
  518. }
  519.  
  520. #else // Stuff to remove unused parameters warning
  521.  
  522. #define PTRACE_jitter
  523. #define PTRACE_skippedFrameCount
  524. #define PTRACE_additionalBuffer
  525. #define PTRACE_direction
  526.  
  527. #endif
  528.  
  529.  
  530. /////////////////////////////////////////////////////////////////////////////
  531.  
  532. H323LogicalChannelThread::H323LogicalChannelThread(H323EndPoint & endpoint,
  533.                                                    H323Channel & c,
  534.                                                    BOOL rx)
  535.   : PThread(endpoint.GetChannelThreadStackSize(),
  536.             NoAutoDeleteThread,
  537.             HighestPriority,
  538.             rx ? "LogChanRx:%0x" : "LogChanTx:%0x"),
  539.     channel(c)
  540. {
  541.   PTRACE(4, "LogChan\tStarting logical channel thread " << this);
  542.   receiver = rx;
  543.   Resume();
  544. }
  545.  
  546.  
  547. void H323LogicalChannelThread::Main()
  548. {
  549.   PTRACE(4, "LogChan\tStarted logical channel thread " << this);
  550.   if (receiver)
  551.     channel.Receive();
  552.   else
  553.     channel.Transmit();
  554.  
  555. #ifdef _WIN32_WCE
  556.     Sleep(0); // Relinquish control to other thread
  557. #endif
  558. }
  559.  
  560.  
  561. /////////////////////////////////////////////////////////////////////////////
  562.  
  563. H323ChannelNumber::H323ChannelNumber(unsigned num, BOOL fromRem)
  564. {
  565.   PAssert(num < 0x10000, PInvalidParameter);
  566.   number = num;
  567.   fromRemote = fromRem;
  568. }
  569.  
  570.  
  571. PObject * H323ChannelNumber::Clone() const
  572. {
  573.   return new H323ChannelNumber(number, fromRemote);
  574. }
  575.  
  576.  
  577. PINDEX H323ChannelNumber::HashFunction() const
  578. {
  579.   PINDEX hash = (number%17) << 1;
  580.   if (fromRemote)
  581.     hash++;
  582.   return hash;
  583. }
  584.  
  585.  
  586. void H323ChannelNumber::PrintOn(ostream & strm) const
  587. {
  588.   strm << (fromRemote ? 'R' : 'T') << '-' << number;
  589. }
  590.  
  591.  
  592. PObject::Comparison H323ChannelNumber::Compare(const PObject & obj) const
  593. {
  594. #ifndef PASN_LEANANDMEAN
  595.   PAssert(IsDescendant(Class()), PInvalidCast);
  596. #endif
  597.   const H323ChannelNumber & other = (const H323ChannelNumber &)obj;
  598.   if (number < other.number)
  599.     return LessThan;
  600.   if (number > other.number)
  601.     return GreaterThan;
  602.   if (fromRemote && !other.fromRemote)
  603.     return LessThan;
  604.   if (!fromRemote && other.fromRemote)
  605.     return GreaterThan;
  606.   return EqualTo;
  607. }
  608.  
  609.  
  610. H323ChannelNumber & H323ChannelNumber::operator++(int)
  611. {
  612.   number++;
  613.   return *this;
  614. }
  615.  
  616.  
  617. /////////////////////////////////////////////////////////////////////////////
  618.  
  619. H323Channel::H323Channel(H323Connection & conn, const H323Capability & cap)
  620.   : endpoint(conn.GetEndPoint()),
  621.     connection(conn)
  622. {
  623.   capability = (H323Capability *)cap.Clone();
  624.   codec = NULL;
  625.   bandwidthUsed = 0;
  626.   receiveThread = NULL;
  627.   transmitThread = NULL;
  628.   terminating = FALSE;
  629.   opened = FALSE;
  630.   paused = FALSE;
  631. }
  632.  
  633.  
  634. H323Channel::~H323Channel()
  635. {
  636.   connection.UseBandwidth(bandwidthUsed, TRUE);
  637.  
  638.   delete codec;
  639.   delete capability;
  640. }
  641.  
  642.  
  643. void H323Channel::PrintOn(ostream & strm) const
  644. {
  645.   strm << number;
  646. }
  647.  
  648.  
  649. unsigned H323Channel::GetSessionID() const
  650. {
  651.   return 0;
  652. }
  653.  
  654.  
  655. void H323Channel::CleanUpOnTermination()
  656. {
  657.   if (!opened || terminating)
  658.     return;
  659.  
  660.   PTRACE(3, "LogChan\tCleaning up " << number);
  661.  
  662.   terminating = TRUE;
  663.  
  664.   // If we have a codec, then close it, this allows the transmitThread to be
  665.   // broken out of any I/O block on reading the codec.
  666.   if (codec != NULL)
  667.     codec->Close();
  668.  
  669.   // If we have a receiver thread, wait for it to die.
  670.   if (receiveThread != NULL) {
  671.     PTRACE(4, "LogChan\tAwaiting termination of " << receiveThread << ' ' << receiveThread->GetThreadName());
  672.     PAssert(receiveThread->WaitForTermination(10000), "Receive media thread did not terminate");
  673.     delete receiveThread;
  674.     receiveThread = NULL;
  675.   }
  676.  
  677.   // If we have a transmitter thread, wait for it to die.
  678.   if (transmitThread != NULL) {
  679.     PTRACE(4, "LogChan\tAwaiting termination of " << transmitThread << ' ' << transmitThread->GetThreadName());
  680.     PAssert(transmitThread->WaitForTermination(10000), "Transmit media thread did not terminate");
  681.     delete transmitThread;
  682.     transmitThread = NULL;
  683.   }
  684.  
  685.   // Signal to the connection that this channel is on the way out
  686.   connection.OnClosedLogicalChannel(*this);
  687.  
  688.   PTRACE(3, "LogChan\tCleaned up " << number);
  689. }
  690.  
  691.  
  692. BOOL H323Channel::IsRunning() const
  693. {
  694.   if (receiveThread  != NULL && !receiveThread ->IsTerminated())
  695.     return TRUE;
  696.  
  697.   if (transmitThread != NULL && !transmitThread->IsTerminated())
  698.     return TRUE;
  699.  
  700.   return FALSE;
  701. }
  702.  
  703.  
  704. BOOL H323Channel::OnReceivedPDU(const H245_OpenLogicalChannel & /*pdu*/,
  705.                                 unsigned & /*errorCode*/)
  706. {
  707.   return TRUE;
  708. }
  709.  
  710.  
  711. BOOL H323Channel::OnReceivedAckPDU(const H245_OpenLogicalChannelAck & /*pdu*/)
  712. {
  713.   return TRUE;
  714. }
  715.  
  716.  
  717. void H323Channel::OnSendOpenAck(const H245_OpenLogicalChannel & /*pdu*/,
  718.                                 H245_OpenLogicalChannelAck & /* pdu*/) const
  719. {
  720. }
  721.  
  722.  
  723. void H323Channel::OnFlowControl(long bitRateRestriction)
  724. {
  725.   if (GetCodec() != NULL)
  726.     codec->OnFlowControl(bitRateRestriction);
  727.   else
  728.     PTRACE(3, "LogChan\tOnFlowControl: " << bitRateRestriction);
  729. }
  730.  
  731.  
  732. void H323Channel::OnMiscellaneousCommand(const H245_MiscellaneousCommand_type & type)
  733. {
  734.   if (GetCodec() != NULL)
  735.     codec->OnMiscellaneousCommand(type);
  736.   else
  737.     PTRACE(3, "LogChan\tOnMiscellaneousCommand: chan=" << number
  738.            << ", type=" << type.GetTagName());
  739. }
  740.  
  741.  
  742. void H323Channel::OnMiscellaneousIndication(const H245_MiscellaneousIndication_type & type)
  743. {
  744.   if (GetCodec() != NULL)
  745.     codec->OnMiscellaneousIndication(type);
  746.   else
  747.     PTRACE(3, "LogChan\tOnMiscellaneousIndication: chan=" << number
  748.            << ", type=" << type.GetTagName());
  749. }
  750.  
  751.  
  752. void H323Channel::OnJitterIndication(DWORD PTRACE_jitter,
  753.                                      int   PTRACE_skippedFrameCount,
  754.                                      int   PTRACE_additionalBuffer)
  755. {
  756.   PTRACE(3, "LogChan\tOnJitterIndication:"
  757.             " jitter=" << PTRACE_jitter <<
  758.             " skippedFrameCount=" << PTRACE_skippedFrameCount <<
  759.             " additionalBuffer=" << PTRACE_additionalBuffer);
  760. }
  761.  
  762.  
  763. BOOL H323Channel::SetInitialBandwidth()
  764. {
  765.   if (GetCodec() == NULL)
  766.     return TRUE;
  767.  
  768.   return SetBandwidthUsed(codec->GetMediaFormat().GetBandwidth()/100);
  769. }
  770.  
  771.  
  772. BOOL H323Channel::SetBandwidthUsed(unsigned bandwidth)
  773. {
  774.   PTRACE(3, "LogChan\tBandwidth requested/used = "
  775.          << bandwidth/10 << '.' << bandwidth%10 << '/'
  776.          << bandwidthUsed/10 << '.' << bandwidthUsed%10
  777.          << " kb/s");
  778.   connection.UseBandwidth(bandwidthUsed, TRUE);
  779.   bandwidthUsed = 0;
  780.  
  781.   if (!connection.UseBandwidth(bandwidth, FALSE))
  782.     return FALSE;
  783.  
  784.   bandwidthUsed = bandwidth;
  785.   return TRUE;
  786. }
  787.  
  788.  
  789. BOOL H323Channel::Open()
  790. {
  791.   if (opened)
  792.     return TRUE;
  793.  
  794.   // Give the connection (or endpoint) a chance to do something with
  795.   // the opening of the codec. Default calls codec->Open();
  796.   if (!connection.OnStartLogicalChannel(*this)) {
  797.     PTRACE(1, "LogChan\tOnStartLogicalChannel failed");
  798.     return FALSE;
  799.   }
  800.   
  801.   opened = TRUE;
  802.   return TRUE;
  803. }
  804.  
  805.  
  806. H323Codec * H323Channel::GetCodec() const
  807. {
  808.   if (codec == NULL) {
  809.     ((H323Channel*)this)->codec = capability->CreateCodec(
  810.                   GetDirection() == IsReceiver ? H323Codec::Decoder : H323Codec::Encoder);
  811.     if (codec && codec->IsDescendant(H323AudioCodec::Class()))
  812.       ((H323AudioCodec*)codec)->SetSilenceDetectionMode(endpoint.GetSilenceDetectionMode()); 
  813.   }
  814.  
  815.   return codec;
  816. }
  817.  
  818.  
  819. void H323Channel::SendMiscCommand(unsigned command)
  820. { 
  821.   connection.SendLogicalChannelMiscCommand(*this, command); 
  822. }
  823.  
  824.  
  825. /////////////////////////////////////////////////////////////////////////////
  826.  
  827. H323UnidirectionalChannel::H323UnidirectionalChannel(H323Connection & conn,
  828.                                                      const H323Capability & cap,
  829.                                                      Directions direction)
  830.   : H323Channel(conn, cap),
  831.     receiver(direction == IsReceiver)
  832. {
  833. }
  834.  
  835.  
  836. H323Channel::Directions H323UnidirectionalChannel::GetDirection() const
  837. {
  838.   return receiver ? IsReceiver : IsTransmitter;
  839. }
  840.  
  841.  
  842. BOOL H323UnidirectionalChannel::Start()
  843. {
  844.   if (!Open())
  845.     return FALSE;
  846.  
  847.   PThread * thread = new H323LogicalChannelThread(endpoint, *this, receiver);
  848.  
  849.   if (receiver)
  850.     receiveThread  = thread;
  851.   else
  852.     transmitThread = thread;
  853.   return TRUE;
  854. }
  855.  
  856.  
  857. /////////////////////////////////////////////////////////////////////////////
  858.  
  859. H323BidirectionalChannel::H323BidirectionalChannel(H323Connection & conn,
  860.                                                    const H323Capability & cap)
  861.   : H323Channel(conn, cap)
  862. {
  863. }
  864.  
  865.  
  866. H323Channel::Directions H323BidirectionalChannel::GetDirection() const
  867. {
  868.   return IsBidirectional;
  869. }
  870.  
  871.  
  872. BOOL H323BidirectionalChannel::Start()
  873. {
  874.   receiveThread  = new H323LogicalChannelThread(endpoint, *this, TRUE);
  875.   transmitThread = new H323LogicalChannelThread(endpoint, *this, FALSE);
  876.   return TRUE;
  877. }
  878.  
  879.  
  880. /////////////////////////////////////////////////////////////////////////////
  881.  
  882. H323_RealTimeChannel::H323_RealTimeChannel(H323Connection & connection,
  883.                                            const H323Capability & capability,
  884.                                            Directions direction)
  885.   : H323UnidirectionalChannel(connection, capability, direction)
  886. {
  887.   rtpPayloadType = RTP_DataFrame::IllegalPayloadType;
  888. }
  889.  
  890.  
  891. BOOL H323_RealTimeChannel::OnSendingPDU(H245_OpenLogicalChannel & open) const
  892. {
  893.   PTRACE(3, "H323RTP\tOnSendingPDU");
  894.  
  895.   open.m_forwardLogicalChannelNumber = (unsigned)number;
  896.  
  897.   if (open.HasOptionalField(H245_OpenLogicalChannel::e_reverseLogicalChannelParameters)) {
  898.     open.m_reverseLogicalChannelParameters.IncludeOptionalField(
  899.             H245_OpenLogicalChannel_reverseLogicalChannelParameters::e_multiplexParameters);
  900.     // Set the communications information for unicast IPv4
  901.     open.m_reverseLogicalChannelParameters.m_multiplexParameters.SetTag(
  902.                 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters
  903.                     ::e_h2250LogicalChannelParameters);
  904.  
  905.     return OnSendingPDU(open.m_reverseLogicalChannelParameters.m_multiplexParameters);
  906.   }
  907.   else {
  908.     // Set the communications information for unicast IPv4
  909.     open.m_forwardLogicalChannelParameters.m_multiplexParameters.SetTag(
  910.                 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters
  911.                     ::e_h2250LogicalChannelParameters);
  912.  
  913.     return OnSendingPDU(open.m_forwardLogicalChannelParameters.m_multiplexParameters);
  914.   }
  915. }
  916.  
  917.  
  918. void H323_RealTimeChannel::OnSendOpenAck(const H245_OpenLogicalChannel & open,
  919.                                          H245_OpenLogicalChannelAck & ack) const
  920. {
  921.   PTRACE(3, "H323RTP\tOnSendOpenAck");
  922.  
  923.   // set forwardMultiplexAckParameters option
  924.   ack.IncludeOptionalField(H245_OpenLogicalChannelAck::e_forwardMultiplexAckParameters);
  925.  
  926.   // select H225 choice
  927.   ack.m_forwardMultiplexAckParameters.SetTag(
  928.       H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::e_h2250LogicalChannelAckParameters);
  929.  
  930.   // get H225 parms
  931.   H245_H2250LogicalChannelAckParameters & param = ack.m_forwardMultiplexAckParameters;
  932.  
  933.   // set session ID
  934.   param.IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_sessionID);
  935.   const H245_H2250LogicalChannelParameters & openparam =
  936.                           open.m_forwardLogicalChannelParameters.m_multiplexParameters;
  937.   unsigned sessionID = openparam.m_sessionID;
  938.   param.m_sessionID = sessionID;
  939.  
  940.   OnSendOpenAck(param);
  941.  
  942.   PTRACE(2, "H323RTP\tSending open logical channel ACK: sessionID=" << sessionID);
  943. }
  944.  
  945.  
  946. BOOL H323_RealTimeChannel::OnReceivedPDU(const H245_OpenLogicalChannel & open,
  947.                                          unsigned & errorCode)
  948. {
  949.   if (receiver)
  950.     number = H323ChannelNumber(open.m_forwardLogicalChannelNumber, TRUE);
  951.  
  952.   PTRACE(3, "H323RTP\tOnReceivedPDU for channel: " << number);
  953.  
  954.   unsigned prevTxFrames = capability->GetTxFramesInPacket();
  955.   unsigned prevRxFrames = capability->GetRxFramesInPacket();
  956.   PString  prevFormat   = capability->GetFormatName();
  957.  
  958.   BOOL reverse = open.HasOptionalField(H245_OpenLogicalChannel::e_reverseLogicalChannelParameters);
  959.   const H245_DataType & dataType = reverse ? open.m_reverseLogicalChannelParameters.m_dataType
  960.                                            : open.m_forwardLogicalChannelParameters.m_dataType;
  961.  
  962.   if (!capability->OnReceivedPDU(dataType, receiver)) {
  963.     PTRACE(1, "H323RTP\tData type not supported");
  964.     errorCode = H245_OpenLogicalChannelReject_cause::e_dataTypeNotSupported;
  965.     return FALSE;
  966.   }
  967.  
  968.   // If we have already created a codec, and the new parameters indicate that
  969.   // the capability limits have changed, then kill off the old codec it will
  970.   // be wrongly constructed.
  971.   if (codec != NULL &&
  972.       (prevTxFrames != capability->GetTxFramesInPacket() ||
  973.        prevRxFrames != capability->GetRxFramesInPacket() ||
  974.        prevFormat   != capability->GetFormatName())) {
  975.     delete codec;
  976.     codec = NULL;
  977.   }
  978.  
  979.   if (reverse) {
  980.     if (open.m_reverseLogicalChannelParameters.m_multiplexParameters.GetTag() ==
  981.              H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::e_h2250LogicalChannelParameters)
  982.       return OnReceivedPDU(open.m_reverseLogicalChannelParameters.m_multiplexParameters, errorCode);
  983.   }
  984.   else {
  985.     if (open.m_forwardLogicalChannelParameters.m_multiplexParameters.GetTag() ==
  986.              H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::e_h2250LogicalChannelParameters)
  987.       return OnReceivedPDU(open.m_forwardLogicalChannelParameters.m_multiplexParameters, errorCode);
  988.   }
  989.  
  990.   PTRACE(1, "H323RTP\tOnly H.225.0 multiplex supported");
  991.   errorCode = H245_OpenLogicalChannelReject_cause::e_unsuitableReverseParameters;
  992.   return FALSE;
  993. }
  994.  
  995.  
  996. BOOL H323_RealTimeChannel::OnReceivedAckPDU(const H245_OpenLogicalChannelAck & ack)
  997. {
  998.   PTRACE(3, "H323RTP\tOnReceiveOpenAck");
  999.  
  1000.   if (!ack.HasOptionalField(H245_OpenLogicalChannelAck::e_forwardMultiplexAckParameters)) {
  1001.     PTRACE(1, "H323RTP\tNo forwardMultiplexAckParameters");
  1002.     return FALSE;
  1003.   }
  1004.  
  1005.   if (ack.m_forwardMultiplexAckParameters.GetTag() !=
  1006.             H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::e_h2250LogicalChannelAckParameters) {
  1007.     PTRACE(1, "H323RTP\tOnly H.225.0 multiplex supported");
  1008.     return FALSE;
  1009.   }
  1010.  
  1011.   return OnReceivedAckPDU(ack.m_forwardMultiplexAckParameters);
  1012. }
  1013.  
  1014.  
  1015. BOOL H323_RealTimeChannel::SetDynamicRTPPayloadType(int newType)
  1016. {
  1017.   PTRACE(1, "H323RTP\tSetting dynamic RTP payload type: " << newType);
  1018.  
  1019.   // This is "no change"
  1020.   if (newType == -1)
  1021.     return TRUE;
  1022.  
  1023.   // Check for illegal type
  1024.   if (newType < RTP_DataFrame::DynamicBase || newType > RTP_DataFrame::MaxPayloadType)
  1025.     return FALSE;
  1026.  
  1027.   // Check for overwriting "known" type
  1028.   if (rtpPayloadType < RTP_DataFrame::DynamicBase)
  1029.     return FALSE;
  1030.  
  1031.   rtpPayloadType = (RTP_DataFrame::PayloadTypes)newType;
  1032.   PTRACE(3, "H323RTP\tSetting dynamic payload type to " << rtpPayloadType);
  1033.   return TRUE;
  1034. }
  1035.  
  1036.  
  1037. /////////////////////////////////////////////////////////////////////////////
  1038.  
  1039. H323_RTPChannel::H323_RTPChannel(H323Connection & conn,
  1040.                                  const H323Capability & cap,
  1041.                                  Directions direction,
  1042.                                  RTP_Session & r)
  1043.   : H323_RealTimeChannel(conn, cap, direction),
  1044.     rtpSession(r),
  1045.     rtpCallbacks(*(H323_RTP_Session *)r.GetUserData())
  1046. {
  1047.   PTRACE(3, "H323RTP\t" << (receiver ? "Receiver" : "Transmitter")
  1048.          << " created using session " << GetSessionID());
  1049. }
  1050.  
  1051.  
  1052. H323_RTPChannel::~H323_RTPChannel()
  1053. {
  1054.   // Finished with the RTP session, this will delete the session if it is no
  1055.   // longer referenced by any logical channels.
  1056.   connection.ReleaseSession(GetSessionID());
  1057. }
  1058.  
  1059.  
  1060. void H323_RTPChannel::CleanUpOnTermination()
  1061. {
  1062.   if (terminating)
  1063.     return;
  1064.  
  1065.   PTRACE(3, "H323RTP\tCleaning up RTP " << number);
  1066.  
  1067.   // Break any I/O blocks and wait for the thread that uses this object to
  1068.   // terminate before we allow it to be deleted.
  1069.   if ((receiver ? receiveThread : transmitThread) != NULL)
  1070.     rtpSession.Close(receiver);
  1071.  
  1072.   H323Channel::CleanUpOnTermination();
  1073. }
  1074.  
  1075.  
  1076. unsigned H323_RTPChannel::GetSessionID() const
  1077. {
  1078.   return rtpSession.GetSessionID();
  1079. }
  1080.  
  1081.  
  1082. BOOL H323_RTPChannel::Open()
  1083. {
  1084.   if (opened)
  1085.     return TRUE;
  1086.  
  1087.   if (!GetCodec()->GetMediaFormat().IsValid()) {
  1088.     PTRACE(1, "LogChan\t" << (GetDirection() == IsReceiver ? "Receive" : "Transmit")
  1089.            << " thread aborted (invalid media format)");
  1090.     return FALSE;
  1091.   }
  1092.  
  1093.   // Open the codec
  1094.   if (!GetCodec()->Open(connection)) {
  1095.     PTRACE(1, "LogChan\t" << (GetDirection() == IsReceiver ? "Receive" : "Transmit")
  1096.            << " thread aborted (open fail) for "<< *capability);
  1097.     return FALSE;
  1098.   }
  1099.  
  1100.   // Give the connection (or endpoint) a chance to do something with
  1101.   // the opening of the codec. Default calls codec->Open();
  1102.   if (!connection.OnStartLogicalChannel(*this)) {
  1103.     PTRACE(1, "LogChan\t" << (GetDirection() == IsReceiver ? "Receive" : "Transmit")
  1104.            << " thread aborted (OnStartLogicalChannel fail)");
  1105.     return FALSE;
  1106.   }
  1107.   
  1108.   PTRACE(3, "LogChan\tOpened using capability " << *capability);
  1109.  
  1110.   GetCodec()->AttachLogicalChannel((H323Channel*)this);
  1111.  
  1112.   opened = TRUE;
  1113.  
  1114.   return TRUE;
  1115. }
  1116.  
  1117.  
  1118. BOOL H323_RTPChannel::OnSendingPDU(H245_H2250LogicalChannelParameters & param) const
  1119. {
  1120.   return rtpCallbacks.OnSendingPDU(*this, param);
  1121. }
  1122.  
  1123.  
  1124. void H323_RTPChannel::OnSendOpenAck(H245_H2250LogicalChannelAckParameters & param) const
  1125. {
  1126.   rtpCallbacks.OnSendingAckPDU(*this, param);
  1127. }
  1128.  
  1129.  
  1130. BOOL H323_RTPChannel::OnReceivedPDU(const H245_H2250LogicalChannelParameters & param,
  1131.                                     unsigned & errorCode)
  1132. {
  1133.   return rtpCallbacks.OnReceivedPDU(*this, param, errorCode);
  1134. }
  1135.  
  1136.  
  1137. BOOL H323_RTPChannel::OnReceivedAckPDU(const H245_H2250LogicalChannelAckParameters & param)
  1138. {
  1139.   return rtpCallbacks.OnReceivedAckPDU(*this, param);
  1140. }
  1141.  
  1142.  
  1143. #if PTRACING
  1144. class CodecReadAnalyser
  1145. {
  1146.   enum { MaxSamples = 1000 };
  1147.   public:
  1148.     CodecReadAnalyser() { count = 0; }
  1149.     void AddSample(DWORD timestamp)
  1150.       {
  1151.         if (count < MaxSamples) {
  1152.           tick[count] = PTimer::Tick();
  1153.           rtp[count] = timestamp;
  1154.           count++;
  1155.         }
  1156.       }
  1157.     friend ostream & operator<<(ostream & strm, const CodecReadAnalyser & analysis)
  1158.       {
  1159.         PTimeInterval minimum = PMaxTimeInterval;
  1160.         PTimeInterval maximum;
  1161.         for (PINDEX i = 1; i < analysis.count; i++) {
  1162.           PTimeInterval delta = analysis.tick[i] - analysis.tick[i-1];
  1163.           strm << setw(6) << analysis.rtp[i] << ' '
  1164.                << setw(6) << (analysis.tick[i] - analysis.tick[0]) << ' '
  1165.                << setw(6) << delta
  1166.                << '\n';
  1167.           if (delta > maximum)
  1168.             maximum = delta;
  1169.           if (delta < minimum)
  1170.             minimum = delta;
  1171.         }
  1172.         strm << "Maximum delta time: " << maximum << "\n"
  1173.                 "Minimum delta time: " << minimum << '\n';
  1174.         return strm;
  1175.       }
  1176.   private:
  1177.     PTimeInterval tick[MaxSamples];
  1178.     DWORD rtp[MaxSamples];
  1179.     PINDEX count;
  1180. };
  1181. #endif
  1182.  
  1183.  
  1184. void H323_RTPChannel::Transmit()
  1185. {
  1186.   if (terminating) {
  1187.     PTRACE(3, "H323RTP\tTransmit thread terminated on start up");
  1188.     return;
  1189.   }
  1190.  
  1191.   const OpalMediaFormat & mediaFormat = codec->GetMediaFormat();
  1192.  
  1193.   // Get parameters from the codec on time and data sizes
  1194.   BOOL isAudio = mediaFormat.NeedsJitterBuffer();
  1195.   unsigned framesInPacket = capability->GetTxFramesInPacket();
  1196.   unsigned maxFrameSize = mediaFormat.GetFrameSize();
  1197.   if (maxFrameSize == 0)
  1198.     maxFrameSize = isAudio ? 8 : 2000;
  1199.   RTP_DataFrame frame(framesInPacket*maxFrameSize);
  1200.  
  1201.   if (rtpPayloadType == RTP_DataFrame::IllegalPayloadType) {
  1202.     rtpPayloadType = capability->GetPayloadType();
  1203.     if (rtpPayloadType == RTP_DataFrame::IllegalPayloadType)
  1204.       rtpPayloadType = mediaFormat.GetPayloadType();
  1205.   }
  1206.  
  1207.   if (mediaFormat.GetTimeUnits() != 0) {
  1208.   PTRACE(2, "H323RTP\tTransmit " << mediaFormat << " thread started:"
  1209.             " rate=" << codec->GetFrameRate() <<
  1210.             " time=" << (codec->GetFrameRate()/mediaFormat.GetTimeUnits()) << "ms" <<
  1211.             " size=" << framesInPacket << '*' << maxFrameSize << '='
  1212.                      << (framesInPacket*maxFrameSize) );
  1213.   } else {
  1214.   PTRACE(2, "H323RTP\tTransmit " << mediaFormat << " thread started:"
  1215.             " rate=" << codec->GetFrameRate() <<
  1216.             " time= GetTimeUnits() is zero" <<
  1217.             " size=" << framesInPacket << '*' << maxFrameSize << '='
  1218.                      << (framesInPacket*maxFrameSize) );
  1219.   }
  1220.  
  1221.   // This is real time so need to keep track of elapsed milliseconds
  1222.   BOOL silent = TRUE;
  1223.   unsigned length;
  1224.   unsigned frameOffset = 0;
  1225.   unsigned frameCount = 0;
  1226.   DWORD rtpTimestamp = 0;
  1227.   frame.SetPayloadSize(0);
  1228.  
  1229. #if PTRACING
  1230.   DWORD lastDisplayedTimestamp = 0;
  1231.   CodecReadAnalyser * codecReadAnalysis = NULL;
  1232.   if (PTrace::GetLevel() >= 5)
  1233.     codecReadAnalysis = new CodecReadAnalyser;
  1234. #endif
  1235.  
  1236.   /* Now keep getting encoded frames from the codec, it is expected that the
  1237.      Read() function will maintain the Real Time aspects of the transmission.
  1238.      That is for GSM codec say with a single frame, this function will take
  1239.      20 milliseconds to complete.
  1240.    */
  1241.   while (codec->Read(frame.GetPayloadPtr()+frameOffset, length, frame)) {
  1242.     // Calculate the timestamp and real time to take in processing
  1243.     rtpTimestamp += codec->GetFrameRate();
  1244.  
  1245. #if PTRACING
  1246.     if (rtpTimestamp - lastDisplayedTimestamp > RTP_TRACE_DISPLAY_RATE) {
  1247.       PTRACE(3, "H323RTP\tTransmitter sent timestamp " << rtpTimestamp);
  1248.       lastDisplayedTimestamp = rtpTimestamp;
  1249.     }
  1250.  
  1251.     if (codecReadAnalysis != NULL)
  1252.       codecReadAnalysis->AddSample(rtpTimestamp);
  1253. #endif
  1254.  
  1255.     if (paused)
  1256.       length = 0; // Act as though silent/no video
  1257.  
  1258.     // Handle marker bit for audio codec
  1259.     if (isAudio) {
  1260.       // If switching from silence to signal
  1261.       if (silent && length > 0) {
  1262.         silent = FALSE;
  1263.         frame.SetMarker(TRUE);  // Set flag for start of sound
  1264.         PTRACE(3, "H323RTP\tTransmit start of talk burst: " << rtpTimestamp);
  1265.       }
  1266.       // If switching from signal to silence
  1267.       else if (!silent && length == 0) {
  1268.         silent = TRUE;
  1269.         // If had some data waiting to go out
  1270.         if (frameOffset > 0)
  1271.           frameCount = framesInPacket;  // Force the RTP write
  1272.         PTRACE(3, "H323RTP\tTransmit  end  of talk burst: " << rtpTimestamp);
  1273.       }
  1274.     }
  1275.  
  1276.     // See if is silence or have some audio data to stuff in the RTP packet
  1277.     if (length == 0)
  1278.       frame.SetTimestamp(rtpTimestamp);
  1279.     else {
  1280.       silenceStartTick = PTimer::Tick();
  1281.  
  1282.       // If first read frame in packet, set timestamp for it
  1283.       if (frameOffset == 0)
  1284.         frame.SetTimestamp(rtpTimestamp);
  1285.       frameOffset += length;
  1286.  
  1287.       // Look for special cases
  1288.       if (rtpPayloadType == RTP_DataFrame::G729 && length == 2) {
  1289.         /* If we have a G729 sid frame (ie 2 bytes instead of 10) then we must
  1290.            not send any more frames in the RTP packet.
  1291.          */
  1292.         frameCount = framesInPacket;
  1293.       }
  1294.       else {
  1295.         /* Increment by number of frames that were read in one hit Note a
  1296.            codec that does variable length frames should never return more
  1297.            than one frame per Read() call or confusion will result.
  1298.          */
  1299.         frameCount += (length + maxFrameSize - 1)/maxFrameSize;
  1300.       }
  1301.     }
  1302.  
  1303.     BOOL sendPacket = FALSE;
  1304.  
  1305.     // Have read number of frames for packet (or just went silent)
  1306.     if (frameCount >= framesInPacket) {
  1307.       // Set payload size to frame offset, now length of frame.
  1308.       frame.SetPayloadSize(frameOffset);
  1309.       frame.SetPayloadType(rtpPayloadType);
  1310.  
  1311.       frameOffset = 0;
  1312.       frameCount = 0;
  1313.  
  1314.       sendPacket = TRUE;
  1315.     }
  1316.  
  1317.     filterMutex.Wait();
  1318.     for (PINDEX i = 0; i < filters.GetSize(); i++)
  1319.       filters[i](frame, (INT)&sendPacket);
  1320.     filterMutex.Signal();
  1321.  
  1322.     if (sendPacket || (silent && frame.GetPayloadSize() > 0)) {
  1323.       // Send the frame of coded data we have so far to RTP transport
  1324.       if (!rtpSession.WriteData(frame))
  1325.          break;
  1326.  
  1327.       // Reset flag for in talk burst
  1328.       if (isAudio)
  1329.         frame.SetMarker(FALSE); 
  1330.  
  1331.       frame.SetPayloadSize(0);
  1332.       frameOffset = 0;
  1333.       frameCount = 0;
  1334.     }
  1335.  
  1336.     if (terminating)
  1337.       break;
  1338.   }
  1339.  
  1340. #if PTRACING
  1341.   PTRACE(5, "Codec read timing:\n" << *codecReadAnalysis);
  1342.   delete codecReadAnalysis;
  1343. #endif
  1344.  
  1345.   if (!terminating)
  1346.     connection.CloseLogicalChannelNumber(number);
  1347.  
  1348.   PTRACE(2, "H323RTP\tTransmit " << mediaFormat << " thread ended");
  1349. }
  1350.  
  1351.  
  1352. void H323_RTPChannel::Receive()
  1353. {
  1354.   if (terminating) {
  1355.     PTRACE(3, "H323RTP\tReceive thread terminated on start up");
  1356.     return;
  1357.   }
  1358.  
  1359.   const OpalMediaFormat & mediaFormat = codec->GetMediaFormat();
  1360.  
  1361.   PTRACE(2, "H323RTP\tReceive " << mediaFormat << " thread started.");
  1362.  
  1363.   // if jitter buffer required, start the thread that is on the other end of it
  1364.   if (mediaFormat.NeedsJitterBuffer())
  1365.     rtpSession.SetJitterBufferSize(connection.GetMinAudioJitterDelay()*mediaFormat.GetTimeUnits(),
  1366.                                    connection.GetMaxAudioJitterDelay()*mediaFormat.GetTimeUnits(),
  1367.                                    endpoint.GetJitterThreadStackSize());
  1368.  
  1369.   // Keep time using th RTP timestamps.
  1370.   DWORD codecFrameRate = codec->GetFrameRate();
  1371.   DWORD rtpTimestamp = 0;
  1372. #if PTRACING
  1373.   DWORD lastDisplayedTimestamp = 0;
  1374. #endif
  1375.  
  1376.   // keep track of consecutive payload type mismatches
  1377.   int consecutiveMismatches = 0;
  1378.  
  1379.   if (rtpPayloadType == RTP_DataFrame::IllegalPayloadType) {
  1380.     rtpPayloadType = capability->GetPayloadType();
  1381.     if (rtpPayloadType == RTP_DataFrame::IllegalPayloadType)
  1382.       rtpPayloadType = mediaFormat.GetPayloadType();
  1383.   }
  1384.  
  1385.   RTP_DataFrame frame;
  1386.   while (rtpSession.ReadBufferedData(rtpTimestamp, frame)) {
  1387.  
  1388.     filterMutex.Wait();
  1389.     for (PINDEX i = 0; i < filters.GetSize(); i++)
  1390.       filters[i](frame, 0);
  1391.     filterMutex.Signal();
  1392.  
  1393.     int size = frame.GetPayloadSize();
  1394.     rtpTimestamp = frame.GetTimestamp();
  1395.  
  1396. #if PTRACING
  1397.     if (rtpTimestamp - lastDisplayedTimestamp > RTP_TRACE_DISPLAY_RATE) {
  1398.       PTRACE(3, "H323RTP\tReceiver written timestamp " << rtpTimestamp);
  1399.       lastDisplayedTimestamp = rtpTimestamp;
  1400.     }
  1401. #endif
  1402.  
  1403.     unsigned written;
  1404.     BOOL ok = TRUE;
  1405.     if (size == 0) {
  1406.       ok = codec->Write(NULL, 0, frame, written);
  1407.       rtpTimestamp += codecFrameRate;
  1408.     } else {
  1409.       silenceStartTick = PTimer::Tick();
  1410.  
  1411.       BOOL isCodecPacket = TRUE;
  1412.  
  1413.       if (frame.GetPayloadType() == rtpPayloadType) {
  1414.         PTRACE_IF(2, consecutiveMismatches > 0,
  1415.                   "H323RTP\tPayload type matched again " << rtpPayloadType);
  1416.         consecutiveMismatches = 0;
  1417.       }
  1418.       else {
  1419.         consecutiveMismatches++;
  1420.         if (consecutiveMismatches >= MAX_PAYLOAD_TYPE_MISMATCHES) {
  1421.           rtpPayloadType = frame.GetPayloadType();
  1422.           consecutiveMismatches = 0;
  1423.           PTRACE(1, "H323RTP\tResetting expected payload type to " << rtpPayloadType);
  1424.         }
  1425.         else {
  1426.           PTRACE(2, "H323RTP\tPayload type mismatch: expected "
  1427.                  << rtpPayloadType << ", got " << frame.GetPayloadType()
  1428.                  << ". Ignoring packet.");
  1429.         }
  1430.       }
  1431.  
  1432.       if (isCodecPacket && consecutiveMismatches == 0) {
  1433.         const BYTE * ptr = frame.GetPayloadPtr();
  1434.         while (ok && size > 0) {
  1435.           /* Now write data to the codec, it is expected that the Write()
  1436.              function will maintain the Real Time aspects of the system. That
  1437.              is for GSM codec, say with a single frame, this function will take
  1438.              20 milliseconds to complete. It is very important that this occurs
  1439.              for audio codecs or the jitter buffer will not operate correctly.
  1440.            */
  1441.           ok = codec->Write(ptr, paused ? 0 : size, frame, written);
  1442.           rtpTimestamp += codecFrameRate;
  1443.           size -= written;
  1444.           ptr += written;
  1445.         }
  1446.         PTRACE_IF(1, size < 0, "H323RTP\tPayload size too small, short " << -size << " bytes.");
  1447.       }
  1448.     }
  1449.  
  1450.     if (terminating)
  1451.       break;
  1452.  
  1453.     if (!ok) {
  1454.       connection.CloseLogicalChannelNumber(number);
  1455.       break;
  1456.     }
  1457.   }
  1458.  
  1459.   PTRACE(2, "H323RTP\tReceive " << mediaFormat << " thread ended");
  1460. }
  1461.  
  1462.  
  1463. void H323_RTPChannel::AddFilter(const PNotifier & filterFunction)
  1464. {
  1465.   filterMutex.Wait();
  1466.   filters.Append(new PNotifier(filterFunction));
  1467.   filterMutex.Signal();
  1468. }
  1469.  
  1470.  
  1471. void H323_RTPChannel::RemoveFilter(const PNotifier & filterFunction)
  1472. {
  1473.   filterMutex.Wait();
  1474.   PINDEX idx = filters.GetValuesIndex(filterFunction);
  1475.   if (idx != P_MAX_INDEX)
  1476.     filters.RemoveAt(idx);
  1477.   filterMutex.Signal();
  1478. }
  1479.  
  1480.  
  1481. PTimeInterval H323_RTPChannel::GetSilenceDuration() const
  1482. {
  1483.   if (silenceStartTick == 0)
  1484.     return silenceStartTick;
  1485.  
  1486.   return PTimer::Tick() - silenceStartTick;
  1487. }
  1488.  
  1489.  
  1490. /////////////////////////////////////////////////////////////////////////////
  1491.  
  1492. H323_ExternalRTPChannel::H323_ExternalRTPChannel(H323Connection & connection,
  1493.                                                  const H323Capability & capability,
  1494.                                                  Directions direction,
  1495.                                                  unsigned id)
  1496.   : H323_RealTimeChannel(connection, capability, direction)
  1497. {
  1498.   sessionID = id;
  1499.   isRunning = FALSE;
  1500. }
  1501.  
  1502.  
  1503. H323_ExternalRTPChannel::H323_ExternalRTPChannel(H323Connection & connection,
  1504.                                                  const H323Capability & capability,
  1505.                                                  Directions direction,
  1506.                                                  unsigned id,
  1507.                                                  const H323TransportAddress & data,
  1508.                                                  const H323TransportAddress & control)
  1509.   : H323_RealTimeChannel(connection, capability, direction),
  1510.     externalMediaAddress(data),
  1511.     externalMediaControlAddress(control)
  1512. {
  1513.   sessionID = id;
  1514.   isRunning = FALSE;
  1515. }
  1516.  
  1517.  
  1518. H323_ExternalRTPChannel::H323_ExternalRTPChannel(H323Connection & connection,
  1519.                                                  const H323Capability & capability,
  1520.                                                  Directions direction,
  1521.                                                  unsigned id,
  1522.                                                  const PIPSocket::Address & ip,
  1523.                                                  WORD dataPort)
  1524.   : H323_RealTimeChannel(connection, capability, direction),
  1525.     externalMediaAddress(ip, dataPort),
  1526.     externalMediaControlAddress(ip, (WORD)(dataPort+1))
  1527. {
  1528.   sessionID = id;
  1529.   isRunning = FALSE;
  1530. }
  1531.  
  1532.  
  1533. unsigned H323_ExternalRTPChannel::GetSessionID() const
  1534. {
  1535.   return sessionID;
  1536. }
  1537.  
  1538.  
  1539. BOOL H323_ExternalRTPChannel::Start()
  1540. {
  1541.   isRunning = TRUE;
  1542.   return Open();
  1543. }
  1544.  
  1545.  
  1546. BOOL H323_ExternalRTPChannel::IsRunning() const
  1547. {
  1548.   return opened && isRunning;
  1549. }
  1550.  
  1551.  
  1552. void H323_ExternalRTPChannel::Receive()
  1553. {
  1554.   // Do nothing
  1555. }
  1556.  
  1557.  
  1558. void H323_ExternalRTPChannel::Transmit()
  1559. {
  1560.   // Do nothing
  1561. }
  1562.  
  1563.  
  1564. BOOL H323_ExternalRTPChannel::OnSendingPDU(H245_H2250LogicalChannelParameters & param) const
  1565. {
  1566.   param.m_sessionID = sessionID;
  1567.  
  1568.   param.IncludeOptionalField(H245_H2250LogicalChannelParameters::e_mediaGuaranteedDelivery);
  1569.   param.m_mediaGuaranteedDelivery = FALSE;
  1570.  
  1571.   param.IncludeOptionalField(H245_H2250LogicalChannelParameters::e_silenceSuppression);
  1572.   param.m_silenceSuppression = FALSE;
  1573.  
  1574.   // unicast must have mediaControlChannel
  1575.   param.IncludeOptionalField(H245_H2250LogicalChannelParameters::e_mediaControlChannel);
  1576.   externalMediaControlAddress.SetPDU(param.m_mediaControlChannel);
  1577.  
  1578.   if (receiver) {
  1579.     // set mediaChannel
  1580.     param.IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaChannel);
  1581.     externalMediaAddress.SetPDU(param.m_mediaChannel);
  1582.   }
  1583.  
  1584.   return TRUE;
  1585. }
  1586.  
  1587.  
  1588. void H323_ExternalRTPChannel::OnSendOpenAck(H245_H2250LogicalChannelAckParameters & param) const
  1589. {
  1590.   // set mediaControlChannel
  1591.   param.IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaControlChannel);
  1592.   externalMediaControlAddress.SetPDU(param.m_mediaControlChannel);
  1593.  
  1594.   // set mediaChannel
  1595.   param.IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaChannel);
  1596.   externalMediaAddress.SetPDU(param.m_mediaChannel);
  1597. }
  1598.  
  1599.  
  1600. BOOL H323_ExternalRTPChannel::OnReceivedPDU(const H245_H2250LogicalChannelParameters & param,
  1601.                                           unsigned & errorCode)
  1602. {
  1603.   // Only support a single audio session
  1604.   if (param.m_sessionID != sessionID) {
  1605.     PTRACE(1, "LogChan\tOpen for invalid session: " << param.m_sessionID);
  1606.     errorCode = H245_OpenLogicalChannelReject_cause::e_invalidSessionID;
  1607.     return FALSE;
  1608.   }
  1609.  
  1610.   if (!param.HasOptionalField(H245_H2250LogicalChannelParameters::e_mediaControlChannel)) {
  1611.     PTRACE(1, "LogChan\tNo mediaControlChannel specified");
  1612.     errorCode = H245_OpenLogicalChannelReject_cause::e_unspecified;
  1613.     return FALSE;
  1614.   }
  1615.  
  1616.   remoteMediaControlAddress = param.m_mediaControlChannel;
  1617.   if (remoteMediaControlAddress.IsEmpty())
  1618.     return FALSE;
  1619.  
  1620.   if (param.HasOptionalField(H245_H2250LogicalChannelParameters::e_mediaChannel)) {
  1621.     remoteMediaAddress = param.m_mediaChannel;
  1622.     if (remoteMediaAddress.IsEmpty())
  1623.       return FALSE;
  1624.   }
  1625.  
  1626.   return TRUE;
  1627. }
  1628.  
  1629.  
  1630. BOOL H323_ExternalRTPChannel::OnReceivedAckPDU(const H245_H2250LogicalChannelAckParameters & param)
  1631. {
  1632.   if (!param.HasOptionalField(H245_H2250LogicalChannelAckParameters::e_sessionID)) {
  1633.     PTRACE(1, "LogChan\tNo session specified");
  1634.     return FALSE;
  1635.   }
  1636.  
  1637.   if (param.m_sessionID != sessionID) {
  1638.     PTRACE(1, "LogChan\tAck for invalid session: " << param.m_sessionID);
  1639.   }
  1640.  
  1641.   if (!param.HasOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaControlChannel)) {
  1642.     PTRACE(1, "LogChan\tNo mediaControlChannel specified");
  1643.     return FALSE;
  1644.   }
  1645.  
  1646.   remoteMediaControlAddress = param.m_mediaControlChannel;
  1647.   if (remoteMediaControlAddress.IsEmpty())
  1648.     return FALSE;
  1649.  
  1650.   if (!param.HasOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaChannel)) {
  1651.     PTRACE(1, "LogChan\tNo mediaChannel specified");
  1652.     return FALSE;
  1653.   }
  1654.  
  1655.   remoteMediaAddress = param.m_mediaChannel;
  1656.   if (remoteMediaAddress.IsEmpty())
  1657.     return FALSE;
  1658.  
  1659.   return TRUE;
  1660. }
  1661.  
  1662.  
  1663. void H323_ExternalRTPChannel::SetExternalAddress(const H323TransportAddress & data,
  1664.                                                  const H323TransportAddress & control)
  1665. {
  1666.   externalMediaAddress = data;
  1667.   externalMediaControlAddress = control;
  1668.  
  1669.   if (data.IsEmpty() || control.IsEmpty()) {
  1670.     PIPSocket::Address ip;
  1671.     WORD port;
  1672.     if (data.GetIpAndPort(ip, port))
  1673.       externalMediaControlAddress = H323TransportAddress(ip, (WORD)(port+1));
  1674.     else if (control.GetIpAndPort(ip, port))
  1675.       externalMediaAddress = H323TransportAddress(ip, (WORD)(port-1));
  1676.   }
  1677. }
  1678.  
  1679.  
  1680. BOOL H323_ExternalRTPChannel::GetRemoteAddress(PIPSocket::Address & ip,
  1681.                                                WORD & dataPort) const
  1682. {
  1683.   if (!remoteMediaControlAddress) {
  1684.     if (remoteMediaControlAddress.GetIpAndPort(ip, dataPort)) {
  1685.       dataPort--;
  1686.       return TRUE;
  1687.     }
  1688.   }
  1689.  
  1690.   if (!remoteMediaAddress)
  1691.     return remoteMediaAddress.GetIpAndPort(ip, dataPort);
  1692.  
  1693.   return FALSE;
  1694. }
  1695.  
  1696.  
  1697. /////////////////////////////////////////////////////////////////////////////
  1698.  
  1699. H323DataChannel::H323DataChannel(H323Connection & conn,
  1700.                                  const H323Capability & cap,
  1701.                                  Directions dir,
  1702.                                  unsigned id)
  1703.   : H323UnidirectionalChannel(conn, cap, dir)
  1704. {
  1705.   sessionID = id;
  1706.   listener = NULL;
  1707.   autoDeleteListener = TRUE;
  1708.   transport = NULL;
  1709.   autoDeleteTransport = TRUE;
  1710.   separateReverseChannel = FALSE;
  1711. }
  1712.  
  1713.  
  1714. H323DataChannel::~H323DataChannel()
  1715. {
  1716.   if (autoDeleteListener)
  1717.     delete listener;
  1718.   if (autoDeleteTransport)
  1719.     delete transport;
  1720. }
  1721.  
  1722.  
  1723. void H323DataChannel::CleanUpOnTermination()
  1724. {
  1725.   if (terminating)
  1726.     return;
  1727.  
  1728.   PTRACE(3, "LogChan\tCleaning up data channel " << number);
  1729.  
  1730.   // Break any I/O blocks and wait for the thread that uses this object to
  1731.   // terminate before we allow it to be deleted.
  1732.   if (listener != NULL)
  1733.     listener->Close();
  1734.   if (transport != NULL)
  1735.     transport->Close();
  1736.  
  1737.   H323UnidirectionalChannel::CleanUpOnTermination();
  1738. }
  1739.  
  1740.  
  1741. unsigned H323DataChannel::GetSessionID() const
  1742. {
  1743.   return sessionID;
  1744. }
  1745.  
  1746.  
  1747. BOOL H323DataChannel::OnSendingPDU(H245_OpenLogicalChannel & open) const
  1748. {
  1749.   PTRACE(3, "LogChan\tOnSendingPDU for channel: " << number);
  1750.  
  1751.   open.m_forwardLogicalChannelNumber = (unsigned)number;
  1752.  
  1753.   open.m_forwardLogicalChannelParameters.m_multiplexParameters.SetTag(
  1754.               H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters
  1755.                   ::e_h2250LogicalChannelParameters);
  1756.   H245_H2250LogicalChannelParameters & fparam = open.m_forwardLogicalChannelParameters.m_multiplexParameters;
  1757.   fparam.m_sessionID = GetSessionID();
  1758.  
  1759.   if (separateReverseChannel)
  1760.     return TRUE;
  1761.  
  1762.   open.IncludeOptionalField(H245_OpenLogicalChannel::e_reverseLogicalChannelParameters);
  1763.   open.m_reverseLogicalChannelParameters.IncludeOptionalField(
  1764.               H245_OpenLogicalChannel_reverseLogicalChannelParameters::e_multiplexParameters);
  1765.   open.m_reverseLogicalChannelParameters.m_multiplexParameters.SetTag(
  1766.               H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters
  1767.                   ::e_h2250LogicalChannelParameters);
  1768.   H245_H2250LogicalChannelParameters & rparam = open.m_reverseLogicalChannelParameters.m_multiplexParameters;
  1769.   rparam.m_sessionID = GetSessionID();
  1770.  
  1771.   return capability->OnSendingPDU(open.m_reverseLogicalChannelParameters.m_dataType);
  1772. }
  1773.  
  1774.  
  1775. void H323DataChannel::OnSendOpenAck(const H245_OpenLogicalChannel & /*open*/,
  1776.                                     H245_OpenLogicalChannelAck & ack) const
  1777. {
  1778.   if (listener == NULL && transport == NULL) {
  1779.     PTRACE(2, "LogChan\tOnSendOpenAck without a listener or transport");
  1780.     return;
  1781.   }
  1782.  
  1783.   PTRACE(3, "LogChan\tOnSendOpenAck for channel: " << number);
  1784.  
  1785.   H245_H2250LogicalChannelAckParameters * param;
  1786.  
  1787.   if (separateReverseChannel) {
  1788.     ack.IncludeOptionalField(H245_OpenLogicalChannelAck::e_forwardMultiplexAckParameters);
  1789.     ack.m_forwardMultiplexAckParameters.SetTag(
  1790.               H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::e_h2250LogicalChannelAckParameters);
  1791.     param = (H245_H2250LogicalChannelAckParameters*)&ack.m_forwardMultiplexAckParameters.GetObject();
  1792.   }
  1793.   else {
  1794.     ack.IncludeOptionalField(H245_OpenLogicalChannelAck::e_reverseLogicalChannelParameters);
  1795.     ack.m_reverseLogicalChannelParameters.m_multiplexParameters.SetTag(
  1796.               H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
  1797.                   ::e_h2250LogicalChannelParameters);
  1798.     param = (H245_H2250LogicalChannelAckParameters*)
  1799.                 &ack.m_reverseLogicalChannelParameters.m_multiplexParameters.GetObject();
  1800.   }
  1801.  
  1802.   unsigned session = GetSessionID();
  1803.   if (session != 0) {
  1804.     param->IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_sessionID);
  1805.     param->m_sessionID = GetSessionID();
  1806.   }
  1807.  
  1808.   param->IncludeOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaChannel);
  1809.   if (listener != NULL)
  1810.     listener->SetUpTransportPDU(param->m_mediaChannel, connection.GetControlChannel());
  1811.   else
  1812.     transport->SetUpTransportPDU(param->m_mediaChannel, H323Transport::UseLocalTSAP);
  1813. }
  1814.  
  1815.  
  1816. BOOL H323DataChannel::OnReceivedPDU(const H245_OpenLogicalChannel & open,
  1817.                                     unsigned & errorCode)
  1818. {
  1819.   number = H323ChannelNumber(open.m_forwardLogicalChannelNumber, TRUE);
  1820.  
  1821.   PTRACE(3, "LogChan\tOnReceivedPDU for data channel: " << number);
  1822.  
  1823.   if (!CreateListener()) {
  1824.     PTRACE(1, "LogChan\tCould not create listener");
  1825.     errorCode = H245_OpenLogicalChannelReject_cause::e_unspecified;
  1826.     return FALSE;
  1827.   }
  1828.  
  1829.   if (separateReverseChannel &&
  1830.       open.HasOptionalField(H245_OpenLogicalChannel::e_reverseLogicalChannelParameters)) {
  1831.     errorCode = H245_OpenLogicalChannelReject_cause::e_unsuitableReverseParameters;
  1832.     PTRACE(2, "LogChan\tOnReceivedPDU has unexpected reverse parameters");
  1833.     return FALSE;
  1834.   }
  1835.  
  1836.   if (!capability->OnReceivedPDU(open.m_forwardLogicalChannelParameters.m_dataType, receiver)) {
  1837.     PTRACE(1, "H323RTP\tData type not supported");
  1838.     errorCode = H245_OpenLogicalChannelReject_cause::e_dataTypeNotSupported;
  1839.     return FALSE;
  1840.   }
  1841.  
  1842.   return TRUE;
  1843. }
  1844.  
  1845.  
  1846. BOOL H323DataChannel::OnReceivedAckPDU(const H245_OpenLogicalChannelAck & ack)
  1847. {
  1848.   PTRACE(3, "LogChan\tOnReceivedAckPDU");
  1849.  
  1850.   const H245_TransportAddress * address;
  1851.  
  1852.   if (separateReverseChannel) {
  1853.       PTRACE(3, "LogChan\tseparateReverseChannels");
  1854.     if (!ack.HasOptionalField(H245_OpenLogicalChannelAck::e_forwardMultiplexAckParameters)) {
  1855.       PTRACE(1, "LogChan\tNo forwardMultiplexAckParameters");
  1856.       return FALSE;
  1857.     }
  1858.  
  1859.     if (ack.m_forwardMultiplexAckParameters.GetTag() !=
  1860.               H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::e_h2250LogicalChannelAckParameters) {
  1861.       PTRACE(1, "LogChan\tOnly H.225.0 multiplex supported");
  1862.       return FALSE;
  1863.     }
  1864.  
  1865.     const H245_H2250LogicalChannelAckParameters & param = ack.m_forwardMultiplexAckParameters;
  1866.  
  1867.     if (!param.HasOptionalField(H245_H2250LogicalChannelAckParameters::e_mediaChannel)) {
  1868.       PTRACE(1, "LogChan\tNo media channel address provided");
  1869.       return FALSE;
  1870.     }
  1871.  
  1872.     address = ¶m.m_mediaChannel;
  1873.  
  1874.     if (ack.HasOptionalField(H245_OpenLogicalChannelAck::e_reverseLogicalChannelParameters)) {
  1875.       PTRACE(3, "LogChan\treverseLogicalChannelParameters set");
  1876.       reverseChannel = H323ChannelNumber(ack.m_reverseLogicalChannelParameters.m_reverseLogicalChannelNumber, TRUE);
  1877.     }
  1878.   }
  1879.   else {
  1880.     if (!ack.HasOptionalField(H245_OpenLogicalChannelAck::e_reverseLogicalChannelParameters)) {
  1881.       PTRACE(1, "LogChan\tNo reverseLogicalChannelParameters");
  1882.       return FALSE;
  1883.     }
  1884.  
  1885.     if (ack.m_reverseLogicalChannelParameters.m_multiplexParameters.GetTag() !=
  1886.               H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
  1887.                               ::e_h2250LogicalChannelParameters) {
  1888.       PTRACE(1, "LogChan\tOnly H.225.0 multiplex supported");
  1889.       return FALSE;
  1890.     }
  1891.  
  1892.     const H245_H2250LogicalChannelParameters & param = ack.m_reverseLogicalChannelParameters.m_multiplexParameters;
  1893.  
  1894.     if (!param.HasOptionalField(H245_H2250LogicalChannelParameters::e_mediaChannel)) {
  1895.       PTRACE(1, "LogChan\tNo media channel address provided");
  1896.       return FALSE;
  1897.     }
  1898.  
  1899.     address = ¶m.m_mediaChannel;
  1900.   }
  1901.  
  1902.   if (!CreateTransport()) {
  1903.     PTRACE(1, "LogChan\tCould not create transport");
  1904.     return FALSE;
  1905.   }
  1906.  
  1907.   if (!transport->ConnectTo(*address)) {
  1908.     PTRACE(1, "LogChan\tCould not connect to remote transport address: " << *address);
  1909.     return FALSE;
  1910.   }
  1911.  
  1912.   return TRUE;
  1913. }
  1914.  
  1915.  
  1916. BOOL H323DataChannel::CreateListener()
  1917. {
  1918.   if (listener == NULL) {
  1919.     listener = connection.GetControlChannel().GetLocalAddress().CreateCompatibleListener(connection.GetEndPoint());
  1920.     if (listener == NULL)
  1921.       return FALSE;
  1922.  
  1923.     PTRACE(3, "LogChan\tCreated listener for data channel: " << *listener);
  1924.   }
  1925.  
  1926.   return listener->Open();
  1927. }
  1928.  
  1929.  
  1930. BOOL H323DataChannel::CreateTransport()
  1931. {
  1932.   if (transport == NULL) {
  1933.     transport = connection.GetControlChannel().GetLocalAddress().CreateTransport(connection.GetEndPoint());
  1934.     if (transport == NULL)
  1935.       return FALSE;
  1936.  
  1937.     PTRACE(3, "LogChan\tCreated transport for data channel: " << *transport);
  1938.   }
  1939.  
  1940.   return transport != NULL;
  1941. }
  1942.  
  1943.  
  1944. /////////////////////////////////////////////////////////////////////////////
  1945.