2007-07-26 22:34:26 +00:00
|
|
|
/*
|
|
|
|
* copyright (c) 2007 Luca Abeni
|
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* FFmpeg 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 for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
2010-01-07 08:11:56 +00:00
|
|
|
#include <string.h>
|
2008-05-09 11:56:36 +00:00
|
|
|
#include "libavutil/avstring.h"
|
|
|
|
#include "libavutil/base64.h"
|
2011-05-22 10:46:29 +00:00
|
|
|
#include "libavutil/dict.h"
|
2011-02-16 08:52:38 +00:00
|
|
|
#include "libavutil/parseutils.h"
|
2011-05-18 12:00:03 +00:00
|
|
|
#include "libavutil/opt.h"
|
2010-08-07 11:16:07 +00:00
|
|
|
#include "libavcodec/xiph.h"
|
2011-05-18 13:21:48 +00:00
|
|
|
#include "libavcodec/mpeg4audio.h"
|
2007-07-26 22:34:26 +00:00
|
|
|
#include "avformat.h"
|
2008-08-27 23:43:28 +00:00
|
|
|
#include "internal.h"
|
2008-01-21 14:28:58 +00:00
|
|
|
#include "avc.h"
|
2014-10-03 20:25:37 +00:00
|
|
|
#include "hevc.h"
|
2007-10-26 15:12:55 +00:00
|
|
|
#include "rtp.h"
|
2010-01-12 10:56:43 +00:00
|
|
|
#if CONFIG_NETWORK
|
|
|
|
#include "network.h"
|
|
|
|
#endif
|
2007-07-26 22:34:26 +00:00
|
|
|
|
2009-01-13 23:44:16 +00:00
|
|
|
#if CONFIG_RTP_MUXER
|
2007-07-26 22:34:26 +00:00
|
|
|
#define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
|
|
|
|
|
|
|
|
struct sdp_session_level {
|
|
|
|
int sdp_version; /**< protocol version (currently 0) */
|
2009-02-08 22:06:55 +00:00
|
|
|
int id; /**< session ID */
|
2007-07-26 22:34:26 +00:00
|
|
|
int version; /**< session version */
|
|
|
|
int start_time; /**< session start time (NTP time, in seconds),
|
2009-02-08 22:06:55 +00:00
|
|
|
or 0 in case of permanent session */
|
2007-07-26 22:34:26 +00:00
|
|
|
int end_time; /**< session end time (NTP time, in seconds),
|
|
|
|
or 0 if the session is not bounded */
|
|
|
|
int ttl; /**< TTL, in case of multicast stream */
|
|
|
|
const char *user; /**< username of the session's creator */
|
|
|
|
const char *src_addr; /**< IP address of the machine from which the session was created */
|
2010-08-25 12:29:32 +00:00
|
|
|
const char *src_type; /**< address type of src_addr */
|
2007-07-26 22:34:26 +00:00
|
|
|
const char *dst_addr; /**< destination IP address (can be multicast) */
|
2010-08-25 12:29:32 +00:00
|
|
|
const char *dst_type; /**< destination IP address type */
|
2007-07-26 22:34:26 +00:00
|
|
|
const char *name; /**< session name (can be an empty string) */
|
|
|
|
};
|
|
|
|
|
2010-08-25 12:29:32 +00:00
|
|
|
static void sdp_write_address(char *buff, int size, const char *dest_addr,
|
|
|
|
const char *dest_type, int ttl)
|
2007-07-26 22:34:26 +00:00
|
|
|
{
|
|
|
|
if (dest_addr) {
|
2010-08-25 12:29:32 +00:00
|
|
|
if (!dest_type)
|
|
|
|
dest_type = "IP4";
|
2010-10-08 11:58:47 +00:00
|
|
|
if (ttl > 0 && !strcmp(dest_type, "IP4")) {
|
|
|
|
/* The TTL should only be specified for IPv4 multicast addresses,
|
|
|
|
* not for IPv6. */
|
2010-08-25 12:29:32 +00:00
|
|
|
av_strlcatf(buff, size, "c=IN %s %s/%d\r\n", dest_type, dest_addr, ttl);
|
2007-07-26 22:34:26 +00:00
|
|
|
} else {
|
2010-08-25 12:29:32 +00:00
|
|
|
av_strlcatf(buff, size, "c=IN %s %s\r\n", dest_type, dest_addr);
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
|
|
|
|
{
|
|
|
|
av_strlcatf(buff, size, "v=%d\r\n"
|
2010-08-25 12:29:32 +00:00
|
|
|
"o=- %d %d IN %s %s\r\n"
|
2009-10-17 11:15:45 +00:00
|
|
|
"s=%s\r\n",
|
2007-07-26 22:34:26 +00:00
|
|
|
s->sdp_version,
|
2010-08-25 12:29:32 +00:00
|
|
|
s->id, s->version, s->src_type, s->src_addr,
|
2009-02-02 23:08:25 +00:00
|
|
|
s->name);
|
2010-08-25 12:29:32 +00:00
|
|
|
sdp_write_address(buff, size, s->dst_addr, s->dst_type, s->ttl);
|
2009-10-17 11:15:45 +00:00
|
|
|
av_strlcatf(buff, size, "t=%d %d\r\n"
|
|
|
|
"a=tool:libavformat " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\r\n",
|
|
|
|
s->start_time, s->end_time);
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
|
2010-01-12 10:56:43 +00:00
|
|
|
#if CONFIG_NETWORK
|
2010-10-07 07:59:35 +00:00
|
|
|
static int resolve_destination(char *dest_addr, int size, char *type,
|
2010-10-07 08:00:03 +00:00
|
|
|
int type_size)
|
2010-01-12 10:56:43 +00:00
|
|
|
{
|
2011-06-06 12:13:02 +00:00
|
|
|
struct addrinfo hints = { 0 }, *ai;
|
2010-10-07 07:59:35 +00:00
|
|
|
int is_multicast;
|
2010-01-12 10:56:43 +00:00
|
|
|
|
2010-08-25 12:29:32 +00:00
|
|
|
av_strlcpy(type, "IP4", type_size);
|
2010-01-12 10:56:43 +00:00
|
|
|
if (!dest_addr[0])
|
2010-10-07 07:59:35 +00:00
|
|
|
return 0;
|
2010-01-12 10:56:43 +00:00
|
|
|
|
|
|
|
/* Resolve the destination, since it must be written
|
|
|
|
* as a numeric IP address in the SDP. */
|
|
|
|
|
|
|
|
if (getaddrinfo(dest_addr, NULL, &hints, &ai))
|
2010-10-07 07:59:35 +00:00
|
|
|
return 0;
|
2010-08-25 13:31:33 +00:00
|
|
|
getnameinfo(ai->ai_addr, ai->ai_addrlen, dest_addr, size,
|
|
|
|
NULL, 0, NI_NUMERICHOST);
|
2010-10-19 07:50:40 +00:00
|
|
|
#ifdef AF_INET6
|
2010-08-25 13:31:33 +00:00
|
|
|
if (ai->ai_family == AF_INET6)
|
|
|
|
av_strlcpy(type, "IP6", type_size);
|
2010-10-19 07:50:40 +00:00
|
|
|
#endif
|
2010-10-07 07:59:35 +00:00
|
|
|
is_multicast = ff_is_multicast_address(ai->ai_addr);
|
2010-01-12 10:56:43 +00:00
|
|
|
freeaddrinfo(ai);
|
2010-10-07 07:59:35 +00:00
|
|
|
return is_multicast;
|
2010-01-12 10:56:43 +00:00
|
|
|
}
|
|
|
|
#else
|
2010-10-07 07:59:35 +00:00
|
|
|
static int resolve_destination(char *dest_addr, int size, char *type,
|
2010-10-07 08:00:03 +00:00
|
|
|
int type_size)
|
2010-01-12 10:56:43 +00:00
|
|
|
{
|
2010-10-07 07:59:35 +00:00
|
|
|
return 0;
|
2010-01-12 10:56:43 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-11-29 13:55:03 +00:00
|
|
|
static int sdp_get_address(char *dest_addr, int size, int *ttl, const char *url)
|
2007-07-26 22:34:26 +00:00
|
|
|
{
|
|
|
|
int port;
|
|
|
|
const char *p;
|
2010-01-07 08:11:56 +00:00
|
|
|
char proto[32];
|
2007-07-26 22:34:26 +00:00
|
|
|
|
2010-06-27 14:16:46 +00:00
|
|
|
av_url_split(proto, sizeof(proto), NULL, 0, dest_addr, size, &port, NULL, 0, url);
|
2007-07-26 22:34:26 +00:00
|
|
|
|
|
|
|
*ttl = 0;
|
2010-01-07 08:11:56 +00:00
|
|
|
|
2012-12-12 10:59:41 +00:00
|
|
|
if (strcmp(proto, "rtp") && strcmp(proto, "srtp")) {
|
2010-01-07 08:11:56 +00:00
|
|
|
/* The url isn't for the actual rtp sessions,
|
|
|
|
* don't parse out anything else than the destination.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-26 22:34:26 +00:00
|
|
|
p = strchr(url, '?');
|
|
|
|
if (p) {
|
|
|
|
char buff[64];
|
|
|
|
|
2011-02-16 08:52:38 +00:00
|
|
|
if (av_find_info_tag(buff, sizeof(buff), "ttl", p)) {
|
2010-10-07 08:00:03 +00:00
|
|
|
*ttl = strtol(buff, NULL, 10);
|
|
|
|
} else {
|
|
|
|
*ttl = 5;
|
|
|
|
}
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
2008-01-21 14:28:58 +00:00
|
|
|
#define MAX_PSET_SIZE 1024
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static char *extradata2psets(AVFormatContext *s, AVCodecParameters *par)
|
2008-01-21 14:28:58 +00:00
|
|
|
{
|
|
|
|
char *psets, *p;
|
2008-02-19 21:58:54 +00:00
|
|
|
const uint8_t *r;
|
2012-08-28 16:24:14 +00:00
|
|
|
static const char pset_string[] = "; sprop-parameter-sets=";
|
|
|
|
static const char profile_string[] = "; profile-level-id=";
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
uint8_t *extradata = par->extradata;
|
|
|
|
int extradata_size = par->extradata_size;
|
2014-10-03 17:49:01 +00:00
|
|
|
uint8_t *tmpbuf = NULL;
|
2012-08-28 11:57:26 +00:00
|
|
|
const uint8_t *sps = NULL, *sps_end;
|
2008-01-21 14:28:58 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->extradata_size > MAX_EXTRADATA_SIZE) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
|
2008-01-21 14:28:58 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->extradata[0] == 1) {
|
|
|
|
if (ff_avc_write_annexb_extradata(par->extradata, &extradata,
|
2014-10-03 17:49:01 +00:00
|
|
|
&extradata_size))
|
2010-06-11 08:01:45 +00:00
|
|
|
return NULL;
|
2014-10-03 17:49:01 +00:00
|
|
|
tmpbuf = extradata;
|
2010-06-11 08:01:45 +00:00
|
|
|
}
|
2008-01-21 14:28:58 +00:00
|
|
|
|
|
|
|
psets = av_mallocz(MAX_PSET_SIZE);
|
2014-08-14 20:31:24 +00:00
|
|
|
if (!psets) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
|
2014-10-03 17:49:01 +00:00
|
|
|
av_free(tmpbuf);
|
2008-01-21 14:28:58 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
memcpy(psets, pset_string, strlen(pset_string));
|
|
|
|
p = psets + strlen(pset_string);
|
2014-10-03 17:49:01 +00:00
|
|
|
r = ff_avc_find_startcode(extradata, extradata + extradata_size);
|
|
|
|
while (r < extradata + extradata_size) {
|
2008-02-19 21:58:54 +00:00
|
|
|
const uint8_t *r1;
|
2009-04-06 21:04:26 +00:00
|
|
|
uint8_t nal_type;
|
2008-01-21 14:28:58 +00:00
|
|
|
|
|
|
|
while (!*(r++));
|
2009-04-06 21:04:26 +00:00
|
|
|
nal_type = *r & 0x1f;
|
2014-10-03 17:49:01 +00:00
|
|
|
r1 = ff_avc_find_startcode(r, extradata + extradata_size);
|
2009-04-06 21:04:26 +00:00
|
|
|
if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
|
|
|
|
r = r1;
|
|
|
|
continue;
|
|
|
|
}
|
2008-01-21 14:28:58 +00:00
|
|
|
if (p != (psets + strlen(pset_string))) {
|
|
|
|
*p = ',';
|
|
|
|
p++;
|
|
|
|
}
|
2012-08-28 11:57:26 +00:00
|
|
|
if (!sps) {
|
|
|
|
sps = r;
|
|
|
|
sps_end = r1;
|
|
|
|
}
|
2014-08-14 20:31:24 +00:00
|
|
|
if (!av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r)) {
|
2016-04-10 19:58:15 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot Base64-encode %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
|
2008-01-21 14:28:58 +00:00
|
|
|
av_free(psets);
|
2014-10-03 17:49:01 +00:00
|
|
|
av_free(tmpbuf);
|
2008-01-21 14:28:58 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
p += strlen(p);
|
|
|
|
r = r1;
|
|
|
|
}
|
2012-08-28 11:57:26 +00:00
|
|
|
if (sps && sps_end - sps >= 4) {
|
|
|
|
memcpy(p, profile_string, strlen(profile_string));
|
|
|
|
p += strlen(p);
|
|
|
|
ff_data_to_hex(p, sps + 1, 3, 0);
|
|
|
|
p[6] = '\0';
|
|
|
|
}
|
2014-10-03 17:49:01 +00:00
|
|
|
av_free(tmpbuf);
|
2008-01-21 14:28:58 +00:00
|
|
|
|
|
|
|
return psets;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static char *extradata2psets_hevc(AVCodecParameters *par)
|
2014-10-03 20:25:37 +00:00
|
|
|
{
|
|
|
|
char *psets;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
uint8_t *extradata = par->extradata;
|
|
|
|
int extradata_size = par->extradata_size;
|
2014-10-03 20:25:37 +00:00
|
|
|
uint8_t *tmpbuf = NULL;
|
|
|
|
int ps_pos[3] = { 0 };
|
|
|
|
static const char * const ps_names[3] = { "vps", "sps", "pps" };
|
|
|
|
int num_arrays, num_nalus;
|
|
|
|
int pos, i, j;
|
|
|
|
|
|
|
|
// Convert to hvcc format. Since we need to group multiple NALUs of
|
|
|
|
// the same type, and we might need to convert from one format to the
|
|
|
|
// other anyway, we get away with a little less work by using the hvcc
|
|
|
|
// format.
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->extradata[0] != 1) {
|
2014-10-03 20:25:37 +00:00
|
|
|
AVIOContext *pb;
|
|
|
|
if (avio_open_dyn_buf(&pb) < 0)
|
|
|
|
return NULL;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0) < 0) {
|
2014-10-03 20:25:37 +00:00
|
|
|
avio_close_dyn_buf(pb, &tmpbuf);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
extradata_size = avio_close_dyn_buf(pb, &extradata);
|
|
|
|
tmpbuf = extradata;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (extradata_size < 23)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
num_arrays = extradata[22];
|
|
|
|
pos = 23;
|
|
|
|
for (i = 0; i < num_arrays; i++) {
|
|
|
|
int num_nalus, nalu_type;
|
|
|
|
if (pos + 3 > extradata_size)
|
|
|
|
goto err;
|
|
|
|
nalu_type = extradata[pos] & 0x3f;
|
|
|
|
// Not including libavcodec/hevc.h to avoid confusion between
|
2016-04-27 17:45:23 +00:00
|
|
|
// NAL_* with the same name for both H.264 and HEVC.
|
2014-10-03 20:25:37 +00:00
|
|
|
if (nalu_type == 32) // VPS
|
|
|
|
ps_pos[0] = pos;
|
|
|
|
else if (nalu_type == 33) // SPS
|
|
|
|
ps_pos[1] = pos;
|
|
|
|
else if (nalu_type == 34) // PPS
|
|
|
|
ps_pos[2] = pos;
|
|
|
|
num_nalus = AV_RB16(&extradata[pos + 1]);
|
|
|
|
pos += 3;
|
|
|
|
for (j = 0; j < num_nalus; j++) {
|
|
|
|
int len;
|
|
|
|
if (pos + 2 > extradata_size)
|
|
|
|
goto err;
|
|
|
|
len = AV_RB16(&extradata[pos]);
|
|
|
|
pos += 2;
|
|
|
|
if (pos + len > extradata_size)
|
|
|
|
goto err;
|
|
|
|
pos += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ps_pos[0] || !ps_pos[1] || !ps_pos[2])
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
psets = av_mallocz(MAX_PSET_SIZE);
|
|
|
|
if (!psets)
|
|
|
|
goto err;
|
|
|
|
psets[0] = '\0';
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
pos = ps_pos[i];
|
|
|
|
|
|
|
|
if (i > 0)
|
|
|
|
av_strlcat(psets, "; ", MAX_PSET_SIZE);
|
|
|
|
av_strlcatf(psets, MAX_PSET_SIZE, "sprop-%s=", ps_names[i]);
|
|
|
|
|
|
|
|
// Skipping boundary checks in the input here; we've already traversed
|
|
|
|
// the whole hvcc structure above without issues
|
|
|
|
num_nalus = AV_RB16(&extradata[pos + 1]);
|
|
|
|
pos += 3;
|
|
|
|
for (j = 0; j < num_nalus; j++) {
|
|
|
|
int len = AV_RB16(&extradata[pos]);
|
|
|
|
int strpos;
|
|
|
|
pos += 2;
|
|
|
|
if (j > 0)
|
|
|
|
av_strlcat(psets, ",", MAX_PSET_SIZE);
|
|
|
|
strpos = strlen(psets);
|
|
|
|
if (!av_base64_encode(psets + strpos, MAX_PSET_SIZE - strpos,
|
|
|
|
&extradata[pos], len)) {
|
|
|
|
av_free(psets);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
pos += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
av_free(tmpbuf);
|
|
|
|
|
|
|
|
return psets;
|
|
|
|
|
|
|
|
err:
|
|
|
|
av_free(tmpbuf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static char *extradata2config(AVFormatContext *s, AVCodecParameters *par)
|
2007-09-05 06:30:59 +00:00
|
|
|
{
|
|
|
|
char *config;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->extradata_size > MAX_EXTRADATA_SIZE) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
|
2007-09-05 06:30:59 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
config = av_malloc(10 + par->extradata_size * 2);
|
2014-08-14 20:31:24 +00:00
|
|
|
if (!config) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
|
2007-09-05 06:30:59 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
memcpy(config, "; config=", 9);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
ff_data_to_hex(config + 9, par->extradata, par->extradata_size, 0);
|
|
|
|
config[9 + par->extradata_size * 2] = 0;
|
2007-09-05 06:30:59 +00:00
|
|
|
|
|
|
|
return config;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static char *xiph_extradata2config(AVFormatContext *s, AVCodecParameters *par)
|
2010-08-07 11:16:07 +00:00
|
|
|
{
|
|
|
|
char *config, *encoded_config;
|
2014-12-12 13:46:19 +00:00
|
|
|
const uint8_t *header_start[3];
|
2010-08-07 11:16:07 +00:00
|
|
|
int headers_len, header_len[3], config_len;
|
|
|
|
int first_header_size;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (par->codec_id) {
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_THEORA:
|
2010-08-07 11:16:07 +00:00
|
|
|
first_header_size = 42;
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_VORBIS:
|
2010-08-07 11:16:07 +00:00
|
|
|
first_header_size = 30;
|
|
|
|
break;
|
|
|
|
default:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
|
2010-08-07 11:16:07 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (avpriv_split_xiph_headers(par->extradata, par->extradata_size,
|
2010-08-07 11:16:07 +00:00
|
|
|
first_header_size, header_start,
|
|
|
|
header_len) < 0) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
|
2010-08-07 11:16:07 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
headers_len = header_len[0] + header_len[2];
|
|
|
|
config_len = 4 + // count
|
|
|
|
3 + // ident
|
|
|
|
2 + // packet size
|
|
|
|
1 + // header count
|
|
|
|
2 + // header size
|
|
|
|
headers_len; // and the rest
|
|
|
|
|
|
|
|
config = av_malloc(config_len);
|
|
|
|
if (!config)
|
|
|
|
goto xiph_fail;
|
|
|
|
|
|
|
|
encoded_config = av_malloc(AV_BASE64_SIZE(config_len));
|
|
|
|
if (!encoded_config) {
|
|
|
|
av_free(config);
|
|
|
|
goto xiph_fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
config[0] = config[1] = config[2] = 0;
|
|
|
|
config[3] = 1;
|
2010-08-09 10:31:59 +00:00
|
|
|
config[4] = (RTP_XIPH_IDENT >> 16) & 0xff;
|
|
|
|
config[5] = (RTP_XIPH_IDENT >> 8) & 0xff;
|
|
|
|
config[6] = (RTP_XIPH_IDENT ) & 0xff;
|
2010-08-07 11:16:07 +00:00
|
|
|
config[7] = (headers_len >> 8) & 0xff;
|
|
|
|
config[8] = headers_len & 0xff;
|
|
|
|
config[9] = 2;
|
|
|
|
config[10] = header_len[0];
|
|
|
|
config[11] = 0; // size of comment header; nonexistent
|
|
|
|
memcpy(config + 12, header_start[0], header_len[0]);
|
|
|
|
memcpy(config + 12 + header_len[0], header_start[2], header_len[2]);
|
|
|
|
|
|
|
|
av_base64_encode(encoded_config, AV_BASE64_SIZE(config_len),
|
|
|
|
config, config_len);
|
|
|
|
av_free(config);
|
|
|
|
|
|
|
|
return encoded_config;
|
|
|
|
|
|
|
|
xiph_fail:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
2010-08-07 11:16:07 +00:00
|
|
|
"Not enough memory for configuration string\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static int latm_context2profilelevel(AVCodecParameters *par)
|
2011-05-18 12:00:03 +00:00
|
|
|
{
|
2011-05-18 13:21:48 +00:00
|
|
|
/* MP4A-LATM
|
|
|
|
* The RTP payload format specification is described in RFC 3016
|
|
|
|
* The encoding specifications are provided in ISO/IEC 14496-3 */
|
|
|
|
|
|
|
|
int profile_level = 0x2B;
|
|
|
|
|
|
|
|
/* TODO: AAC Profile only supports AAC LC Object Type.
|
|
|
|
* Different Object Types should implement different Profile Levels */
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->sample_rate <= 24000) {
|
|
|
|
if (par->channels <= 2)
|
2011-05-18 13:21:48 +00:00
|
|
|
profile_level = 0x28; // AAC Profile, Level 1
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
} else if (par->sample_rate <= 48000) {
|
|
|
|
if (par->channels <= 2) {
|
2011-05-18 13:21:48 +00:00
|
|
|
profile_level = 0x29; // AAC Profile, Level 2
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
} else if (par->channels <= 5) {
|
2011-05-18 13:21:48 +00:00
|
|
|
profile_level = 0x2A; // AAC Profile, Level 4
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
} else if (par->sample_rate <= 96000) {
|
|
|
|
if (par->channels <= 5) {
|
2011-05-18 13:21:48 +00:00
|
|
|
profile_level = 0x2B; // AAC Profile, Level 5
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return profile_level;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
static char *latm_context2config(AVFormatContext *s, AVCodecParameters *par)
|
2011-05-18 12:00:03 +00:00
|
|
|
{
|
2011-05-18 13:21:48 +00:00
|
|
|
/* MP4A-LATM
|
|
|
|
* The RTP payload format specification is described in RFC 3016
|
|
|
|
* The encoding specifications are provided in ISO/IEC 14496-3 */
|
|
|
|
|
|
|
|
uint8_t config_byte[6];
|
|
|
|
int rate_index;
|
|
|
|
char *config;
|
|
|
|
|
|
|
|
for (rate_index = 0; rate_index < 16; rate_index++)
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (avpriv_mpeg4audio_sample_rates[rate_index] == par->sample_rate)
|
2011-05-18 13:21:48 +00:00
|
|
|
break;
|
|
|
|
if (rate_index == 16) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
|
2011-05-18 13:21:48 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
config_byte[0] = 0x40;
|
|
|
|
config_byte[1] = 0;
|
|
|
|
config_byte[2] = 0x20 | rate_index;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
config_byte[3] = par->channels << 4;
|
2011-05-18 13:21:48 +00:00
|
|
|
config_byte[4] = 0x3f;
|
|
|
|
config_byte[5] = 0xc0;
|
|
|
|
|
|
|
|
config = av_malloc(6*2+1);
|
|
|
|
if (!config) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
|
2011-05-18 13:21:48 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
ff_data_to_hex(config, config_byte, 6, 1);
|
|
|
|
config[12] = 0;
|
|
|
|
|
|
|
|
return config;
|
|
|
|
}
|
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
static char *sdp_write_media_attributes(char *buff, int size, AVStream *st, int payload_type, AVFormatContext *fmt)
|
2007-07-26 22:34:26 +00:00
|
|
|
{
|
|
|
|
char *config = NULL;
|
2016-04-10 19:58:15 +00:00
|
|
|
AVCodecParameters *p = st->codecpar;
|
2007-07-26 22:34:26 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (p->codec_id) {
|
2016-05-03 17:07:37 +00:00
|
|
|
case AV_CODEC_ID_DIRAC:
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d VC2/90000\r\n", payload_type);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_H264: {
|
2012-05-28 09:11:26 +00:00
|
|
|
int mode = 1;
|
2014-01-03 13:47:02 +00:00
|
|
|
if (fmt && fmt->oformat && fmt->oformat->priv_class &&
|
2012-05-28 09:11:26 +00:00
|
|
|
av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
|
|
|
|
mode = 0;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size) {
|
|
|
|
config = extradata2psets(fmt, p);
|
2008-01-21 14:28:58 +00:00
|
|
|
}
|
2008-01-21 11:09:06 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
|
2012-05-28 09:11:26 +00:00
|
|
|
"a=fmtp:%d packetization-mode=%d%s\r\n",
|
2008-01-21 11:09:06 +00:00
|
|
|
payload_type,
|
2012-05-28 09:11:26 +00:00
|
|
|
payload_type, mode, config ? config : "");
|
2008-01-21 11:09:06 +00:00
|
|
|
break;
|
2012-05-28 09:11:26 +00:00
|
|
|
}
|
2014-10-03 22:17:01 +00:00
|
|
|
case AV_CODEC_ID_H261:
|
|
|
|
{
|
|
|
|
const char *pic_fmt = NULL;
|
|
|
|
/* only QCIF and CIF are specified as supported in RFC 4587 */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->width == 176 && p->height == 144)
|
2014-10-03 22:17:01 +00:00
|
|
|
pic_fmt = "QCIF=1";
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
else if (p->width == 352 && p->height == 288)
|
2014-10-03 22:17:01 +00:00
|
|
|
pic_fmt = "CIF=1";
|
2014-12-06 18:54:07 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
|
2014-10-03 22:17:01 +00:00
|
|
|
if (pic_fmt)
|
|
|
|
av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
|
|
|
|
break;
|
|
|
|
}
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_H263:
|
|
|
|
case AV_CODEC_ID_H263P:
|
2010-12-20 20:46:40 +00:00
|
|
|
/* a=framesize is required by 3GPP TS 26.234 (PSS). It
|
|
|
|
* actually specifies the maximum video size, but we only know
|
|
|
|
* the current size. This is required for playback on Android
|
|
|
|
* stagefright and on Samsung bada. */
|
2012-02-07 14:39:14 +00:00
|
|
|
if (!fmt || !fmt->oformat->priv_class ||
|
|
|
|
!av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->codec_id == AV_CODEC_ID_H263P)
|
2010-12-20 20:46:40 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
|
|
|
|
"a=framesize:%d %d-%d\r\n",
|
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->width, p->height);
|
2009-04-07 06:41:55 +00:00
|
|
|
break;
|
2014-09-21 10:10:42 +00:00
|
|
|
case AV_CODEC_ID_HEVC:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size)
|
|
|
|
config = extradata2psets_hevc(p);
|
2014-09-21 10:10:42 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
|
2014-10-03 20:25:37 +00:00
|
|
|
if (config)
|
|
|
|
av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
|
|
|
|
payload_type, config);
|
2014-09-21 10:10:42 +00:00
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_MPEG4:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size) {
|
|
|
|
config = extradata2config(fmt, p);
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
|
|
|
|
"a=fmtp:%d profile-level-id=1%s\r\n",
|
|
|
|
payload_type,
|
|
|
|
payload_type, config ? config : "");
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_AAC:
|
2011-11-28 03:22:11 +00:00
|
|
|
if (fmt && fmt->oformat && fmt->oformat->priv_class &&
|
2011-05-18 12:00:03 +00:00
|
|
|
av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
config = latm_context2config(fmt, p);
|
2011-05-18 13:21:48 +00:00
|
|
|
if (!config)
|
|
|
|
return NULL;
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
|
|
|
|
"a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate, p->channels,
|
|
|
|
payload_type, latm_context2profilelevel(p), config);
|
2011-05-18 13:21:48 +00:00
|
|
|
} else {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size) {
|
|
|
|
config = extradata2config(fmt, p);
|
2011-05-18 13:21:50 +00:00
|
|
|
} else {
|
|
|
|
/* FIXME: maybe we can forge config information based on the
|
|
|
|
* codec parameters...
|
|
|
|
*/
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(fmt, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
|
2011-05-18 13:21:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2014-08-14 20:31:24 +00:00
|
|
|
if (!config) {
|
2011-05-18 13:21:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
|
|
|
|
"a=fmtp:%d profile-level-id=1;"
|
|
|
|
"mode=AAC-hbr;sizelength=13;indexlength=3;"
|
|
|
|
"indexdeltalength=3%s\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate, p->channels,
|
2011-05-18 13:21:50 +00:00
|
|
|
payload_type, config);
|
2011-05-18 13:21:48 +00:00
|
|
|
}
|
2007-09-05 06:30:59 +00:00
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_PCM_S16BE:
|
2009-12-26 10:59:56 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
2007-11-09 12:33:28 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
|
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->sample_rate, p->channels);
|
2007-11-09 12:33:28 +00:00
|
|
|
break;
|
2017-10-24 21:03:02 +00:00
|
|
|
case AV_CODEC_ID_PCM_S24BE:
|
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d L24/%d/%d\r\n",
|
|
|
|
payload_type,
|
|
|
|
p->sample_rate, p->channels);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_PCM_MULAW:
|
2009-12-26 10:59:56 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
2007-11-09 12:33:28 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
|
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->sample_rate, p->channels);
|
2007-11-09 12:33:28 +00:00
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_PCM_ALAW:
|
2009-12-26 10:59:56 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
2007-11-09 12:33:28 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
|
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->sample_rate, p->channels);
|
2007-11-09 12:33:28 +00:00
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_AMR_NB:
|
2009-04-08 07:16:14 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
|
|
|
|
"a=fmtp:%d octet-align=1\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate, p->channels,
|
2009-04-08 07:16:14 +00:00
|
|
|
payload_type);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_AMR_WB:
|
2009-04-08 07:16:14 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
|
|
|
|
"a=fmtp:%d octet-align=1\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate, p->channels,
|
2009-04-08 07:16:14 +00:00
|
|
|
payload_type);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_VORBIS:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size)
|
|
|
|
config = xiph_extradata2config(fmt, p);
|
2010-08-07 11:16:07 +00:00
|
|
|
else
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(fmt, AV_LOG_ERROR, "Vorbis configuration info missing\n");
|
2010-08-07 11:16:07 +00:00
|
|
|
if (!config)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
|
|
|
|
"a=fmtp:%d configuration=%s\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate, p->channels,
|
2010-08-07 11:16:07 +00:00
|
|
|
payload_type, config);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_THEORA: {
|
2010-08-07 11:16:07 +00:00
|
|
|
const char *pix_fmt;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (p->format) {
|
2012-10-06 10:10:34 +00:00
|
|
|
case AV_PIX_FMT_YUV420P:
|
2010-08-07 11:16:07 +00:00
|
|
|
pix_fmt = "YCbCr-4:2:0";
|
|
|
|
break;
|
2012-10-06 10:10:34 +00:00
|
|
|
case AV_PIX_FMT_YUV422P:
|
2010-08-07 11:16:07 +00:00
|
|
|
pix_fmt = "YCbCr-4:2:2";
|
|
|
|
break;
|
2012-10-06 10:10:34 +00:00
|
|
|
case AV_PIX_FMT_YUV444P:
|
2010-08-07 11:16:07 +00:00
|
|
|
pix_fmt = "YCbCr-4:4:4";
|
|
|
|
break;
|
|
|
|
default:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
|
2010-08-07 11:16:07 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->extradata_size)
|
|
|
|
config = xiph_extradata2config(fmt, p);
|
2013-12-13 22:27:26 +00:00
|
|
|
else
|
2016-07-17 16:10:27 +00:00
|
|
|
av_log(fmt, AV_LOG_ERROR, "Theora configuration info missing\n");
|
2013-12-13 22:27:26 +00:00
|
|
|
if (!config)
|
|
|
|
return NULL;
|
|
|
|
|
2010-08-07 11:16:07 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d theora/90000\r\n"
|
|
|
|
"a=fmtp:%d delivery-method=inline; "
|
|
|
|
"width=%d; height=%d; sampling=%s; "
|
|
|
|
"configuration=%s\r\n",
|
|
|
|
payload_type, payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->width, p->height, pix_fmt, config);
|
2010-08-07 11:16:07 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_VP8:
|
2010-08-16 14:21:17 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d VP8/90000\r\n",
|
|
|
|
payload_type);
|
|
|
|
break;
|
2016-05-30 14:31:52 +00:00
|
|
|
case AV_CODEC_ID_VP9:
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d VP9/90000\r\n",
|
|
|
|
payload_type);
|
|
|
|
break;
|
2012-09-23 14:17:41 +00:00
|
|
|
case AV_CODEC_ID_MJPEG:
|
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d JPEG/90000\r\n",
|
|
|
|
payload_type);
|
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_ADPCM_G722:
|
2010-09-15 17:35:39 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
|
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
8000, p->channels);
|
2010-09-15 17:35:39 +00:00
|
|
|
break;
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_ADPCM_G726: {
|
2011-11-30 21:11:50 +00:00
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
2017-10-07 18:41:38 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d AAL2-G726-%d/%d\r\n",
|
2011-11-30 21:11:50 +00:00
|
|
|
payload_type,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
p->bits_per_coded_sample*8,
|
|
|
|
p->sample_rate);
|
2011-11-30 21:11:50 +00:00
|
|
|
break;
|
|
|
|
}
|
2017-10-07 18:47:10 +00:00
|
|
|
case AV_CODEC_ID_ADPCM_G726LE: {
|
|
|
|
if (payload_type >= RTP_PT_PRIVATE)
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
|
|
|
|
payload_type,
|
|
|
|
p->bits_per_coded_sample*8,
|
|
|
|
p->sample_rate);
|
|
|
|
break;
|
|
|
|
}
|
2012-08-05 09:11:04 +00:00
|
|
|
case AV_CODEC_ID_ILBC:
|
2012-06-17 14:25:46 +00:00
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
|
|
|
|
"a=fmtp:%d mode=%d\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate,
|
|
|
|
payload_type, p->block_align == 38 ? 20 : 30);
|
2012-06-17 14:25:46 +00:00
|
|
|
break;
|
2012-09-22 10:32:37 +00:00
|
|
|
case AV_CODEC_ID_SPEEX:
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type, p->sample_rate);
|
2016-04-10 19:58:15 +00:00
|
|
|
if (st->codec) {
|
2012-10-13 15:03:33 +00:00
|
|
|
const char *mode;
|
|
|
|
uint64_t vad_option;
|
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
if (st->codec->flags & AV_CODEC_FLAG_QSCALE)
|
2012-10-13 15:03:33 +00:00
|
|
|
mode = "on";
|
2016-04-10 19:58:15 +00:00
|
|
|
else if (!av_opt_get_int(st->codec, "vad", AV_OPT_FLAG_ENCODING_PARAM, &vad_option) && vad_option)
|
2012-10-13 15:03:33 +00:00
|
|
|
mode = "vad";
|
|
|
|
else
|
|
|
|
mode = "off";
|
|
|
|
|
|
|
|
av_strlcatf(buff, size, "a=fmtp:%d vbr=%s\r\n",
|
|
|
|
payload_type, mode);
|
|
|
|
}
|
2012-09-22 10:32:37 +00:00
|
|
|
break;
|
2012-10-08 21:51:42 +00:00
|
|
|
case AV_CODEC_ID_OPUS:
|
2014-09-25 00:43:22 +00:00
|
|
|
/* The opus RTP draft says that all opus streams MUST be declared
|
|
|
|
as stereo, to avoid negotiation failures. The actual number of
|
|
|
|
channels can change on a packet-by-packet basis. The number of
|
|
|
|
channels a receiver prefers to receive or a sender plans to send
|
|
|
|
can be declared via fmtp parameters (both default to mono), but
|
|
|
|
receivers MUST be able to receive and process stereo packets. */
|
|
|
|
av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
|
2012-10-08 21:51:42 +00:00
|
|
|
payload_type);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->channels == 2) {
|
2016-03-01 04:08:14 +00:00
|
|
|
av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
|
2014-09-25 00:43:22 +00:00
|
|
|
payload_type);
|
|
|
|
}
|
2012-10-08 21:51:42 +00:00
|
|
|
break;
|
2007-07-26 22:34:26 +00:00
|
|
|
default:
|
2009-02-08 22:06:55 +00:00
|
|
|
/* Nothing special to do here... */
|
2007-07-26 22:34:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_free(config);
|
|
|
|
|
|
|
|
return buff;
|
|
|
|
}
|
|
|
|
|
2012-11-11 19:44:28 +00:00
|
|
|
void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
|
|
|
|
const char *dest_addr, const char *dest_type,
|
|
|
|
int port, int ttl, AVFormatContext *fmt)
|
2007-07-26 22:34:26 +00:00
|
|
|
{
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *p = st->codecpar;
|
2007-07-26 22:34:26 +00:00
|
|
|
const char *type;
|
|
|
|
int payload_type;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
|
2007-07-26 22:34:26 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (p->codec_type) {
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
|
|
|
|
case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
|
|
|
|
case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
|
2007-07-26 22:34:26 +00:00
|
|
|
default : type = "application"; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
|
2010-08-25 12:29:32 +00:00
|
|
|
sdp_write_address(buff, size, dest_addr, dest_type, ttl);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (p->bit_rate) {
|
2017-09-21 23:33:22 +00:00
|
|
|
av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
|
2008-03-05 13:31:24 +00:00
|
|
|
}
|
2007-07-26 22:34:26 +00:00
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
sdp_write_media_attributes(buff, size, st, payload_type, fmt);
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
|
2011-04-08 10:22:39 +00:00
|
|
|
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
|
2007-07-26 22:34:26 +00:00
|
|
|
{
|
2011-05-22 10:46:29 +00:00
|
|
|
AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
|
2011-06-06 12:13:02 +00:00
|
|
|
struct sdp_session_level s = { 0 };
|
2012-11-11 19:44:28 +00:00
|
|
|
int i, j, port, ttl, is_multicast, index = 0;
|
2010-08-25 12:29:32 +00:00
|
|
|
char dst[32], dst_type[5];
|
2007-07-26 22:34:26 +00:00
|
|
|
|
2011-04-08 10:22:39 +00:00
|
|
|
memset(buf, 0, size);
|
2007-07-26 22:34:26 +00:00
|
|
|
s.user = "-";
|
|
|
|
s.src_addr = "127.0.0.1"; /* FIXME: Properly set this */
|
2010-08-25 12:29:32 +00:00
|
|
|
s.src_type = "IP4";
|
2009-02-02 23:08:25 +00:00
|
|
|
s.name = title ? title->value : "No Name";
|
2007-07-26 22:34:26 +00:00
|
|
|
|
|
|
|
port = 0;
|
|
|
|
ttl = 0;
|
|
|
|
if (n_files == 1) {
|
2017-12-29 22:30:14 +00:00
|
|
|
port = sdp_get_address(dst, sizeof(dst), &ttl, ac[0]->url ? ac[0]->url : "");
|
2010-10-07 07:59:35 +00:00
|
|
|
is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
|
|
|
|
sizeof(dst_type));
|
|
|
|
if (!is_multicast)
|
|
|
|
ttl = 0;
|
2010-01-07 08:24:44 +00:00
|
|
|
if (dst[0]) {
|
2007-07-26 22:34:26 +00:00
|
|
|
s.dst_addr = dst;
|
2010-08-25 12:29:32 +00:00
|
|
|
s.dst_type = dst_type;
|
2007-07-26 22:34:26 +00:00
|
|
|
s.ttl = ttl;
|
2010-08-25 12:29:32 +00:00
|
|
|
if (!strcmp(dst_type, "IP6")) {
|
|
|
|
s.src_addr = "::1";
|
|
|
|
s.src_type = "IP6";
|
|
|
|
}
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
2011-04-08 10:22:39 +00:00
|
|
|
sdp_write_header(buf, size, &s);
|
2007-07-26 22:34:26 +00:00
|
|
|
|
|
|
|
dst[0] = 0;
|
|
|
|
for (i = 0; i < n_files; i++) {
|
|
|
|
if (n_files != 1) {
|
2017-12-29 22:30:14 +00:00
|
|
|
port = sdp_get_address(dst, sizeof(dst), &ttl, ac[i]->url ? ac[i]->url : "");
|
2010-10-07 07:59:35 +00:00
|
|
|
is_multicast = resolve_destination(dst, sizeof(dst), dst_type,
|
|
|
|
sizeof(dst_type));
|
|
|
|
if (!is_multicast)
|
|
|
|
ttl = 0;
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
for (j = 0; j < ac[i]->nb_streams; j++) {
|
2012-11-11 19:44:28 +00:00
|
|
|
ff_sdp_write_media(buf, size, ac[i]->streams[j], index++,
|
|
|
|
dst[0] ? dst : NULL, dst_type,
|
|
|
|
(port > 0) ? port + j * 2 : 0,
|
|
|
|
ttl, ac[i]);
|
2007-07-26 22:34:26 +00:00
|
|
|
if (port <= 0) {
|
2011-04-08 10:22:39 +00:00
|
|
|
av_strlcatf(buf, size,
|
2007-07-26 22:34:26 +00:00
|
|
|
"a=control:streamid=%d\r\n", i + j);
|
|
|
|
}
|
2012-12-12 10:59:41 +00:00
|
|
|
if (ac[i]->pb && ac[i]->pb->av_class) {
|
|
|
|
uint8_t *crypto_suite = NULL, *crypto_params = NULL;
|
|
|
|
av_opt_get(ac[i]->pb, "srtp_out_suite", AV_OPT_SEARCH_CHILDREN,
|
|
|
|
&crypto_suite);
|
|
|
|
av_opt_get(ac[i]->pb, "srtp_out_params", AV_OPT_SEARCH_CHILDREN,
|
|
|
|
&crypto_params);
|
|
|
|
if (crypto_suite && crypto_suite[0])
|
|
|
|
av_strlcatf(buf, size,
|
|
|
|
"a=crypto:1 %s inline:%s\r\n",
|
|
|
|
crypto_suite, crypto_params);
|
|
|
|
av_free(crypto_suite);
|
|
|
|
av_free(crypto_params);
|
|
|
|
}
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-05 13:44:56 +00:00
|
|
|
return 0;
|
2007-07-26 22:34:26 +00:00
|
|
|
}
|
2007-08-05 13:32:37 +00:00
|
|
|
#else
|
2011-04-08 10:22:39 +00:00
|
|
|
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
|
2007-08-05 13:32:37 +00:00
|
|
|
{
|
2007-08-05 13:44:56 +00:00
|
|
|
return AVERROR(ENOSYS);
|
2007-08-05 13:32:37 +00:00
|
|
|
}
|
2010-05-18 19:32:59 +00:00
|
|
|
|
2012-11-11 19:44:28 +00:00
|
|
|
void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
|
|
|
|
const char *dest_addr, const char *dest_type,
|
|
|
|
int port, int ttl, AVFormatContext *fmt)
|
2010-05-18 19:32:59 +00:00
|
|
|
{
|
|
|
|
}
|
2007-08-05 13:32:37 +00:00
|
|
|
#endif
|