rtpdec_h264.c 13.5 KB
Newer Older
1
/*
2
 * RTP H.264 Protocol (RFC3984)
3
 * Copyright (c) 2006 Ryan Martell
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * 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
 */

/**
23
 * @file
24 25 26 27 28 29 30 31
 * @brief H.264 / RTP Code (RFC3984)
 * @author Ryan Martell <rdm4@martellventures.com>
 *
 * @note Notes:
 * Notes:
 * This currently supports packetization mode:
 * Single Nal Unit Mode (0), or
 * Non-Interleaved Mode (1).  It currently does not support
32 33
 * Interleaved Mode (2). (This requires implementing STAP-B, MTAP16, MTAP24,
 *                        FU-B packet types)
34 35
 */

36
#include "libavutil/attributes.h"
37
#include "libavutil/base64.h"
38
#include "libavutil/intreadwrite.h"
39
#include "libavutil/avstring.h"
40 41
#include "avformat.h"

42
#include "rtpdec.h"
43
#include "rtpdec_formats.h"
44

45
struct PayloadContext {
46
    // sdp setup parameters
47 48 49 50
    uint8_t profile_idc;
    uint8_t profile_iop;
    uint8_t level_idc;
    int packetization_mode;
51 52 53
#ifdef DEBUG
    int packet_types_received[32];
#endif
54
};
55

56 57
#ifdef DEBUG
#define COUNT_NAL_TYPE(data, nal) data->packet_types_received[(nal) & 0x1f]++
58
#define NAL_COUNTERS data->packet_types_received
59 60
#else
#define COUNT_NAL_TYPE(data, nal) do { } while (0)
61
#define NAL_COUNTERS NULL
62
#endif
63
#define NAL_MASK 0x1f
64

65 66
static const uint8_t start_sequence[] = { 0, 0, 0, 1 };

67 68
static void parse_profile_level_id(AVFormatContext *s,
                                   PayloadContext *h264_data,
69
                                   const char *value)
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
{
    char buffer[3];
    // 6 characters=3 bytes, in hex.
    uint8_t profile_idc;
    uint8_t profile_iop;
    uint8_t level_idc;

    buffer[0]   = value[0];
    buffer[1]   = value[1];
    buffer[2]   = '\0';
    profile_idc = strtol(buffer, NULL, 16);
    buffer[0]   = value[2];
    buffer[1]   = value[3];
    profile_iop = strtol(buffer, NULL, 16);
    buffer[0]   = value[4];
    buffer[1]   = value[5];
    level_idc   = strtol(buffer, NULL, 16);

    av_log(s, AV_LOG_DEBUG,
           "RTP Profile IDC: %x Profile IOP: %x Level: %x\n",
           profile_idc, profile_iop, level_idc);
    h264_data->profile_idc = profile_idc;
    h264_data->profile_iop = profile_iop;
    h264_data->level_idc   = level_idc;
}

