movenchint.c 15.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * MOV, 3GP, MP4 muxer RTP hinting
 * Copyright (c) 2010 Martin Storsjo
 *
 * 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
 */

#include "movenc.h"
#include "libavutil/intreadwrite.h"
24
#include "internal.h"
25
#include "rtpenc_chain.h"
26
#include "avio_internal.h"
27
#include "rtp.h"
28 29 30 31 32 33 34 35 36 37 38 39

int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
{
    MOVMuxContext *mov  = s->priv_data;
    MOVTrack *track     = &mov->tracks[index];
    MOVTrack *src_track = &mov->tracks[src_index];
    AVStream *src_st    = s->streams[src_index];
    int ret = AVERROR(ENOMEM);

    track->tag = MKTAG('r','t','p',' ');
    track->src_track = src_index;

40
    track->enc = avcodec_alloc_context3(NULL);
41 42 43 44 45
    if (!track->enc)
        goto fail;
    track->enc->codec_type = AVMEDIA_TYPE_DATA;
    track->enc->codec_tag  = track->tag;

46
    ret = ff_rtp_chain_mux_open(&track->rtp_ctx, s, src_st, NULL,
47
                                RTP_MAX_PACKET_SIZE, src_index);
48
    if (ret < 0)
49 50 51 52 53 54 55 56 57 58 59 60 61
        goto fail;

    /* Copy the RTP AVStream timebase back to the hint AVStream */
    track->timescale = track->rtp_ctx->streams[0]->time_base.den;

    /* Mark the hinted track that packets written to it should be
     * sent to this track for hinting. */
    src_track->hint_track = index;
    return 0;
fail:
    av_log(s, AV_LOG_WARNING,
           "Unable to initialize hinting of stream %d\n", src_index);
    av_freep(&track->enc);
62
    /* Set a default timescale, to avoid crashes in av_dump_format */
63 64 65 66
    track->timescale = 90000;
    return ret;
}

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
/**
 * Remove the first sample from the sample queue.
 */
static void sample_queue_pop(HintSampleQueue *queue)
{
    if (queue->len <= 0)
        return;
    if (queue->samples[0].own_data)
        av_free(queue->samples[0].data);
    queue->len--;
    memmove(queue->samples, queue->samples + 1, sizeof(HintSample)*queue->len);
}

/**
 * Empty the sample queue, releasing all memory.
 */
static void sample_queue_free(HintSampleQueue *queue)
{
    int i;
    for (i = 0; i < queue->len; i++)
        if (queue->samples[i].own_data)
            av_free(queue->samples[i].data);
    av_freep(&queue->samples);
90
    queue->len  = 0;
91 92 93 94 95 96 97 98
    queue->size = 0;
}

/**
 * Add a reference to the sample data to the sample queue. The data is
 * not copied. sample_queue_retain should be called before pkt->data
 * is reused/freed.
 */
99 100
static void sample_queue_push(HintSampleQueue *queue, uint8_t *data, int size,
                              int sample)
101 102 103
{
    /* No need to keep track of smaller samples, since describing them
     * with immediates is more efficient. */
104
    if (size <= 14)
105 106
        return;
    if (!queue->samples || queue->len >= queue->size) {
107
        HintSample *samples;
108
        samples = av_realloc_array(queue->samples, queue->size + 10, sizeof(HintSample));
109
        if (!samples)
110
            return;
111
        queue->size += 10;
112
        queue->samples = samples;
113
    }
114 115
    queue->samples[queue->len].data = data;
    queue->samples[queue->len].size = size;
116
    queue->samples[queue->len].sample_number = sample;
117
    queue->samples[queue->len].offset   = 0;
118 119 120 121 122 123 124 125 126 127 128 129 130
    queue->samples[queue->len].own_data = 0;
    queue->len++;
}

/**
 * Make local copies of all referenced sample data in the queue.
 */
static void sample_queue_retain(HintSampleQueue *queue)
{
    int i;
    for (i = 0; i < queue->len; ) {
        HintSample *sample = &queue->samples[i];
        if (!sample->own_data) {
131
            uint8_t *ptr = av_malloc(sample->size);
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
            if (!ptr) {
                /* Unable to allocate memory for this one, remove it */
                memmove(queue->samples + i, queue->samples + i + 1,
                        sizeof(HintSample)*(queue->len - i - 1));
                queue->len--;
                continue;
            }
            memcpy(ptr, sample->data, sample->size);
            sample->data = ptr;
            sample->own_data = 1;
        }
        i++;
    }
}

