LCOV - code coverage report
Current view: top level - libavformat - rtp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 16 48 33.3 %
Date: 2017-12-15 02:19:58 Functions: 1 4 25.0 %

          Line data    Source code
       1             : /*
       2             :  * RTP input/output format
       3             :  * Copyright (c) 2002 Fabrice Bellard
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include "libavutil/avstring.h"
      23             : #include "libavutil/opt.h"
      24             : #include "avformat.h"
      25             : 
      26             : #include "rtp.h"
      27             : 
      28             : /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
      29             : /* payload types >= 96 are dynamic;
      30             :  * payload types between 72 and 76 are reserved for RTCP conflict avoidance;
      31             :  * all the other payload types not present in the table are unassigned or
      32             :  * reserved
      33             :  */
      34             : static const struct {
      35             :     int pt;
      36             :     const char enc_name[6];
      37             :     enum AVMediaType codec_type;
      38             :     enum AVCodecID codec_id;
      39             :     int clock_rate;
      40             :     int audio_channels;
      41             : } rtp_payload_types[] = {
      42             :   {0, "PCMU",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_PCM_MULAW, 8000, 1},
      43             :   {3, "GSM",         AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      44             :   {4, "G723",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_G723_1, 8000, 1},
      45             :   {5, "DVI4",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      46             :   {6, "DVI4",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 16000, 1},
      47             :   {7, "LPC",         AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      48             :   {8, "PCMA",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_PCM_ALAW, 8000, 1},
      49             :   {9, "G722",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_ADPCM_G722, 8000, 1},
      50             :   {10, "L16",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_PCM_S16BE, 44100, 2},
      51             :   {11, "L16",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_PCM_S16BE, 44100, 1},
      52             :   {12, "QCELP",      AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_QCELP, 8000, 1},
      53             :   {13, "CN",         AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      54             :   {14, "MPA",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_MP2, -1, -1},
      55             :   {14, "MPA",        AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_MP3, -1, -1},
      56             :   {15, "G728",       AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      57             :   {16, "DVI4",       AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 11025, 1},
      58             :   {17, "DVI4",       AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 22050, 1},
      59             :   {18, "G729",       AVMEDIA_TYPE_AUDIO,   AV_CODEC_ID_NONE, 8000, 1},
      60             :   {25, "CelB",       AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_NONE, 90000, -1},
      61             :   {26, "JPEG",       AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_MJPEG, 90000, -1},
      62             :   {28, "nv",         AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_NONE, 90000, -1},
      63             :   {31, "H261",       AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_H261, 90000, -1},
      64             :   {32, "MPV",        AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_MPEG1VIDEO, 90000, -1},
      65             :   {32, "MPV",        AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_MPEG2VIDEO, 90000, -1},
      66             :   {33, "MP2T",       AVMEDIA_TYPE_DATA,    AV_CODEC_ID_MPEG2TS, 90000, -1},
      67             :   {34, "H263",       AVMEDIA_TYPE_VIDEO,   AV_CODEC_ID_H263, 90000, -1},
      68             :   {-1, "",           AVMEDIA_TYPE_UNKNOWN, AV_CODEC_ID_NONE, -1, -1}
      69             : };
      70             : 
      71           0 : int ff_rtp_get_codec_info(AVCodecParameters *par, int payload_type)
      72             : {
      73           0 :     int i = 0;
      74             : 
      75           0 :     for (i = 0; rtp_payload_types[i].pt >= 0; i++)
      76           0 :         if (rtp_payload_types[i].pt == payload_type) {
      77           0 :             if (rtp_payload_types[i].codec_id != AV_CODEC_ID_NONE) {
      78           0 :                 par->codec_type = rtp_payload_types[i].codec_type;
      79           0 :                 par->codec_id = rtp_payload_types[i].codec_id;
      80           0 :                 if (rtp_payload_types[i].audio_channels > 0)
      81           0 :                     par->channels = rtp_payload_types[i].audio_channels;
      82           0 :                 if (rtp_payload_types[i].clock_rate > 0)
      83           0 :                     par->sample_rate = rtp_payload_types[i].clock_rate;
      84           0 :                 return 0;
      85             :             }
      86             :         }
      87           0 :     return -1;
      88             : }
      89             : 
      90           4 : int ff_rtp_get_payload_type(AVFormatContext *fmt,
      91             :                             AVCodecParameters *par, int idx)
      92             : {
      93             :     int i;
      94           4 :     AVOutputFormat *ofmt = fmt ? fmt->oformat : NULL;
      95             : 
      96             :     /* Was the payload type already specified for the RTP muxer? */
      97           4 :     if (ofmt && ofmt->priv_class && fmt->priv_data) {
      98             :         int64_t payload_type;
      99           6 :         if (av_opt_get_int(fmt->priv_data, "payload_type", 0, &payload_type) >= 0 &&
     100           2 :             payload_type >= 0)
     101           2 :             return (int)payload_type;
     102             :     }
     103             : 
     104             :     /* static payload type */
     105          54 :     for (i = 0; rtp_payload_types[i].pt >= 0; ++i)
     106          52 :         if (rtp_payload_types[i].codec_id == par->codec_id) {
     107           1 :             if (par->codec_id == AV_CODEC_ID_H263 && (!fmt || !fmt->oformat ||
     108           0 :                 !fmt->oformat->priv_class || !fmt->priv_data ||
     109           0 :                 !av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190")))
     110           0 :                 continue;
     111             :             /* G722 has 8000 as nominal rate even if the sample rate is 16000,
     112             :              * see section 4.5.2 in RFC 3551. */
     113           1 :             if (par->codec_id == AV_CODEC_ID_ADPCM_G722 &&
     114           0 :                 par->sample_rate == 16000 && par->channels == 1)
     115           0 :                 return rtp_payload_types[i].pt;
     116           2 :             if (par->codec_type == AVMEDIA_TYPE_AUDIO &&
     117           2 :                 ((rtp_payload_types[i].clock_rate > 0 &&
     118           1 :                   par->sample_rate != rtp_payload_types[i].clock_rate) ||
     119           0 :                  (rtp_payload_types[i].audio_channels > 0 &&
     120           0 :                   par->channels != rtp_payload_types[i].audio_channels)))
     121           1 :                 continue;
     122           0 :             return rtp_payload_types[i].pt;
     123             :         }
     124             : 
     125           2 :     if (idx < 0)
     126           0 :         idx = par->codec_type == AVMEDIA_TYPE_AUDIO;
     127             : 
     128             :     /* dynamic payload type */
     129           2 :     return RTP_PT_PRIVATE + idx;
     130             : }
     131             : 
     132           0 : const char *ff_rtp_enc_name(int payload_type)
     133             : {
     134             :     int i;
     135             : 
     136           0 :     for (i = 0; rtp_payload_types[i].pt >= 0; i++)
     137           0 :         if (rtp_payload_types[i].pt == payload_type)
     138           0 :             return rtp_payload_types[i].enc_name;
     139             : 
     140           0 :     return "";
     141             : }
     142             : 
     143           0 : enum AVCodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
     144             : {
     145             :     int i;
     146             : 
     147           0 :     for (i = 0; rtp_payload_types[i].pt >= 0; i++)
     148           0 :         if (!av_strcasecmp(buf, rtp_payload_types[i].enc_name) && (codec_type == rtp_payload_types[i].codec_type))
     149           0 :             return rtp_payload_types[i].codec_id;
     150             : 
     151           0 :     return AV_CODEC_ID_NONE;
     152             : }

Generated by: LCOV version 1.13