96 97 98
int ff_h264_parse_sprop_parameter_sets(AVFormatContext *s,
                                       uint8_t **data_ptr, int *size_ptr,
                                       const char *value)
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
{
    char base64packet[1024];
    uint8_t decoded_packet[1024];
    int packet_size;

    while (*value) {
        char *dst = base64packet;

        while (*value && *value != ','
               && (dst - base64packet) < sizeof(base64packet) - 1) {
            *dst++ = *value++;
        }
        *dst++ = '\0';

        if (*value == ',')
            value++;

        packet_size = av_base64_decode(decoded_packet, base64packet,
                                       sizeof(decoded_packet));
        if (packet_size > 0) {
119
            uint8_t *dest = av_realloc(*data_ptr,
120
                                       packet_size + sizeof(start_sequence) +
121
                                       *size_ptr +
122
                                       AV_INPUT_BUFFER_PADDING_SIZE);
123 124 125 126 127
            if (!dest) {
                av_log(s, AV_LOG_ERROR,
                       "Unable to allocate memory for extradata!\n");
                return AVERROR(ENOMEM);
            }
128
            *data_ptr = dest;
129

130
            memcpy(dest + *size_ptr, start_sequence,
131
                   sizeof(start_sequence));
132
            memcpy(dest + *size_ptr + sizeof(start_sequence),
133
                   decoded_packet, packet_size);
134
            memset(dest + *size_ptr + sizeof(start_sequence) +
135
                   packet_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
136

137
            *size_ptr += sizeof(start_sequence) + packet_size;
138 139 140 141 142 143
        }
    }

    return 0;
}

144 145
static int sdp_parse_fmtp_config_h264(AVFormatContext *s,
                                      AVStream *stream,
146
                                      PayloadContext *h264_data,
147
                                      const char *attr, const char *value)
148
{
149
    AVCodecParameters *par = stream->codecpar;
150 151

    if (!strcmp(attr, "packetization-mode")) {
152
        av_log(s, AV_LOG_DEBUG, "RTP Packetization Mode: %d\n", atoi(value));
153
        h264_data->packetization_mode = atoi(value);
154
        /*
155 156 157 158 159
         * Packetization Mode:
         * 0 or not present: Single NAL mode (Only nals from 1-23 are allowed)
         * 1: Non-interleaved Mode: 1-23, 24 (STAP-A), 28 (FU-A) are allowed.
         * 2: Interleaved Mode: 25 (STAP-B), 26 (MTAP16), 27 (MTAP24), 28 (FU-A),
         *                      and 29 (FU-B) are allowed.
160 161
         */
        if (h264_data->packetization_mode > 1)
162
            av_log(s, AV_LOG_ERROR,
163
                   "Interleaved RTP mode is not supported yet.\n");
164
    } else if (!strcmp(attr, "profile-level-id")) {
165 166
        if (strlen(value) == 6)
            parse_profile_level_id(s, h264_data, value);
167
    } else if (!strcmp(attr, "sprop-parameter-sets")) {
168
        int ret;
169 170 171 172
        if (value[strlen(value) - 1] == ',') {
            av_log(s, AV_LOG_WARNING, "Missing PPS in sprop-parameter-sets, ignoring\n");
            return 0;
        }
173 174 175 176
        par->extradata_size = 0;
        av_freep(&par->extradata);
        ret = ff_h264_parse_sprop_parameter_sets(s, &par->extradata,
                                                 &par->extradata_size, value);
177
        av_log(s, AV_LOG_DEBUG, "Extradata set to %p (size: %d)\n",
178
               par->extradata, par->extradata_size);
179
        return ret;
180
    }
181
    return 0;
182 183
}

184
void ff_h264_parse_framesize(AVCodecParameters *par, const char *p)
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
{
    char buf1[50];
    char *dst = buf1;

    // remove the protocol identifier
    while (*p && *p == ' ')
        p++;                     // strip spaces.
    while (*p && *p != ' ')
        p++;                     // eat protocol identifier
    while (*p && *p == ' ')
        p++;                     // strip trailing spaces.
    while (*p && *p != '-' && (dst - buf1) < sizeof(buf1) - 1)
        *dst++ = *p++;
    *dst = '\0';

    // a='framesize:96 320-240'
    // set our parameters
202 203
    par->width   = atoi(buf1);
    par->height  = atoi(p + 1); // skip the -
204 205
}

206
int ff_h264_handle_aggregated_packet(AVFormatContext *ctx, PayloadContext *data, AVPacket *pkt,
207
                                     const uint8_t *buf, int len,
208
                                     int skip_between, int *nal_counters,
209
                                     int nal_mask)
210 211 212 213 214 215
{
    int pass         = 0;
    int total_length = 0;
    uint8_t *dst     = NULL;
    int ret;

216
    // first we are going to figure out the total size
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
    for (pass = 0; pass < 2; pass++) {
        const uint8_t *src = buf;
        int src_len        = len;

        while (src_len > 2) {
            uint16_t nal_size = AV_RB16(src);

            // consume the length of the aggregate
            src     += 2;
            src_len -= 2;

            if (nal_size <= src_len) {
                if (pass == 0) {
                    // counting
                    total_length += sizeof(start_sequence) + nal_size;
                } else {
                    // copying
                    memcpy(dst, start_sequence, sizeof(start_sequence));
                    dst += sizeof(start_sequence);
                    memcpy(dst, src, nal_size);
237 238
                    if (nal_counters)
                        nal_counters[(*src) & nal_mask]++;
239 240 241 242 243
                    dst += nal_size;
                }
            } else {
                av_log(ctx, AV_LOG_ERROR,
                       "nal size exceeds length: %d %d\n", nal_size, src_len);
244
                return AVERROR_INVALIDDATA;
245 246 247
            }

            // eat what we handled
248 249
            src     += nal_size + skip_between;
            src_len -= nal_size + skip_between;
250 251 252 253 254 255 256 257 258 259 260 261 262 263
        }

        if (pass == 0) {
            /* now we know the total size of the packet (with the
             * start sequences added) */
            if ((ret = av_new_packet(pkt, total_length)) < 0)
                return ret;
            dst = pkt->data;
        }
    }

    return 0;
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
int ff_h264_handle_frag_packet(AVPacket *pkt, const uint8_t *buf, int len,
                               int start_bit, const uint8_t *nal_header,
                               int nal_header_len)
{
    int ret;
    int tot_len = len;
    int pos = 0;
    if (start_bit)
        tot_len += sizeof(start_sequence) + nal_header_len;
    if ((ret = av_new_packet(pkt, tot_len)) < 0)
        return ret;
    if (start_bit) {
        memcpy(pkt->data + pos, start_sequence, sizeof(start_sequence));
        pos += sizeof(start_sequence);
        memcpy(pkt->data + pos, nal_header, nal_header_len);
        pos += nal_header_len;
    }
    memcpy(pkt->data + pos, buf, len);
    return 0;
}

285
static int h264_handle_packet_fu_a(AVFormatContext *ctx, PayloadContext *data, AVPacket *pkt,
286 287
                                   const uint8_t *buf, int len,
                                   int *nal_counters, int nal_mask)
288 289 290 291
{
    uint8_t fu_indicator, fu_header, start_bit, nal_type, nal;

    if (len < 3) {
292
        av_log(ctx, AV_LOG_ERROR, "Too short data for FU-A H.264 RTP packet\n");
293 294 295 296 297 298 299 300 301 302 303 304 305
        return AVERROR_INVALIDDATA;
    }

    fu_indicator = buf[0];
    fu_header    = buf[1];
    start_bit    = fu_header >> 7;
    nal_type     = fu_header & 0x1f;
    nal          = fu_indicator & 0xe0 | nal_type;

    // skip the fu_indicator and fu_header
    buf += 2;
    len -= 2;

306 307 308
    if (start_bit && nal_counters)
        nal_counters[nal_type & nal_mask]++;
    return ff_h264_handle_frag_packet(pkt, buf, len, start_bit, &nal, 1);
309 310
}

311
// return 0 on packet, no more left, 1 on packet, 1 on partial packet
312 313
static int h264_handle_packet(AVFormatContext *ctx, PayloadContext *data,
                              AVStream *st, AVPacket *pkt, uint32_t *timestamp,
314 315
                              const uint8_t *buf, int len, uint16_t seq,
                              int flags)
316
{
317 318
    uint8_t nal;
    uint8_t type;
319
    int result = 0;
320

321
    if (!len) {
322
        av_log(ctx, AV_LOG_ERROR, "Empty H.264 RTP packet\n");
323 324 325 326 327
        return AVERROR_INVALIDDATA;
    }
    nal  = buf[0];
    type = nal & 0x1f;

328 329
    /* Simplify the case (these are all the NAL types used internally by
     * the H.264 codec). */
330
    if (type >= 1 && type <= 23)
331
        type = 1;
332
    switch (type) {
333
    case 0:                    // undefined, but pass them through
334
    case 1:
335 336
        if ((result = av_new_packet(pkt, len + sizeof(start_sequence))) < 0)
            return result;
337
        memcpy(pkt->data, start_sequence, sizeof(start_sequence));
338
        memcpy(pkt->data + sizeof(start_sequence), buf, len);
339
        COUNT_NAL_TYPE(data, nal);
340 341 342 343 344 345
        break;

    case 24:                   // STAP-A (one packet, multiple nals)
        // consume the STAP-A NAL
        buf++;
        len--;
346
        result = ff_h264_handle_aggregated_packet(ctx, data, pkt, buf, len, 0,
347
                                                  NAL_COUNTERS, NAL_MASK);
348 349 350 351 352 353
        break;

    case 25:                   // STAP-B
    case 26:                   // MTAP-16
    case 27:                   // MTAP-24
    case 29:                   // FU-B
354
        avpriv_report_missing_feature(ctx, "RTP H.264 NAL unit type %d", type);
355
        result = AVERROR_PATCHWELCOME;
356 357 358
        break;

    case 28:                   // FU-A (fragmented nal)
359
        result = h264_handle_packet_fu_a(ctx, data, pkt, buf, len,
360
                                         NAL_COUNTERS, NAL_MASK);
361 362 363 364 365
        break;

    case 30:                   // undefined
    case 31:                   // undefined
    default:
366
        av_log(ctx, AV_LOG_ERROR, "Undefined type (%d)\n", type);
367
        result = AVERROR_INVALIDDATA;
368 369 370
        break;
    }

371 372
    pkt->stream_index = st->index;

373 374 375
    return result;
}

376
static void h264_close_context(PayloadContext *data)
377 378 379 380 381 382 383 384 385 386 387 388
{
#ifdef DEBUG
    int ii;

    for (ii = 0; ii < 32; ii++) {
        if (data->packet_types_received[ii])
            av_log(NULL, AV_LOG_DEBUG, "Received %d packets of type %d\n",
                   data->packet_types_received[ii], ii);
    }
#endif
}

389 390
static int parse_h264_sdp_line(AVFormatContext *s, int st_index,
                               PayloadContext *h264_data, const char *line)
391
{
392
    AVStream *stream;
393 394
    const char *p = line;

395 396 397 398
    if (st_index < 0)
        return 0;

    stream = s->streams[st_index];
399

400
    if (av_strstart(p, "framesize:", &p)) {
401
        ff_h264_parse_framesize(stream->codecpar, p);
402
    } else if (av_strstart(p, "fmtp:", &p)) {
403
        return ff_parse_fmtp(s, stream, h264_data, p, sdp_parse_fmtp_config_h264);
404
    } else if (av_strstart(p, "cliprect:", &p)) {
405 406 407
        // could use this if we wanted.
    }

408
    return 0;
409 410 411
}

RTPDynamicProtocolHandler ff_h264_dynamic_handler = {
412
    .enc_name         = "H264",
413
    .codec_type       = AVMEDIA_TYPE_VIDEO,
414
    .codec_id         = AV_CODEC_ID_H264,
415
    .need_parsing     = AVSTREAM_PARSE_FULL,
416
    .priv_data_size   = sizeof(PayloadContext),
417
    .parse_sdp_a_line = parse_h264_sdp_line,
418
    .close            = h264_close_context,
419
    .parse_packet     = h264_handle_packet,
420
};