/**
 * Find matches of needle[n_pos ->] within haystack. If a sufficiently
 * large match is found, matching bytes before n_pos are included
 * in the match, too (within the limits of the arrays).
 *
 * @param haystack buffer that may contain parts of needle
 * @param h_len length of the haystack buffer
 * @param needle buffer containing source data that have been used to
 *               construct haystack
 * @param n_pos start position in needle used for looking for matches
 * @param n_len length of the needle buffer
 * @param match_h_offset_ptr offset of the first matching byte within haystack
 * @param match_n_offset_ptr offset of the first matching byte within needle
 * @param match_len_ptr length of the matched segment
 * @return 0 if a match was found, < 0 if no match was found
 */
static int match_segments(const uint8_t *haystack, int h_len,
                          const uint8_t *needle, int n_pos, int n_len,
                          int *match_h_offset_ptr, int *match_n_offset_ptr,
                          int *match_len_ptr)
{
    int h_pos;
    for (h_pos = 0; h_pos < h_len; h_pos++) {
        int match_len = 0;
        int match_h_pos, match_n_pos;

        /* Check how many bytes match at needle[n_pos] and haystack[h_pos] */
        while (h_pos + match_len < h_len && n_pos + match_len < n_len &&
               needle[n_pos + match_len] == haystack[h_pos + match_len])
            match_len++;
        if (match_len <= 8)
            continue;

        /* If a sufficiently large match was found, try to expand
         * the matched segment backwards. */
        match_h_pos = h_pos;
        match_n_pos = n_pos;
        while (match_n_pos > 0 && match_h_pos > 0 &&
               needle[match_n_pos - 1] == haystack[match_h_pos - 1]) {
            match_n_pos--;
            match_h_pos--;
            match_len++;
        }
        if (match_len <= 14)
            continue;
        *match_h_offset_ptr = match_h_pos;
        *match_n_offset_ptr = match_n_pos;
        *match_len_ptr = match_len;
        return 0;
    }
    return -1;
}

/**
 * Look for segments in samples in the sample queue matching the data
 * in ptr. Samples not matching are removed from the queue. If a match
 * is found, the next time it will look for matches starting from the
 * end of the previous matched segment.
 *
 * @param data data to find matches for in the sample queue
 * @param len length of the data buffer
 * @param queue samples used for looking for matching segments
 * @param pos the offset in data of the matched segment
 * @param match_sample the number of the sample that contained the match
 * @param match_offset the offset of the matched segment within the sample
 * @param match_len the length of the matched segment
 * @return 0 if a match was found, < 0 if no match was found
 */
static int find_sample_match(const uint8_t *data, int len,
                             HintSampleQueue *queue, int *pos,
                             int *match_sample, int *match_offset,
                             int *match_len)
{
    while (queue->len > 0) {
        HintSample *sample = &queue->samples[0];
        /* If looking for matches in a new sample, skip the first 5 bytes,
         * since they often may be modified/removed in the output packet. */
        if (sample->offset == 0 && sample->size > 5)
            sample->offset = 5;

        if (match_segments(data, len, sample->data, sample->offset,
                           sample->size, pos, match_offset, match_len) == 0) {
            *match_sample = sample->sample_number;
            /* Next time, look for matches at this offset, with a little
             * margin to this match. */
            sample->offset = *match_offset + *match_len + 5;
            if (sample->offset + 10 >= sample->size)
                sample_queue_pop(queue); /* Not enough useful data left */
            return 0;
        }

        if (sample->offset < 10 && sample->size > 20) {
            /* No match found from the start of the sample,
             * try from the middle of the sample instead. */
            sample->offset = sample->size/2;
        } else {
            /* No match for this sample, remove it */
            sample_queue_pop(queue);
        }
    }
    return -1;
}

250
static void output_immediate(const uint8_t *data, int size,
251
                             AVIOContext *out, int *entries)
