FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Common code for the RTP depacketization of MPEG-4 formats.
3			* Copyright (c) 2010 Fabrice Bellard
4			* Romain Degez
5			*
6			* This file is part of FFmpeg.
7			*
8			* FFmpeg is free software; you can redistribute it and/or
9			* modify it under the terms of the GNU Lesser General Public
10			* License as published by the Free Software Foundation; either
11			* version 2.1 of the License, or (at your option) any later version.
12			*
13			* FFmpeg is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16			* Lesser General Public License for more details.
17			*
18			* You should have received a copy of the GNU Lesser General Public
19			* License along with FFmpeg; if not, write to the Free Software
20			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21			*/
22
23			/**
24			* @file
25			* @brief MPEG-4 / RTP Code
26			* @author Fabrice Bellard
27			* @author Romain Degez
28			*/
29
30			#include "rtpdec_formats.h"
31			#include "internal.h"
32			#include "libavutil/attributes.h"
33			#include "libavutil/avstring.h"
34			#include "libavutil/mem.h"
35			#include "libavcodec/get_bits.h"
36
37			#define MAX_AAC_HBR_FRAME_SIZE 8191
38
39			/** Structure listing useful vars to parse RTP packet payload */
40			struct PayloadContext {
41			int bitrate;
42			int sizelength;
43			int indexlength;
44			int indexdeltalength;
45			int profile_level_id;
46			int streamtype;
47			int objecttype;
48			char *mode;
49
50			/** mpeg 4 AU headers */
51			struct AUHeaders {
52			int size;
53			int index;
54			int cts_flag;
55			int cts;
56			int dts_flag;
57			int dts;
58			int rap_flag;
59			int streamstate;
60			} *au_headers;
61			int au_headers_allocated;
62			int nb_au_headers;
63			int au_headers_length_bytes;
64			int cur_au_index;
65
66			uint8_t buf[FFMAX(RTP_MAX_PACKET_LENGTH, MAX_AAC_HBR_FRAME_SIZE)];
67			int buf_pos, buf_size;
68			uint32_t timestamp;
69			};
70
71			typedef struct AttrNameMap {
72			const char *str;
73			uint16_t type;
74			uint32_t offset;
75
76			/** Range for integer values */
77			struct Range {
78			int min;
79			int max;
80			} range;
81			} AttrNameMap;
82
83			/* All known fmtp parameters and the corresponding RTPAttrTypeEnum */
84			#define ATTR_NAME_TYPE_INT 0
85			#define ATTR_NAME_TYPE_STR 1
86			static const AttrNameMap attr_names[] = {
87			{ "bitrate", ATTR_NAME_TYPE_INT,
88			offsetof(PayloadContext, bitrate),
89			{0, INT32_MAX} },
90			{ "SizeLength", ATTR_NAME_TYPE_INT,
91			offsetof(PayloadContext, sizelength),
92			{0, 32} }, // SizeLength number of bits used to encode AU-size integer value
93			{ "IndexLength", ATTR_NAME_TYPE_INT,
94			offsetof(PayloadContext, indexlength),
95			{0, 32} }, // IndexLength number of bits used to encode AU-Index integer value
96			{ "IndexDeltaLength", ATTR_NAME_TYPE_INT,
97			offsetof(PayloadContext, indexdeltalength),
98			{0, 32} }, // IndexDeltaLength number of bits to encode AU-Index-delta integer value
99			{ "profile-level-id", ATTR_NAME_TYPE_INT,
100			offsetof(PayloadContext, profile_level_id),
101			{INT32_MIN, INT32_MAX} }, // It differs depending on StreamType
102			{ "StreamType", ATTR_NAME_TYPE_INT,
103			offsetof(PayloadContext, streamtype),
104			{0x00, 0x3F} }, // Values from ISO/IEC 14496-1, 'StreamType Values' table
105			{ "mode", ATTR_NAME_TYPE_STR,
106			offsetof(PayloadContext, mode),
107			{0} },
108			{ NULL, -1, -1, {0} },
109			};
110
111		✗	static void close_context(PayloadContext *data)
112			{
113		✗	av_freep(&data->au_headers);
114		✗	av_freep(&data->mode);
115		✗	}
116
117		✗	static int parse_fmtp_config(AVCodecParameters *par, const char *value)
118			{
119			/* decode the hexa encoded parameter */
120		✗	int len = ff_hex_to_data(NULL, value), ret;
121
122		✗	if ((ret = ff_alloc_extradata(par, len)) < 0)
123		✗	return ret;
124		✗	ff_hex_to_data(par->extradata, value);
125		✗	return 0;
126			}
127
128		✗	static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf, int len)
129			{
130			int au_headers_length, au_header_size, i;
131			GetBitContext getbitcontext;
132			int ret;
133
134		✗	if (len < 2)
135		✗	return AVERROR_INVALIDDATA;
136
137			/* decode the first 2 bytes where the AUHeader sections are stored
138			length in bits */
139		✗	au_headers_length = AV_RB16(buf);
140
141		✗	if (au_headers_length > RTP_MAX_PACKET_LENGTH)
142		✗	return -1;
143
144		✗	data->au_headers_length_bytes = (au_headers_length + 7) / 8;
145
146			/* skip AU headers length section (2 bytes) */
147		✗	buf += 2;
148		✗	len -= 2;
149
150		✗	if (len < data->au_headers_length_bytes)
151		✗	return AVERROR_INVALIDDATA;
152
153		✗	ret = init_get_bits(&getbitcontext, buf, data->au_headers_length_bytes * 8);
154		✗	if (ret < 0)
155		✗	return ret;
156
157			/* XXX: Wrong if optional additional sections are present (cts, dts etc...) */
158		✗	au_header_size = data->sizelength + data->indexlength;
159		✗	if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
160		✗	return -1;
161
162		✗	data->nb_au_headers = au_headers_length / au_header_size;
163		✗	if (!data->au_headers || data->au_headers_allocated < data->nb_au_headers) {
164		✗	av_free(data->au_headers);
165		✗	data->au_headers = av_malloc(sizeof(struct AUHeaders) * data->nb_au_headers);
166		✗	if (!data->au_headers)
167		✗	return AVERROR(ENOMEM);
168		✗	data->au_headers_allocated = data->nb_au_headers;
169			}
170
171		✗	for (i = 0; i < data->nb_au_headers; ++i) {
172		✗	data->au_headers[i].size = get_bits_long(&getbitcontext, data->sizelength);
173		✗	data->au_headers[i].index = get_bits_long(&getbitcontext, data->indexlength);
174			}
175
176		✗	return 0;
177			}
178
179
180			/* Follows RFC 3640 */
181		✗	static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data,
182			AVStream *st, AVPacket *pkt, uint32_t *timestamp,
183			const uint8_t *buf, int len, uint16_t seq,
184			int flags)
185			{
186			int ret;
187
188
189		✗	if (!buf) {
190		✗	if (data->cur_au_index > data->nb_au_headers) {
191		✗	av_log(ctx, AV_LOG_ERROR, "Invalid parser state\n");
192		✗	return AVERROR_INVALIDDATA;
193			}
194		✗	if (data->buf_size - data->buf_pos < data->au_headers[data->cur_au_index].size) {
195		✗	av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
196		✗	return AVERROR_INVALIDDATA;
197			}
198		✗	if ((ret = av_new_packet(pkt, data->au_headers[data->cur_au_index].size)) < 0) {
199		✗	av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
200		✗	return ret;
201			}
202		✗	memcpy(pkt->data, &data->buf[data->buf_pos], data->au_headers[data->cur_au_index].size);
203		✗	data->buf_pos += data->au_headers[data->cur_au_index].size;
204		✗	pkt->stream_index = st->index;
205		✗	data->cur_au_index++;
206
207		✗	if (data->cur_au_index == data->nb_au_headers) {
208		✗	data->buf_pos = 0;
209		✗	return 0;
210			}
211
212		✗	return 1;
213			}
214
215		✗	if (rtp_parse_mp4_au(data, buf, len)) {
216		✗	av_log(ctx, AV_LOG_ERROR, "Error parsing AU headers\n");
217		✗	return -1;
218			}
219
220		✗	buf += data->au_headers_length_bytes + 2;
221		✗	len -= data->au_headers_length_bytes + 2;
222		✗	if (data->nb_au_headers == 1 && len < data->au_headers[0].size) {
223			/* Packet is fragmented */
224
225		✗	if (!data->buf_pos) {
226		✗	if (data->au_headers[0].size > MAX_AAC_HBR_FRAME_SIZE) {
227		✗	av_log(ctx, AV_LOG_ERROR, "Invalid AU size\n");
228		✗	return AVERROR_INVALIDDATA;
229			}
230
231		✗	data->buf_size = data->au_headers[0].size;
232		✗	data->timestamp = *timestamp;
233			}
234
235		✗	if (data->timestamp != *timestamp ||
236		✗	data->au_headers[0].size != data->buf_size ||
237		✗	data->buf_pos + len > MAX_AAC_HBR_FRAME_SIZE) {
238		✗	data->buf_pos = 0;
239		✗	data->buf_size = 0;
240		✗	av_log(ctx, AV_LOG_ERROR, "Invalid packet received\n");
241		✗	return AVERROR_INVALIDDATA;
242			}
243
244		✗	memcpy(&data->buf[data->buf_pos], buf, len);
245		✗	data->buf_pos += len;
246
247		✗	if (!(flags & RTP_FLAG_MARKER))
248		✗	return AVERROR(EAGAIN);
249
250		✗	if (data->buf_pos != data->buf_size) {
251		✗	data->buf_pos = 0;
252		✗	av_log(ctx, AV_LOG_ERROR, "Missed some packets, discarding frame\n");
253		✗	return AVERROR_INVALIDDATA;
254			}
255
256		✗	data->buf_pos = 0;
257		✗	ret = av_new_packet(pkt, data->buf_size);
258		✗	if (ret < 0) {
259		✗	av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
260		✗	return ret;
261			}
262		✗	pkt->stream_index = st->index;
263
264		✗	memcpy(pkt->data, data->buf, data->buf_size);
265
266		✗	return 0;
267			}
268
269		✗	if (len < data->au_headers[0].size) {
270		✗	av_log(ctx, AV_LOG_ERROR, "First AU larger than packet size\n");
271		✗	return AVERROR_INVALIDDATA;
272			}
273		✗	if ((ret = av_new_packet(pkt, data->au_headers[0].size)) < 0) {
274		✗	av_log(ctx, AV_LOG_ERROR, "Out of memory\n");
275		✗	return ret;
276			}
277		✗	memcpy(pkt->data, buf, data->au_headers[0].size);
278		✗	len -= data->au_headers[0].size;
279		✗	buf += data->au_headers[0].size;
280		✗	pkt->stream_index = st->index;
281
282		✗	if (len > 0 && data->nb_au_headers > 1) {
283		✗	data->buf_size = FFMIN(len, sizeof(data->buf));
284		✗	memcpy(data->buf, buf, data->buf_size);
285		✗	data->cur_au_index = 1;
286		✗	data->buf_pos = 0;
287		✗	return 1;
288			}
289
290		✗	return 0;
291			}
292
293		✗	static int parse_fmtp(AVFormatContext *s,
294			AVStream *stream, PayloadContext *data,
295			const char *attr, const char *value)
296			{
297		✗	AVCodecParameters *par = stream->codecpar;
298			int res, i;
299
300		✗	if (!strcmp(attr, "config")) {
301		✗	res = parse_fmtp_config(par, value);
302
303		✗	if (res < 0)
304		✗	return res;
305			}
306
307		✗	if (par->codec_id == AV_CODEC_ID_AAC) {
308			/* Looking for a known attribute */
309		✗	for (i = 0; attr_names[i].str; ++i) {
310		✗	if (!av_strcasecmp(attr, attr_names[i].str)) {
311		✗	if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
312		✗	char *end_ptr = NULL;
313		✗	long long int val = strtoll(value, &end_ptr, 10);
314		✗	if (end_ptr == value || end_ptr[0] != '\0') {
315		✗	av_log(s, AV_LOG_ERROR,
316			"The %s field value is not a valid number: %s\n",
317			attr, value);
318		✗	return AVERROR_INVALIDDATA;
319			}
320		✗	if (val < attr_names[i].range.min ||
321		✗	val > attr_names[i].range.max) {
322		✗	av_log(s, AV_LOG_ERROR,
323			"fmtp field %s should be in range [%d,%d] (provided value: %lld)",
324		✗	attr, attr_names[i].range.min, attr_names[i].range.max, val);
325		✗	return AVERROR_INVALIDDATA;
326			}
327
328		✗	*(int *)((char *)data+
329		✗	attr_names[i].offset) = (int) val;
330		✗	} else if (attr_names[i].type == ATTR_NAME_TYPE_STR) {
331		✗	char *val = av_strdup(value);
332		✗	if (!val)
333		✗	return AVERROR(ENOMEM);
334		✗	*(char **)((char *)data+
335		✗	attr_names[i].offset) = val;
336			}
337			}
338			}
339		✗	if (!strcmp(attr, "bitrate")) {
340		✗	par->bit_rate = data->bitrate;
341			}
342			}
343		✗	return 0;
344			}
345
346		✗	static int parse_sdp_line(AVFormatContext *s, int st_index,
347			PayloadContext *data, const char *line)
348			{
349			const char *p;
350
351		✗	if (st_index < 0)
352		✗	return 0;
353
354		✗	if (av_strstart(line, "fmtp:", &p))
355		✗	return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);
356
357		✗	return 0;
358			}
359
360			const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler = {
361			.enc_name = "MP4V-ES",
362			.codec_type = AVMEDIA_TYPE_VIDEO,
363			.codec_id = AV_CODEC_ID_MPEG4,
364			.need_parsing = AVSTREAM_PARSE_FULL,
365			.priv_data_size = sizeof(PayloadContext),
366			.parse_sdp_a_line = parse_sdp_line,
367			};
368
369			const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler = {
370			.enc_name = "mpeg4-generic",
371			.codec_type = AVMEDIA_TYPE_AUDIO,
372			.codec_id = AV_CODEC_ID_AAC,
373			.need_parsing = AVSTREAM_PARSE_HEADERS,
374			.priv_data_size = sizeof(PayloadContext),
375			.parse_sdp_a_line = parse_sdp_line,
376			.close = close_context,
377			.parse_packet = aac_parse_packet,
378			};
379