tls_gnutls: Readd support for nonblocking operation
[ffmpeg.git] / libavformat / rtpdec_latm.c
1 /*
2  * RTP Depacketization of MP4A-LATM, RFC 3016
3  * Copyright (c) 2010 Martin Storsjo
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/avstring.h"
23
24 #include "libavcodec/bitstream.h"
25
26 #include "avio_internal.h"
27 #include "rtpdec_formats.h"
28 #include "internal.h"
29
30 struct PayloadContext {
31     AVIOContext *dyn_buf;
32     uint8_t *buf;
33     int pos, len;
34     uint32_t timestamp;
35 };
36
37 static void latm_close_context(PayloadContext *data)
38 {
39     ffio_free_dyn_buf(&data->dyn_buf);
40     av_free(data->buf);
41 }
42
43 static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
44                              AVStream *st, AVPacket *pkt, uint32_t *timestamp,
45                              const uint8_t *buf, int len, uint16_t seq,
46                              int flags)
47 {
48     int ret, cur_len;
49
50     if (buf) {
51         if (!data->dyn_buf || data->timestamp != *timestamp) {
52             av_freep(&data->buf);
53             ffio_free_dyn_buf(&data->dyn_buf);
54
55             data->timestamp = *timestamp;
56             if ((ret = avio_open_dyn_buf(&data->dyn_buf)) < 0)
57                 return ret;
58         }
59         avio_write(data->dyn_buf, buf, len);
60
61         if (!(flags & RTP_FLAG_MARKER))
62             return AVERROR(EAGAIN);
63         av_free(data->buf);
64         data->len = avio_close_dyn_buf(data->dyn_buf, &data->buf);
65         data->dyn_buf = NULL;
66         data->pos = 0;
67     }
68
69     if (!data->buf) {
70         av_log(ctx, AV_LOG_ERROR, "No data available yet\n");
71         return AVERROR(EIO);
72     }
73
74     cur_len = 0;
75     while (data->pos < data->len) {
76         uint8_t val = data->buf[data->pos++];
77         cur_len += val;
78         if (val != 0xff)
79             break;
80     }
81     if (data->pos + cur_len > data->len) {
82         av_log(ctx, AV_LOG_ERROR, "Malformed LATM packet\n");
83         return AVERROR(EIO);
84     }
85
86     if ((ret = av_new_packet(pkt, cur_len)) < 0)
87         return ret;
88     memcpy(pkt->data, data->buf + data->pos, cur_len);
89     data->pos += cur_len;
90     pkt->stream_index = st->index;
91     return data->pos < data->len;
92 }
93
94 static int parse_fmtp_config(AVStream *st, const char *value)
95 {
96     int len = ff_hex_to_data(NULL, value), i, ret = 0;
97     BitstreamContext bc;
98     uint8_t *config;
99     int audio_mux_version, same_time_framing, num_programs, num_layers;
100
101     /* Pad this buffer, too, to avoid out of bounds reads with get_bits below */
102     config = av_mallocz(len + AV_INPUT_BUFFER_PADDING_SIZE);
103     if (!config)
104         return AVERROR(ENOMEM);
105     ff_hex_to_data(config, value);
106     bitstream_init8(&bc, config, len);
107     audio_mux_version = bitstream_read(&bc, 1);
108     same_time_framing = bitstream_read(&bc, 1);
109     bitstream_skip(&bc, 6); /* num_sub_frames */
110     num_programs      = bitstream_read(&bc, 4);
111     num_layers        = bitstream_read(&bc, 3);
112     if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 ||
113         num_layers != 0) {
114         avpriv_report_missing_feature(NULL, "LATM config (%d,%d,%d,%d)",
115                                       audio_mux_version, same_time_framing,
116                                       num_programs, num_layers);
117         ret = AVERROR_PATCHWELCOME;
118         goto end;
119     }
120     av_freep(&st->codecpar->extradata);
121     st->codecpar->extradata_size = (bitstream_bits_left(&bc) + 7) / 8;
122     st->codecpar->extradata = av_mallocz(st->codecpar->extradata_size +
123                                          AV_INPUT_BUFFER_PADDING_SIZE);
124     if (!st->codecpar->extradata) {
125         ret = AVERROR(ENOMEM);
126         goto end;
127     }
128     for (i = 0; i < st->codecpar->extradata_size; i++)
129         st->codecpar->extradata[i] = bitstream_read(&bc, 8);
130
131 end:
132     av_free(config);
133     return ret;
134 }
135
136 static int parse_fmtp(AVFormatContext *s,
137                       AVStream *stream, PayloadContext *data,
138                       const char *attr, const char *value)
139 {
140     int res;
141
142     if (!strcmp(attr, "config")) {
143         res = parse_fmtp_config(stream, value);
144         if (res < 0)
145             return res;
146     } else if (!strcmp(attr, "cpresent")) {
147         int cpresent = atoi(value);
148         if (cpresent != 0)
149             avpriv_request_sample(s,
150                                   "RTP MP4A-LATM with in-band configuration");
151     }
152
153     return 0;
154 }
155
156 static int latm_parse_sdp_line(AVFormatContext *s, int st_index,
157                                PayloadContext *data, const char *line)
158 {
159     const char *p;
160
161     if (st_index < 0)
162         return 0;
163
164     if (av_strstart(line, "fmtp:", &p))
165         return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);
166
167     return 0;
168 }
169
170 RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler = {
171     .enc_name           = "MP4A-LATM",
172     .codec_type         = AVMEDIA_TYPE_AUDIO,
173     .codec_id           = AV_CODEC_ID_AAC,
174     .priv_data_size     = sizeof(PayloadContext),
175     .parse_sdp_a_line   = latm_parse_sdp_line,
176     .close              = latm_close_context,
177     .parse_packet       = latm_parse_packet,
178 };