252 253 254 255 256
{
    while (size > 0) {
        int len = size;
        if (len > 14)
            len = 14;
257 258 259
        avio_w8(out, 1); /* immediate constructor */
        avio_w8(out, len); /* amount of valid data */
        avio_write(out, data, len);
260 261 262 263
        data += len;
        size -= len;

        for (; len < 14; len++)
264
            avio_w8(out, 0);
265 266 267 268 269

        (*entries)++;
    }
}

270
static void output_match(AVIOContext *out, int match_sample,
271 272
                         int match_offset, int match_len, int *entries)
{
273 274 275 276 277 278 279
    avio_w8(out, 2); /* sample constructor */
    avio_w8(out, 0); /* track reference */
    avio_wb16(out, match_len);
    avio_wb32(out, match_sample);
    avio_wb32(out, match_offset);
    avio_wb16(out, 1); /* bytes per block */
    avio_wb16(out, 1); /* samples per block */
280 281 282
    (*entries)++;
}

283
static void describe_payload(const uint8_t *data, int size,
284
                             AVIOContext *out, int *entries,
285
                             HintSampleQueue *queue)
286 287
{
    /* Describe the payload using different constructors */
288 289 290 291 292 293 294 295 296 297 298 299
    while (size > 0) {
        int match_sample, match_offset, match_len, pos;
        if (find_sample_match(data, size, queue, &pos, &match_sample,
                              &match_offset, &match_len) < 0)
            break;
        output_immediate(data, pos, out, entries);
        data += pos;
        size -= pos;
        output_match(out, match_sample, match_offset, match_len, entries);
        data += match_len;
        size -= match_len;
    }
300 301 302 303 304 305 306 307 308 309 310 311
    output_immediate(data, size, out, entries);
}

/**
 * Write an RTP hint (that may contain one or more RTP packets)
 * for the packets in data. data contains one or more packets with a
 * BE32 size header.
 *
 * @param out buffer where the hints are written
 * @param data buffer containing RTP packets
 * @param size the size of the data buffer
 * @param trk the MOVTrack for the hint track
312
 * @param dts pointer where the timestamp for the written RTP hint is stored
313 314
 * @return the number of RTP packets in the written hint
 */
315
static int write_hint_packets(AVIOContext *out, const uint8_t *data,
316
                              int size, MOVTrack *trk, int64_t *dts)
317 318 319 320 321
{
    int64_t curpos;
    int64_t count_pos, entries_pos;
    int count = 0, entries;

322
    count_pos = avio_tell(out);
323
    /* RTPsample header */
324 325
    avio_wb16(out, 0); /* packet count */
    avio_wb16(out, 0); /* reserved */
326 327 328 329 330

    while (size > 4) {
        uint32_t packet_len = AV_RB32(data);
        uint16_t seq;
        uint32_t ts;
331
        int32_t  ts_diff;
332 333 334 335 336

        data += 4;
        size -= 4;
        if (packet_len > size || packet_len <= 12)
            break;
337
        if (RTP_PT_IS_RTCP(data[1])) {
338 339 340 341 342 343 344 345 346 347
            /* RTCP packet, just skip */
            data += packet_len;
            size -= packet_len;
            continue;
        }

        if (packet_len > trk->max_packet_size)
            trk->max_packet_size = packet_len;

        seq = AV_RB16(&data[2]);
348
        ts  = AV_RB32(&data[4]);
349 350 351 352 353

        if (trk->prev_rtp_ts == 0)
            trk->prev_rtp_ts = ts;
        /* Unwrap the 32-bit RTP timestamp that wraps around often
         * into a not (as often) wrapping 64-bit timestamp. */
354 355 356 357 358 359
        ts_diff = ts - trk->prev_rtp_ts;
        if (ts_diff > 0) {
            trk->cur_rtp_ts_unwrapped += ts_diff;
            trk->prev_rtp_ts = ts;
            ts_diff = 0;
        }
360 361
        if (*dts == AV_NOPTS_VALUE)
            *dts = trk->cur_rtp_ts_unwrapped;
362 363 364

        count++;
        /* RTPpacket header */
365 366 367
        avio_wb32(out, 0); /* relative_time */
        avio_write(out, data, 2); /* RTP header */
        avio_wb16(out, seq); /* RTPsequenceseed */
368
        avio_wb16(out, ts_diff ? 4 : 0); /* reserved + flags (extra_flag) */
369
        entries_pos = avio_tell(out);
370
        avio_wb16(out, 0); /* entry count */
371 372 373 374 375 376
        if (ts_diff) { /* if extra_flag is set */
            avio_wb32(out, 16); /* extra_information_length */
            avio_wb32(out, 12); /* rtpoffsetTLV box */
            avio_write(out, "rtpo", 4);
            avio_wb32(out, ts_diff);
        }
377 378 379 380 381 382 383

        data += 12;
        size -= 12;
        packet_len -= 12;

        entries = 0;
        /* Write one or more constructors describing the payload data */
384
        describe_payload(data, packet_len, out, &entries, &trk->sample_queue);
385 386 387
        data += packet_len;
        size -= packet_len;

388
        curpos = avio_tell(out);
389
        avio_seek(out, entries_pos, SEEK_SET);
390
        avio_wb16(out, entries);
391
        avio_seek(out, curpos, SEEK_SET);
392 393
    }

394
    curpos = avio_tell(out);
395
    avio_seek(out, count_pos, SEEK_SET);
396
    avio_wb16(out, count);
397
    avio_seek(out, curpos, SEEK_SET);
398 399 400 401
    return count;
}

int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
402 403
                             int track_index, int sample,
                             uint8_t *sample_data, int sample_size)
404 405 406 407 408 409
{
    MOVMuxContext *mov = s->priv_data;
    MOVTrack *trk = &mov->tracks[track_index];
    AVFormatContext *rtp_ctx = trk->rtp_ctx;
    uint8_t *buf = NULL;
    int size;
410
    AVIOContext *hintbuf = NULL;
411 412 413 414 415 416 417 418
    AVPacket hint_pkt;
    int ret = 0, count;

    if (!rtp_ctx)
        return AVERROR(ENOENT);
    if (!rtp_ctx->pb)
        return AVERROR(ENOMEM);

419 420 421 422
    if (sample_data)
        sample_queue_push(&trk->sample_queue, sample_data, sample_size, sample);
    else
        sample_queue_push(&trk->sample_queue, pkt->data, pkt->size, sample);
423

424
    /* Feed the packet to the RTP muxer */
425
    ff_write_chained(rtp_ctx, 0, pkt, s);
426 427 428

    /* Fetch the output from the RTP muxer, open a new output buffer
     * for next time. */
429
    size = avio_close_dyn_buf(rtp_ctx->pb, &buf);
430
    if ((ret = ffio_open_dyn_packet_buf(&rtp_ctx->pb,
431
                                        RTP_MAX_PACKET_SIZE)) < 0)
432 433 434 435 436 437
        goto done;

    if (size <= 0)
        goto done;

    /* Open a buffer for writing the hint */
438
    if ((ret = avio_open_dyn_buf(&hintbuf)) < 0)
439 440 441 442 443 444
        goto done;
    av_init_packet(&hint_pkt);
    count = write_hint_packets(hintbuf, buf, size, trk, &hint_pkt.dts);
    av_freep(&buf);

    /* Write the hint data into the hint track */
445
    hint_pkt.size = size = avio_close_dyn_buf(hintbuf, &buf);
446 447 448 449 450 451 452 453 454
    hint_pkt.data = buf;
    hint_pkt.pts  = hint_pkt.dts;
    hint_pkt.stream_index = track_index;
    if (pkt->flags & AV_PKT_FLAG_KEY)
        hint_pkt.flags |= AV_PKT_FLAG_KEY;
    if (count > 0)
        ff_mov_write_packet(s, &hint_pkt);
done:
    av_free(buf);
455
    sample_queue_retain(&trk->sample_queue);
456 457 458
    return ret;
}

459 460 461
void ff_mov_close_hinting(MOVTrack *track)
{
    AVFormatContext *rtp_ctx = track->rtp_ctx;
462 463 464
    uint8_t *ptr;

    av_freep(&track->enc);
465
    sample_queue_free(&track->sample_queue);
466 467 468 469
    if (!rtp_ctx)
        return;
    if (rtp_ctx->pb) {
        av_write_trailer(rtp_ctx);
470
        avio_close_dyn_buf(rtp_ctx->pb, &ptr);
471 472
        av_free(ptr);
    }
473
    avformat_free_context(rtp_ctx);
474
}