← Back to branch summary

~ubuntu-branches/ubuntu/raring/libav/raring-security

« back to all changes in this revision

Viewing changes to .pc/post-0.7.1/0019-lavf-fix-segfault-in-av_open_input_stream.patch/libavformat/utils.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2011-10-01 00:22:07 UTC
  • mfrom: (1.3.8 sid)
  • Revision ID: package-import@ubuntu.com-20111001002207-tnxz39i0rwr5ufy9
Tags: 4:0.7.2-1ubuntu1
* Merge from debian, remaining changes:
  - don't build against libfaad, libdirac, librtmp and libopenjpeg,
    lame, xvid, x264  (all in universe)
  - not installing into multiarch directories
* This new upstream release has basically merged in all 70 patches that
  are present in 4:0.7.1-7ubuntu2, plus some additional, similarily
  focused ones.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/post-0.7.1/0019-lavf-fix-segfault-in-av_open_input_stream.patch/libavformat/utils.c
1
 
/*
2
 
 * various utility functions for use within Libav
3
 
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
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
 
/* #define DEBUG */
23
 
 
24
 
#include "avformat.h"
25
 
#include "avio_internal.h"
26
 
#include "internal.h"
27
 
#include "libavcodec/internal.h"
28
 
#include "libavutil/opt.h"
29
 
#include "libavutil/dict.h"
30
 
#include "libavutil/pixdesc.h"
31
 
#include "metadata.h"
32
 
#include "id3v2.h"
33
 
#include "libavutil/avstring.h"
34
 
#include "riff.h"
35
 
#include "audiointerleave.h"
36
 
#include "url.h"
37
 
#include <sys/time.h>
38
 
#include <time.h>
39
 
#include <strings.h>
40
 
#include <stdarg.h>
41
 
#if CONFIG_NETWORK
42
 
#include "network.h"
43
 
#endif
44
 
 
45
 
#undef NDEBUG
46
 
#include <assert.h>
47
 
 
48
 
/**
49
 
 * @file
50
 
 * various utility functions for use within Libav
51
 
 */
52
 
 
53
 
unsigned avformat_version(void)
54
 
{
55
 
    return LIBAVFORMAT_VERSION_INT;
56
 
}
57
 
 
58
 
const char *avformat_configuration(void)
59
 
{
60
 
    return LIBAV_CONFIGURATION;
61
 
}
62
 
 
63
 
const char *avformat_license(void)
64
 
{
65
 
#define LICENSE_PREFIX "libavformat license: "
66
 
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
67
 
}
68
 
 
69
 
/* fraction handling */
70
 
 
71
 
/**
72
 
 * f = val + (num / den) + 0.5.
73
 
 *
74
 
 * 'num' is normalized so that it is such as 0 <= num < den.
75
 
 *
76
 
 * @param f fractional number
77
 
 * @param val integer value
78
 
 * @param num must be >= 0
79
 
 * @param den must be >= 1
80
 
 */
81
 
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
82
 
{
83
 
    num += (den >> 1);
84
 
    if (num >= den) {
85
 
        val += num / den;
86
 
        num = num % den;
87
 
    }
88
 
    f->val = val;
89
 
    f->num = num;
90
 
    f->den = den;
91
 
}
92
 
 
93
 
/**
94
 
 * Fractional addition to f: f = f + (incr / f->den).
95
 
 *
96
 
 * @param f fractional number
97
 
 * @param incr increment, can be positive or negative
98
 
 */
99
 
static void av_frac_add(AVFrac *f, int64_t incr)
100
 
{
101
 
    int64_t num, den;
102
 
 
103
 
    num = f->num + incr;
104
 
    den = f->den;
105
 
    if (num < 0) {
106
 
        f->val += num / den;
107
 
        num = num % den;
108
 
        if (num < 0) {
109
 
            num += den;
110
 
            f->val--;
111
 
        }
112
 
    } else if (num >= den) {
113
 
        f->val += num / den;
114
 
        num = num % den;
115
 
    }
116
 
    f->num = num;
117
 
}
118
 
 
119
 
/** head of registered input format linked list */
120
 
static AVInputFormat *first_iformat = NULL;
121
 
/** head of registered output format linked list */
122
 
static AVOutputFormat *first_oformat = NULL;
123
 
 
124
 
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
125
 
{
126
 
    if(f) return f->next;
127
 
    else  return first_iformat;
128
 
}
129
 
 
130
 
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
131
 
{
132
 
    if(f) return f->next;
133
 
    else  return first_oformat;
134
 
}
135
 
 
136
 
void av_register_input_format(AVInputFormat *format)
137
 
{
138
 
    AVInputFormat **p;
139
 
    p = &first_iformat;
140
 
    while (*p != NULL) p = &(*p)->next;
141
 
    *p = format;
142
 
    format->next = NULL;
143
 
}
144
 
 
145
 
void av_register_output_format(AVOutputFormat *format)
146
 
{
147
 
    AVOutputFormat **p;
148
 
    p = &first_oformat;
149
 
    while (*p != NULL) p = &(*p)->next;
150
 
    *p = format;
151
 
    format->next = NULL;
152
 
}
153
 
 
154
 
int av_match_ext(const char *filename, const char *extensions)
155
 
{
156
 
    const char *ext, *p;
157
 
    char ext1[32], *q;
158
 
 
159
 
    if(!filename)
160
 
        return 0;
161
 
 
162
 
    ext = strrchr(filename, '.');
163
 
    if (ext) {
164
 
        ext++;
165
 
        p = extensions;
166
 
        for(;;) {
167
 
            q = ext1;
168
 
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
169
 
                *q++ = *p++;
170
 
            *q = '\0';
171
 
            if (!strcasecmp(ext1, ext))
172
 
                return 1;
173
 
            if (*p == '\0')
174
 
                break;
175
 
            p++;
176
 
        }
177
 
    }
178
 
    return 0;
179
 
}
180
 
 
181
 
static int match_format(const char *name, const char *names)
182
 
{
183
 
    const char *p;
184
 
    int len, namelen;
185
 
 
186
 
    if (!name || !names)
187
 
        return 0;
188
 
 
189
 
    namelen = strlen(name);
190
 
    while ((p = strchr(names, ','))) {
191
 
        len = FFMAX(p - names, namelen);
192
 
        if (!strncasecmp(name, names, len))
193
 
            return 1;
194
 
        names = p+1;
195
 
    }
196
 
    return !strcasecmp(name, names);
197
 
}
198
 
 
199
 
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
200
 
                                const char *mime_type)
201
 
{
202
 
    AVOutputFormat *fmt = NULL, *fmt_found;
203
 
    int score_max, score;
204
 
 
205
 
    /* specific test for image sequences */
206
 
#if CONFIG_IMAGE2_MUXER
207
 
    if (!short_name && filename &&
208
 
        av_filename_number_test(filename) &&
209
 
        ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
210
 
        return av_guess_format("image2", NULL, NULL);
211
 
    }
212
 
#endif
213
 
    /* Find the proper file type. */
214
 
    fmt_found = NULL;
215
 
    score_max = 0;
216
 
    while ((fmt = av_oformat_next(fmt))) {
217
 
        score = 0;
218
 
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219
 
            score += 100;
220
 
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
221
 
            score += 10;
222
 
        if (filename && fmt->extensions &&
223
 
            av_match_ext(filename, fmt->extensions)) {
224
 
            score += 5;
225
 
        }
226
 
        if (score > score_max) {
227
 
            score_max = score;
228
 
            fmt_found = fmt;
229
 
        }
230
 
    }
231
 
    return fmt_found;
232
 
}
233
 
 
234
 
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
235
 
                            const char *filename, const char *mime_type, enum AVMediaType type){
236
 
    if(type == AVMEDIA_TYPE_VIDEO){
237
 
        enum CodecID codec_id= CODEC_ID_NONE;
238
 
 
239
 
#if CONFIG_IMAGE2_MUXER
240
 
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
241
 
            codec_id= ff_guess_image2_codec(filename);
242
 
        }
243
 
#endif
244
 
        if(codec_id == CODEC_ID_NONE)
245
 
            codec_id= fmt->video_codec;
246
 
        return codec_id;
247
 
    }else if(type == AVMEDIA_TYPE_AUDIO)
248
 
        return fmt->audio_codec;
249
 
    else if (type == AVMEDIA_TYPE_SUBTITLE)
250
 
        return fmt->subtitle_codec;
251
 
    else
252
 
        return CODEC_ID_NONE;
253
 
}
254
 
 
255
 
AVInputFormat *av_find_input_format(const char *short_name)
256
 
{
257
 
    AVInputFormat *fmt = NULL;
258
 
    while ((fmt = av_iformat_next(fmt))) {
259
 
        if (match_format(short_name, fmt->name))
260
 
            return fmt;
261
 
    }
262
 
    return NULL;
263
 
}
264
 
 
265
 
 
266
 
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
267
 
{
268
 
    int ret= av_new_packet(pkt, size);
269
 
 
270
 
    if(ret<0)
271
 
        return ret;
272
 
 
273
 
    pkt->pos= avio_tell(s);
274
 
 
275
 
    ret= avio_read(s, pkt->data, size);
276
 
    if(ret<=0)
277
 
        av_free_packet(pkt);
278
 
    else
279
 
        av_shrink_packet(pkt, ret);
280
 
 
281
 
    return ret;
282
 
}
283
 
 
284
 
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
285
 
{
286
 
    int ret;
287
 
    int old_size;
288
 
    if (!pkt->size)
289
 
        return av_get_packet(s, pkt, size);
290
 
    old_size = pkt->size;
291
 
    ret = av_grow_packet(pkt, size);
292
 
    if (ret < 0)
293
 
        return ret;
294
 
    ret = avio_read(s, pkt->data + old_size, size);
295
 
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
296
 
    return ret;
297
 
}
298
 
 
299
 
 
300
 
int av_filename_number_test(const char *filename)
301
 
{
302
 
    char buf[1024];
303
 
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
304
 
}
305
 
 
306
 
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
307
 
{
308
 
    AVProbeData lpd = *pd;
309
 
    AVInputFormat *fmt1 = NULL, *fmt;
310
 
    int score, id3 = 0;
311
 
 
312
 
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
313
 
        int id3len = ff_id3v2_tag_len(lpd.buf);
314
 
        if (lpd.buf_size > id3len + 16) {
315
 
            lpd.buf += id3len;
316
 
            lpd.buf_size -= id3len;
317
 
        }
318
 
        id3 = 1;
319
 
    }
320
 
 
321
 
    fmt = NULL;
322
 
    while ((fmt1 = av_iformat_next(fmt1))) {
323
 
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
324
 
            continue;
325
 
        score = 0;
326
 
        if (fmt1->read_probe) {
327
 
            score = fmt1->read_probe(&lpd);
328
 
        } else if (fmt1->extensions) {
329
 
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
330
 
                score = 50;
331
 
            }
332
 
        }
333
 
        if (score > *score_max) {
334
 
            *score_max = score;
335
 
            fmt = fmt1;
336
 
        }else if (score == *score_max)
337
 
            fmt = NULL;
338
 
    }
339
 
 
340
 
    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
341
 
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
342
 
        while ((fmt = av_iformat_next(fmt)))
343
 
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
344
 
                *score_max = AVPROBE_SCORE_MAX/4;
345
 
                break;
346
 
            }
347
 
    }
348
 
 
349
 
    return fmt;
350
 
}
351
 
 
352
 
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
353
 
    int score=0;
354
 
    return av_probe_input_format2(pd, is_opened, &score);
355
 
}
356
 
 
357
 
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
358
 
{
359
 
    static const struct {
360
 
        const char *name; enum CodecID id; enum AVMediaType type;
361
 
    } fmt_id_type[] = {
362
 
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
363
 
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
364
 
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
365
 
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
366
 
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
367
 
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
368
 
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
369
 
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
370
 
        { 0 }
371
 
    };
372
 
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
373
 
 
374
 
    if (fmt) {
375
 
        int i;
376
 
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
377
 
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
378
 
        for (i = 0; fmt_id_type[i].name; i++) {
379
 
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
380
 
                st->codec->codec_id   = fmt_id_type[i].id;
381
 
                st->codec->codec_type = fmt_id_type[i].type;
382
 
                break;
383
 
            }
384
 
        }
385
 
    }
386
 
    return !!fmt;
387
 
}
388
 
 
389
 
/************************************************************/
390
 
/* input media file */
391
 
 
392
 
#if FF_API_FORMAT_PARAMETERS
393
 
static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
394
 
{
395
 
    char buf[1024];
396
 
    AVDictionary *opts = NULL;
397
 
 
398
 
    if (!ap)
399
 
        return NULL;
400
 
 
401
 
    if (ap->time_base.num) {
402
 
        snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
403
 
        av_dict_set(&opts, "framerate", buf, 0);
404
 
    }
405
 
    if (ap->sample_rate) {
406
 
        snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
407
 
        av_dict_set(&opts, "sample_rate", buf, 0);
408
 
    }
409
 
    if (ap->channels) {
410
 
        snprintf(buf, sizeof(buf), "%d", ap->channels);
411
 
        av_dict_set(&opts, "channels", buf, 0);
412
 
    }
413
 
    if (ap->width || ap->height) {
414
 
        snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
415
 
        av_dict_set(&opts, "video_size", buf, 0);
416
 
    }
417
 
    if (ap->pix_fmt != PIX_FMT_NONE) {
418
 
        av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
419
 
    }
420
 
    if (ap->channel) {
421
 
        snprintf(buf, sizeof(buf), "%d", ap->channel);
422
 
        av_dict_set(&opts, "channel", buf, 0);
423
 
    }
424
 
    if (ap->standard) {
425
 
        av_dict_set(&opts, "standard", ap->standard, 0);
426
 
    }
427
 
    if (ap->mpeg2ts_compute_pcr) {
428
 
        av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
429
 
    }
430
 
    if (ap->initial_pause) {
431
 
        av_dict_set(&opts, "initial_pause", "1", 0);
432
 
    }
433
 
    return opts;
434
 
}
435
 
 
436
 
/**
437
 
 * Open a media file from an IO stream. 'fmt' must be specified.
438
 
 */
439
 
int av_open_input_stream(AVFormatContext **ic_ptr,
440
 
                         AVIOContext *pb, const char *filename,
441
 
                         AVInputFormat *fmt, AVFormatParameters *ap)
442
 
{
443
 
    int err;
444
 
    AVDictionary *opts;
445
 
    AVFormatContext *ic;
446
 
    AVFormatParameters default_ap;
447
 
 
448
 
    if(!ap){
449
 
        ap=&default_ap;
450
 
        memset(ap, 0, sizeof(default_ap));
451
 
    }
452
 
    opts = convert_format_parameters(ap);
453
 
 
454
 
    if(!ap->prealloced_context)
455
 
        ic = avformat_alloc_context();
456
 
    else
457
 
        ic = *ic_ptr;
458
 
    if (!ic) {
459
 
        err = AVERROR(ENOMEM);
460
 
        goto fail;
461
 
    }
462
 
    if (pb && fmt && fmt->flags & AVFMT_NOFILE)
463
 
        av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
464
 
                                   "will be ignored with AVFMT_NOFILE format.\n");
465
 
    else
466
 
        ic->pb = pb;
467
 
 
468
 
    err = avformat_open_input(&ic, filename, fmt, &opts);
469
 
    ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
470
 
 
471
 
    *ic_ptr = ic;
472
 
fail:
473
 
    av_dict_free(&opts);
474
 
    return err;
475
 
}
476
 
#endif
477
 
 
478
 
/** size of probe buffer, for guessing file type from file contents */
479
 
#define PROBE_BUF_MIN 2048
480
 
#define PROBE_BUF_MAX (1<<20)
481
 
 
482
 
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
483
 
                          const char *filename, void *logctx,
484
 
                          unsigned int offset, unsigned int max_probe_size)
485
 
{
486
 
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
487
 
    unsigned char *buf = NULL;
488
 
    int ret = 0, probe_size;
489
 
 
490
 
    if (!max_probe_size) {
491
 
        max_probe_size = PROBE_BUF_MAX;
492
 
    } else if (max_probe_size > PROBE_BUF_MAX) {
493
 
        max_probe_size = PROBE_BUF_MAX;
494
 
    } else if (max_probe_size < PROBE_BUF_MIN) {
495
 
        return AVERROR(EINVAL);
496
 
    }
497
 
 
498
 
    if (offset >= max_probe_size) {
499
 
        return AVERROR(EINVAL);
500
 
    }
501
 
 
502
 
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
503
 
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
504
 
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
505
 
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
506
 
 
507
 
        if (probe_size < offset) {
508
 
            continue;
509
 
        }
510
 
 
511
 
        /* read probe data */
512
 
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
513
 
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
514
 
            /* fail if error was not end of file, otherwise, lower score */
515
 
            if (ret != AVERROR_EOF) {
516
 
                av_free(buf);
517
 
                return ret;
518
 
            }
519
 
            score = 0;
520
 
            ret = 0;            /* error was end of file, nothing read */
521
 
        }
522
 
        pd.buf_size += ret;
523
 
        pd.buf = &buf[offset];
524
 
 
525
 
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
526
 
 
527
 
        /* guess file format */
528
 
        *fmt = av_probe_input_format2(&pd, 1, &score);
529
 
        if(*fmt){
530
 
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
531
 
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
532
 
            }else
533
 
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
534
 
        }
535
 
    }
536
 
 
537
 
    if (!*fmt) {
538
 
        av_free(buf);
539
 
        return AVERROR_INVALIDDATA;
540
 
    }
541
 
 
542
 
    /* rewind. reuse probe buffer to avoid seeking */
543
 
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
544
 
        av_free(buf);
545
 
 
546
 
    return ret;
547
 
}
548
 
 
549
 
#if FF_API_FORMAT_PARAMETERS
550
 
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
551
 
                       AVInputFormat *fmt,
552
 
                       int buf_size,
553
 
                       AVFormatParameters *ap)
554
 
{
555
 
    int err;
556
 
    AVDictionary *opts = convert_format_parameters(ap);
557
 
 
558
 
    if (!ap || !ap->prealloced_context)
559
 
        *ic_ptr = NULL;
560
 
 
561
 
    err = avformat_open_input(ic_ptr, filename, fmt, &opts);
562
 
 
563
 
    av_dict_free(&opts);
564
 
    return err;
565
 
}
566
 
#endif
567
 
 
568
 
/* open input file and probe the format if necessary */
569
 
static int init_input(AVFormatContext *s, const char *filename)
570
 
{
571
 
    int ret;
572
 
    AVProbeData pd = {filename, NULL, 0};
573
 
 
574
 
    if (s->pb) {
575
 
        s->flags |= AVFMT_FLAG_CUSTOM_IO;
576
 
        if (!s->iformat)
577
 
            return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
578
 
        else if (s->iformat->flags & AVFMT_NOFILE)
579
 
            return AVERROR(EINVAL);
580
 
        return 0;
581
 
    }
582
 
 
583
 
    if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
584
 
        (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
585
 
        return 0;
586
 
 
587
 
    if ((ret = avio_open(&s->pb, filename, AVIO_FLAG_READ)) < 0)
588
 
       return ret;
589
 
    if (s->iformat)
590
 
        return 0;
591
 
    return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
592
 
}
593
 
 
594
 
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
595
 
{
596
 
    AVFormatContext *s = *ps;
597
 
    int ret = 0;
598
 
    AVFormatParameters ap = { 0 };
599
 
    AVDictionary *tmp = NULL;
600
 
 
601
 
    if (!s && !(s = avformat_alloc_context()))
602
 
        return AVERROR(ENOMEM);
603
 
    if (fmt)
604
 
        s->iformat = fmt;
605
 
 
606
 
    if (options)
607
 
        av_dict_copy(&tmp, *options, 0);
608
 
 
609
 
    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
610
 
        goto fail;
611
 
 
612
 
    if ((ret = init_input(s, filename)) < 0)
613
 
        goto fail;
614
 
 
615
 
    /* check filename in case an image number is expected */
616
 
    if (s->iformat->flags & AVFMT_NEEDNUMBER) {
617
 
        if (!av_filename_number_test(filename)) {
618
 
            ret = AVERROR(EINVAL);
619
 
            goto fail;
620
 
        }
621
 
    }
622
 
 
623
 
    s->duration = s->start_time = AV_NOPTS_VALUE;
624
 
    av_strlcpy(s->filename, filename, sizeof(s->filename));
625
 
 
626
 
    /* allocate private data */
627
 
    if (s->iformat->priv_data_size > 0) {
628
 
        if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
629
 
            ret = AVERROR(ENOMEM);
630
 
            goto fail;
631
 
        }
632
 
        if (s->iformat->priv_class) {
633
 
            *(const AVClass**)s->priv_data = s->iformat->priv_class;
634
 
            av_opt_set_defaults(s->priv_data);
635
 
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
636
 
                goto fail;
637
 
        }
638
 
    }
639
 
 
640
 
    /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
641
 
    if (s->pb)
642
 
        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
643
 
 
644
 
    if (s->iformat->read_header)
645
 
        if ((ret = s->iformat->read_header(s, &ap)) < 0)
646
 
            goto fail;
647
 
 
648
 
    if (s->pb && !s->data_offset)
649
 
        s->data_offset = avio_tell(s->pb);
650
 
 
651
 
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
652
 
 
653
 
    if (options) {
654
 
        av_dict_free(options);
655
 
        *options = tmp;
656
 
    }
657
 
    *ps = s;
658
 
    return 0;
659
 
 
660
 
fail:
661
 
    av_dict_free(&tmp);
662
 
    if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
663
 
        avio_close(s->pb);
664
 
    avformat_free_context(s);
665
 
    *ps = NULL;
666
 
    return ret;
667
 
}
668
 
 
669
 
/*******************************************************/
670
 
 
671
 
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
672
 
                               AVPacketList **plast_pktl){
673
 
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
674
 
    if (!pktl)
675
 
        return NULL;
676
 
 
677
 
    if (*packet_buffer)
678
 
        (*plast_pktl)->next = pktl;
679
 
    else
680
 
        *packet_buffer = pktl;
681
 
 
682
 
    /* add the packet in the buffered packet list */
683
 
    *plast_pktl = pktl;
684
 
    pktl->pkt= *pkt;
685
 
    return &pktl->pkt;
686
 
}
687
 
 
688
 
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
689
 
{
690
 
    int ret, i;
691
 
    AVStream *st;
692
 
 
693
 
    for(;;){
694
 
        AVPacketList *pktl = s->raw_packet_buffer;
695
 
 
696
 
        if (pktl) {
697
 
            *pkt = pktl->pkt;
698
 
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
699
 
               !s->streams[pkt->stream_index]->probe_packets ||
700
 
               s->raw_packet_buffer_remaining_size < pkt->size){
701
 
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
702
 
                av_freep(&pd->buf);
703
 
                pd->buf_size = 0;
704
 
                s->raw_packet_buffer = pktl->next;
705
 
                s->raw_packet_buffer_remaining_size += pkt->size;
706
 
                av_free(pktl);
707
 
                return 0;
708
 
            }
709
 
        }
710
 
 
711
 
        av_init_packet(pkt);
712
 
        ret= s->iformat->read_packet(s, pkt);
713
 
        if (ret < 0) {
714
 
            if (!pktl || ret == AVERROR(EAGAIN))
715
 
                return ret;
716
 
            for (i = 0; i < s->nb_streams; i++)
717
 
                s->streams[i]->probe_packets = 0;
718
 
            continue;
719
 
        }
720
 
        st= s->streams[pkt->stream_index];
721
 
 
722
 
        switch(st->codec->codec_type){
723
 
        case AVMEDIA_TYPE_VIDEO:
724
 
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
725
 
            break;
726
 
        case AVMEDIA_TYPE_AUDIO:
727
 
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
728
 
            break;
729
 
        case AVMEDIA_TYPE_SUBTITLE:
730
 
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
731
 
            break;
732
 
        }
733
 
 
734
 
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
735
 
                     !st->probe_packets))
736
 
            return ret;
737
 
 
738
 
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
739
 
        s->raw_packet_buffer_remaining_size -= pkt->size;
740
 
 
741
 
        if(st->codec->codec_id == CODEC_ID_PROBE){
742
 
            AVProbeData *pd = &st->probe_data;
743
 
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
744
 
            --st->probe_packets;
745
 
 
746
 
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
747
 
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
748
 
            pd->buf_size += pkt->size;
749
 
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
750
 
 
751
 
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
752
 
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
753
 
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
754
 
                if(st->codec->codec_id != CODEC_ID_PROBE){
755
 
                    pd->buf_size=0;
756
 
                    av_freep(&pd->buf);
757
 
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
758
 
                }
759
 
            }
760
 
        }
761
 
    }
762
 
}
763
 
 
764
 
/**********************************************************/
765
 
 
766
 
/**
767
 
 * Get the number of samples of an audio frame. Return -1 on error.
768
 
 */
769
 
static int get_audio_frame_size(AVCodecContext *enc, int size)
770
 
{
771
 
    int frame_size;
772
 
 
773
 
    if(enc->codec_id == CODEC_ID_VORBIS)
774
 
        return -1;
775
 
 
776
 
    if (enc->frame_size <= 1) {
777
 
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
778
 
 
779
 
        if (bits_per_sample) {
780
 
            if (enc->channels == 0)
781
 
                return -1;
782
 
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
783
 
        } else {
784
 
            /* used for example by ADPCM codecs */
785
 
            if (enc->bit_rate == 0)
786
 
                return -1;
787
 
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
788
 
        }
789
 
    } else {
790
 
        frame_size = enc->frame_size;
791
 
    }
792
 
    return frame_size;
793
 
}
794
 
 
795
 
 
796
 
/**
797
 
 * Return the frame duration in seconds. Return 0 if not available.
798
 
 */
799
 
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
800
 
                                   AVCodecParserContext *pc, AVPacket *pkt)
801
 
{
802
 
    int frame_size;
803
 
 
804
 
    *pnum = 0;
805
 
    *pden = 0;
806
 
    switch(st->codec->codec_type) {
807
 
    case AVMEDIA_TYPE_VIDEO:
808
 
        if(st->time_base.num*1000LL > st->time_base.den){
809
 
            *pnum = st->time_base.num;
810
 
            *pden = st->time_base.den;
811
 
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
812
 
            *pnum = st->codec->time_base.num;
813
 
            *pden = st->codec->time_base.den;
814
 
            if (pc && pc->repeat_pict) {
815
 
                *pnum = (*pnum) * (1 + pc->repeat_pict);
816
 
            }
817
 
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
818
 
            //Thus if we have no parser in such case leave duration undefined.
819
 
            if(st->codec->ticks_per_frame>1 && !pc){
820
 
                *pnum = *pden = 0;
821
 
            }
822
 
        }
823
 
        break;
824
 
    case AVMEDIA_TYPE_AUDIO:
825
 
        frame_size = get_audio_frame_size(st->codec, pkt->size);
826
 
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
827
 
            break;
828
 
        *pnum = frame_size;
829
 
        *pden = st->codec->sample_rate;
830
 
        break;
831
 
    default:
832
 
        break;
833
 
    }
834
 
}
835
 
 
836
 
static int is_intra_only(AVCodecContext *enc){
837
 
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
838
 
        return 1;
839
 
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
840
 
        switch(enc->codec_id){
841
 
        case CODEC_ID_MJPEG:
842
 
        case CODEC_ID_MJPEGB:
843
 
        case CODEC_ID_LJPEG:
844
 
        case CODEC_ID_RAWVIDEO:
845
 
        case CODEC_ID_DVVIDEO:
846
 
        case CODEC_ID_HUFFYUV:
847
 
        case CODEC_ID_FFVHUFF:
848
 
        case CODEC_ID_ASV1:
849
 
        case CODEC_ID_ASV2:
850
 
        case CODEC_ID_VCR1:
851
 
        case CODEC_ID_DNXHD:
852
 
        case CODEC_ID_JPEG2000:
853
 
            return 1;
854
 
        default: break;
855
 
        }
856
 
    }
857
 
    return 0;
858
 
}
859
 
 
860
 
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
861
 
                                      int64_t dts, int64_t pts)
862
 
{
863
 
    AVStream *st= s->streams[stream_index];
864
 
    AVPacketList *pktl= s->packet_buffer;
865
 
 
866
 
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
867
 
        return;
868
 
 
869
 
    st->first_dts= dts - st->cur_dts;
870
 
    st->cur_dts= dts;
871
 
 
872
 
    for(; pktl; pktl= pktl->next){
873
 
        if(pktl->pkt.stream_index != stream_index)
874
 
            continue;
875
 
        //FIXME think more about this check
876
 
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
877
 
            pktl->pkt.pts += st->first_dts;
878
 
 
879
 
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
880
 
            pktl->pkt.dts += st->first_dts;
881
 
 
882
 
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
883
 
            st->start_time= pktl->pkt.pts;
884
 
    }
885
 
    if (st->start_time == AV_NOPTS_VALUE)
886
 
        st->start_time = pts;
887
 
}
888
 
 
889
 
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
890
 
{
891
 
    AVPacketList *pktl= s->packet_buffer;
892
 
    int64_t cur_dts= 0;
893
 
 
894
 
    if(st->first_dts != AV_NOPTS_VALUE){
895
 
        cur_dts= st->first_dts;
896
 
        for(; pktl; pktl= pktl->next){
897
 
            if(pktl->pkt.stream_index == pkt->stream_index){
898
 
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
899
 
                    break;
900
 
                cur_dts -= pkt->duration;
901
 
            }
902
 
        }
903
 
        pktl= s->packet_buffer;
904
 
        st->first_dts = cur_dts;
905
 
    }else if(st->cur_dts)
906
 
        return;
907
 
 
908
 
    for(; pktl; pktl= pktl->next){
909
 
        if(pktl->pkt.stream_index != pkt->stream_index)
910
 
            continue;
911
 
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
912
 
           && !pktl->pkt.duration){
913
 
            pktl->pkt.dts= cur_dts;
914
 
            if(!st->codec->has_b_frames)
915
 
                pktl->pkt.pts= cur_dts;
916
 
            cur_dts += pkt->duration;
917
 
            pktl->pkt.duration= pkt->duration;
918
 
        }else
919
 
            break;
920
 
    }
921
 
    if(st->first_dts == AV_NOPTS_VALUE)
922
 
        st->cur_dts= cur_dts;
923
 
}
924
 
 
925
 
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
926
 
                               AVCodecParserContext *pc, AVPacket *pkt)
927
 
{
928
 
    int num, den, presentation_delayed, delay, i;
929
 
    int64_t offset;
930
 
 
931
 
    if (s->flags & AVFMT_FLAG_NOFILLIN)
932
 
        return;
933
 
 
934
 
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
935
 
        pkt->dts= AV_NOPTS_VALUE;
936
 
 
937
 
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
938
 
        //FIXME Set low_delay = 0 when has_b_frames = 1
939
 
        st->codec->has_b_frames = 1;
940
 
 
941
 
    /* do we have a video B-frame ? */
942
 
    delay= st->codec->has_b_frames;
943
 
    presentation_delayed = 0;
944
 
 
945
 
    // ignore delay caused by frame threading so that the mpeg2-without-dts
946
 
    // warning will not trigger
947
 
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
948
 
        delay -= st->codec->thread_count-1;
949
 
 
950
 
    /* XXX: need has_b_frame, but cannot get it if the codec is
951
 
        not initialized */
952
 
    if (delay &&
953
 
        pc && pc->pict_type != AV_PICTURE_TYPE_B)
954
 
        presentation_delayed = 1;
955
 
 
956
 
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
957
 
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
958
 
        pkt->dts -= 1LL<<st->pts_wrap_bits;
959
 
    }
960
 
 
961
 
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
962
 
    // we take the conservative approach and discard both
963
 
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
964
 
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
965
 
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
966
 
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
967
 
    }
968
 
 
969
 
    if (pkt->duration == 0) {
970
 
        compute_frame_duration(&num, &den, st, pc, pkt);
971
 
        if (den && num) {
972
 
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
973
 
 
974
 
            if(pkt->duration != 0 && s->packet_buffer)
975
 
                update_initial_durations(s, st, pkt);
976
 
        }
977
 
    }
978
 
 
979
 
    /* correct timestamps with byte offset if demuxers only have timestamps
980
 
       on packet boundaries */
981
 
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
982
 
        /* this will estimate bitrate based on this frame's duration and size */
983
 
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
984
 
        if(pkt->pts != AV_NOPTS_VALUE)
985
 
            pkt->pts += offset;
986
 
        if(pkt->dts != AV_NOPTS_VALUE)
987
 
            pkt->dts += offset;
988
 
    }
989
 
 
990
 
    if (pc && pc->dts_sync_point >= 0) {
991
 
        // we have synchronization info from the parser
992
 
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
993
 
        if (den > 0) {
994
 
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
995
 
            if (pkt->dts != AV_NOPTS_VALUE) {
996
 
                // got DTS from the stream, update reference timestamp
997
 
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
998
 
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
999
 
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
1000
 
                // compute DTS based on reference timestamp
1001
 
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1002
 
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1003
 
            }
1004
 
            if (pc->dts_sync_point > 0)
1005
 
                st->reference_dts = pkt->dts; // new reference
1006
 
        }
1007
 
    }
1008
 
 
1009
 
    /* This may be redundant, but it should not hurt. */
1010
 
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1011
 
        presentation_delayed = 1;
1012
 
 
1013
 
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
1014
 
    /* interpolate PTS and DTS if they are not present */
1015
 
    //We skip H264 currently because delay and has_b_frames are not reliably set
1016
 
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1017
 
        if (presentation_delayed) {
1018
 
            /* DTS = decompression timestamp */
1019
 
            /* PTS = presentation timestamp */
1020
 
            if (pkt->dts == AV_NOPTS_VALUE)
1021
 
                pkt->dts = st->last_IP_pts;
1022
 
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1023
 
            if (pkt->dts == AV_NOPTS_VALUE)
1024
 
                pkt->dts = st->cur_dts;
1025
 
 
1026
 
            /* this is tricky: the dts must be incremented by the duration
1027
 
            of the frame we are displaying, i.e. the last I- or P-frame */
1028
 
            if (st->last_IP_duration == 0)
1029
 
                st->last_IP_duration = pkt->duration;
1030
 
            if(pkt->dts != AV_NOPTS_VALUE)
1031
 
                st->cur_dts = pkt->dts + st->last_IP_duration;
1032
 
            st->last_IP_duration  = pkt->duration;
1033
 
            st->last_IP_pts= pkt->pts;
1034
 
            /* cannot compute PTS if not present (we can compute it only
1035
 
            by knowing the future */
1036
 
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1037
 
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1038
 
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1039
 
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1040
 
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1041
 
                    pkt->pts += pkt->duration;
1042
 
    //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
1043
 
                }
1044
 
            }
1045
 
 
1046
 
            /* presentation is not delayed : PTS and DTS are the same */
1047
 
            if(pkt->pts == AV_NOPTS_VALUE)
1048
 
                pkt->pts = pkt->dts;
1049
 
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1050
 
            if(pkt->pts == AV_NOPTS_VALUE)
1051
 
                pkt->pts = st->cur_dts;
1052
 
            pkt->dts = pkt->pts;
1053
 
            if(pkt->pts != AV_NOPTS_VALUE)
1054
 
                st->cur_dts = pkt->pts + pkt->duration;
1055
 
        }
1056
 
    }
1057
 
 
1058
 
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1059
 
        st->pts_buffer[0]= pkt->pts;
1060
 
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1061
 
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1062
 
        if(pkt->dts == AV_NOPTS_VALUE)
1063
 
            pkt->dts= st->pts_buffer[0];
1064
 
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1065
 
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1066
 
        }
1067
 
        if(pkt->dts > st->cur_dts)
1068
 
            st->cur_dts = pkt->dts;
1069
 
    }
1070
 
 
1071
 
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1072
 
 
1073
 
    /* update flags */
1074
 
    if(is_intra_only(st->codec))
1075
 
        pkt->flags |= AV_PKT_FLAG_KEY;
1076
 
    else if (pc) {
1077
 
        pkt->flags = 0;
1078
 
        /* keyframe computation */
1079
 
        if (pc->key_frame == 1)
1080
 
            pkt->flags |= AV_PKT_FLAG_KEY;
1081
 
        else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1082
 
            pkt->flags |= AV_PKT_FLAG_KEY;
1083
 
    }
1084
 
    if (pc)
1085
 
        pkt->convergence_duration = pc->convergence_duration;
1086
 
}
1087
 
 
1088
 
 
1089
 
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1090
 
{
1091
 
    AVStream *st;
1092
 
    int len, ret, i;
1093
 
 
1094
 
    av_init_packet(pkt);
1095
 
 
1096
 
    for(;;) {
1097
 
        /* select current input stream component */
1098
 
        st = s->cur_st;
1099
 
        if (st) {
1100
 
            if (!st->need_parsing || !st->parser) {
1101
 
                /* no parsing needed: we just output the packet as is */
1102
 
                /* raw data support */
1103
 
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1104
 
                compute_pkt_fields(s, st, NULL, pkt);
1105
 
                s->cur_st = NULL;
1106
 
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1107
 
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1108
 
                    ff_reduce_index(s, st->index);
1109
 
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1110
 
                }
1111
 
                break;
1112
 
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1113
 
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1114
 
                                       st->cur_ptr, st->cur_len,
1115
 
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1116
 
                                       st->cur_pkt.pos);
1117
 
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1118
 
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1119
 
                /* increment read pointer */
1120
 
                st->cur_ptr += len;
1121
 
                st->cur_len -= len;
1122
 
 
1123
 
                /* return packet if any */
1124
 
                if (pkt->size) {
1125
 
                got_packet:
1126
 
                    pkt->duration = 0;
1127
 
                    pkt->stream_index = st->index;
1128
 
                    pkt->pts = st->parser->pts;
1129
 
                    pkt->dts = st->parser->dts;
1130
 
                    pkt->pos = st->parser->pos;
1131
 
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1132
 
                        s->cur_st = NULL;
1133
 
                        pkt->destruct= st->cur_pkt.destruct;
1134
 
                        st->cur_pkt.destruct= NULL;
1135
 
                        st->cur_pkt.data    = NULL;
1136
 
                        assert(st->cur_len == 0);
1137
 
                    }else{
1138
 
                    pkt->destruct = NULL;
1139
 
                    }
1140
 
                    compute_pkt_fields(s, st, st->parser, pkt);
1141
 
 
1142
 
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1143
 
                        ff_reduce_index(s, st->index);
1144
 
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1145
 
                                           0, 0, AVINDEX_KEYFRAME);
1146
 
                    }
1147
 
 
1148
 
                    break;
1149
 
                }
1150
 
            } else {
1151
 
                /* free packet */
1152
 
                av_free_packet(&st->cur_pkt);
1153
 
                s->cur_st = NULL;
1154
 
            }
1155
 
        } else {
1156
 
            AVPacket cur_pkt;
1157
 
            /* read next packet */
1158
 
            ret = av_read_packet(s, &cur_pkt);
1159
 
            if (ret < 0) {
1160
 
                if (ret == AVERROR(EAGAIN))
1161
 
                    return ret;
1162
 
                /* return the last frames, if any */
1163
 
                for(i = 0; i < s->nb_streams; i++) {
1164
 
                    st = s->streams[i];
1165
 
                    if (st->parser && st->need_parsing) {
1166
 
                        av_parser_parse2(st->parser, st->codec,
1167
 
                                        &pkt->data, &pkt->size,
1168
 
                                        NULL, 0,
1169
 
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1170
 
                                        AV_NOPTS_VALUE);
1171
 
                        if (pkt->size)
1172
 
                            goto got_packet;
1173
 
                    }
1174
 
                }
1175
 
                /* no more packets: really terminate parsing */
1176
 
                return ret;
1177
 
            }
1178
 
            st = s->streams[cur_pkt.stream_index];
1179
 
            st->cur_pkt= cur_pkt;
1180
 
 
1181
 
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1182
 
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1183
 
               st->cur_pkt.pts < st->cur_pkt.dts){
1184
 
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1185
 
                    st->cur_pkt.stream_index,
1186
 
                    st->cur_pkt.pts,
1187
 
                    st->cur_pkt.dts,
1188
 
                    st->cur_pkt.size);
1189
 
//                av_free_packet(&st->cur_pkt);
1190
 
//                return -1;
1191
 
            }
1192
 
 
1193
 
            if(s->debug & FF_FDEBUG_TS)
1194
 
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1195
 
                    st->cur_pkt.stream_index,
1196
 
                    st->cur_pkt.pts,
1197
 
                    st->cur_pkt.dts,
1198
 
                    st->cur_pkt.size,
1199
 
                    st->cur_pkt.duration,
1200
 
                    st->cur_pkt.flags);
1201
 
 
1202
 
            s->cur_st = st;
1203
 
            st->cur_ptr = st->cur_pkt.data;
1204
 
            st->cur_len = st->cur_pkt.size;
1205
 
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1206
 
                st->parser = av_parser_init(st->codec->codec_id);
1207
 
                if (!st->parser) {
1208
 
                    /* no parser available: just output the raw packets */
1209
 
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1210
 
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1211
 
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1212
 
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1213
 
                    st->parser->flags |= PARSER_FLAG_ONCE;
1214
 
                }
1215
 
            }
1216
 
        }
1217
 
    }
1218
 
    if(s->debug & FF_FDEBUG_TS)
1219
 
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1220
 
            pkt->stream_index,
1221
 
            pkt->pts,
1222
 
            pkt->dts,
1223
 
            pkt->size,
1224
 
            pkt->duration,
1225
 
            pkt->flags);
1226
 
 
1227
 
    return 0;
1228
 
}
1229
 
 
1230
 
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1231
 
{
1232
 
    AVPacketList *pktl;
1233
 
    int eof=0;
1234
 
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1235
 
 
1236
 
    for(;;){
1237
 
        pktl = s->packet_buffer;
1238
 
        if (pktl) {
1239
 
            AVPacket *next_pkt= &pktl->pkt;
1240
 
 
1241
 
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1242
 
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1243
 
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1244
 
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1245
 
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1246
 
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1247
 
                        next_pkt->pts= pktl->pkt.dts;
1248
 
                    }
1249
 
                    pktl= pktl->next;
1250
 
                }
1251
 
                pktl = s->packet_buffer;
1252
 
            }
1253
 
 
1254
 
            if(   next_pkt->pts != AV_NOPTS_VALUE
1255
 
               || next_pkt->dts == AV_NOPTS_VALUE
1256
 
               || !genpts || eof){
1257
 
                /* read packet from packet buffer, if there is data */
1258
 
                *pkt = *next_pkt;
1259
 
                s->packet_buffer = pktl->next;
1260
 
                av_free(pktl);
1261
 
                return 0;
1262
 
            }
1263
 
        }
1264
 
        if(genpts){
1265
 
            int ret= av_read_frame_internal(s, pkt);
1266
 
            if(ret<0){
1267
 
                if(pktl && ret != AVERROR(EAGAIN)){
1268
 
                    eof=1;
1269
 
                    continue;
1270
 
                }else
1271
 
                    return ret;
1272
 
            }
1273
 
 
1274
 
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1275
 
                                           &s->packet_buffer_end)) < 0)
1276
 
                return AVERROR(ENOMEM);
1277
 
        }else{
1278
 
            assert(!s->packet_buffer);
1279
 
            return av_read_frame_internal(s, pkt);
1280
 
        }
1281
 
    }
1282
 
}
1283
 
 
1284
 
/* XXX: suppress the packet queue */
1285
 
static void flush_packet_queue(AVFormatContext *s)
1286
 
{
1287
 
    AVPacketList *pktl;
1288
 
 
1289
 
    for(;;) {
1290
 
        pktl = s->packet_buffer;
1291
 
        if (!pktl)
1292
 
            break;
1293
 
        s->packet_buffer = pktl->next;
1294
 
        av_free_packet(&pktl->pkt);
1295
 
        av_free(pktl);
1296
 
    }
1297
 
    while(s->raw_packet_buffer){
1298
 
        pktl = s->raw_packet_buffer;
1299
 
        s->raw_packet_buffer = pktl->next;
1300
 
        av_free_packet(&pktl->pkt);
1301
 
        av_free(pktl);
1302
 
    }
1303
 
    s->packet_buffer_end=
1304
 
    s->raw_packet_buffer_end= NULL;
1305
 
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1306
 
}
1307
 
 
1308
 
/*******************************************************/
1309
 
/* seek support */
1310
 
 
1311
 
int av_find_default_stream_index(AVFormatContext *s)
1312
 
{
1313
 
    int first_audio_index = -1;
1314
 
    int i;
1315
 
    AVStream *st;
1316
 
 
1317
 
    if (s->nb_streams <= 0)
1318
 
        return -1;
1319
 
    for(i = 0; i < s->nb_streams; i++) {
1320
 
        st = s->streams[i];
1321
 
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1322
 
            return i;
1323
 
        }
1324
 
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1325
 
            first_audio_index = i;
1326
 
    }
1327
 
    return first_audio_index >= 0 ? first_audio_index : 0;
1328
 
}
1329
 
 
1330
 
/**
1331
 
 * Flush the frame reader.
1332
 
 */
1333
 
void ff_read_frame_flush(AVFormatContext *s)
1334
 
{
1335
 
    AVStream *st;
1336
 
    int i, j;
1337
 
 
1338
 
    flush_packet_queue(s);
1339
 
 
1340
 
    s->cur_st = NULL;
1341
 
 
1342
 
    /* for each stream, reset read state */
1343
 
    for(i = 0; i < s->nb_streams; i++) {
1344
 
        st = s->streams[i];
1345
 
 
1346
 
        if (st->parser) {
1347
 
            av_parser_close(st->parser);
1348
 
            st->parser = NULL;
1349
 
            av_free_packet(&st->cur_pkt);
1350
 
        }
1351
 
        st->last_IP_pts = AV_NOPTS_VALUE;
1352
 
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1353
 
        st->reference_dts = AV_NOPTS_VALUE;
1354
 
        /* fail safe */
1355
 
        st->cur_ptr = NULL;
1356
 
        st->cur_len = 0;
1357
 
 
1358
 
        st->probe_packets = MAX_PROBE_PACKETS;
1359
 
 
1360
 
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1361
 
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1362
 
    }
1363
 
}
1364
 
 
1365
 
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1366
 
    int i;
1367
 
 
1368
 
    for(i = 0; i < s->nb_streams; i++) {
1369
 
        AVStream *st = s->streams[i];
1370
 
 
1371
 
        st->cur_dts = av_rescale(timestamp,
1372
 
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1373
 
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1374
 
    }
1375
 
}
1376
 
 
1377
 
void ff_reduce_index(AVFormatContext *s, int stream_index)
1378
 
{
1379
 
    AVStream *st= s->streams[stream_index];
1380
 
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1381
 
 
1382
 
    if((unsigned)st->nb_index_entries >= max_entries){
1383
 
        int i;
1384
 
        for(i=0; 2*i<st->nb_index_entries; i++)
1385
 
            st->index_entries[i]= st->index_entries[2*i];
1386
 
        st->nb_index_entries= i;
1387
 
    }
1388
 
}
1389
 
 
1390
 
int ff_add_index_entry(AVIndexEntry **index_entries,
1391
 
                       int *nb_index_entries,
1392
 
                       unsigned int *index_entries_allocated_size,
1393
 
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1394
 
{
1395
 
    AVIndexEntry *entries, *ie;
1396
 
    int index;
1397
 
 
1398
 
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1399
 
        return -1;
1400
 
 
1401
 
    entries = av_fast_realloc(*index_entries,
1402
 
                              index_entries_allocated_size,
1403
 
                              (*nb_index_entries + 1) *
1404
 
                              sizeof(AVIndexEntry));
1405
 
    if(!entries)
1406
 
        return -1;
1407
 
 
1408
 
    *index_entries= entries;
1409
 
 
1410
 
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1411
 
 
1412
 
    if(index<0){
1413
 
        index= (*nb_index_entries)++;
1414
 
        ie= &entries[index];
1415
 
        assert(index==0 || ie[-1].timestamp < timestamp);
1416
 
    }else{
1417
 
        ie= &entries[index];
1418
 
        if(ie->timestamp != timestamp){
1419
 
            if(ie->timestamp <= timestamp)
1420
 
                return -1;
1421
 
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1422
 
            (*nb_index_entries)++;
1423
 
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1424
 
            distance= ie->min_distance;
1425
 
    }
1426
 
 
1427
 
    ie->pos = pos;
1428
 
    ie->timestamp = timestamp;
1429
 
    ie->min_distance= distance;
1430
 
    ie->size= size;
1431
 
    ie->flags = flags;
1432
 
 
1433
 
    return index;
1434
 
}
1435
 
 
1436
 
int av_add_index_entry(AVStream *st,
1437
 
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1438
 
{
1439
 
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1440
 
                              &st->index_entries_allocated_size, pos,
1441
 
                              timestamp, size, distance, flags);
1442
 
}
1443
 
 
1444
 
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1445
 
                              int64_t wanted_timestamp, int flags)
1446
 
{
1447
 
    int a, b, m;
1448
 
    int64_t timestamp;
1449
 
 
1450
 
    a = - 1;
1451
 
    b = nb_entries;
1452
 
 
1453
 
    //optimize appending index entries at the end
1454
 
    if(b && entries[b-1].timestamp < wanted_timestamp)
1455
 
        a= b-1;
1456
 
 
1457
 
    while (b - a > 1) {
1458
 
        m = (a + b) >> 1;
1459
 
        timestamp = entries[m].timestamp;
1460
 
        if(timestamp >= wanted_timestamp)
1461
 
            b = m;
1462
 
        if(timestamp <= wanted_timestamp)
1463
 
            a = m;
1464
 
    }
1465
 
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1466
 
 
1467
 
    if(!(flags & AVSEEK_FLAG_ANY)){
1468
 
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1469
 
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1470
 
        }
1471
 
    }
1472
 
 
1473
 
    if(m == nb_entries)
1474
 
        return -1;
1475
 
    return  m;
1476
 
}
1477
 
 
1478
 
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1479
 
                              int flags)
1480
 
{
1481
 
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1482
 
                                     wanted_timestamp, flags);
1483
 
}
1484
 
 
1485
 
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1486
 
    AVInputFormat *avif= s->iformat;
1487
 
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1488
 
    int64_t ts_min, ts_max, ts;
1489
 
    int index;
1490
 
    int64_t ret;
1491
 
    AVStream *st;
1492
 
 
1493
 
    if (stream_index < 0)
1494
 
        return -1;
1495
 
 
1496
 
    av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1497
 
 
1498
 
    ts_max=
1499
 
    ts_min= AV_NOPTS_VALUE;
1500
 
    pos_limit= -1; //gcc falsely says it may be uninitialized
1501
 
 
1502
 
    st= s->streams[stream_index];
1503
 
    if(st->index_entries){
1504
 
        AVIndexEntry *e;
1505
 
 
1506
 
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1507
 
        index= FFMAX(index, 0);
1508
 
        e= &st->index_entries[index];
1509
 
 
1510
 
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1511
 
            pos_min= e->pos;
1512
 
            ts_min= e->timestamp;
1513
 
            av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1514
 
                    pos_min,ts_min);
1515
 
        }else{
1516
 
            assert(index==0);
1517
 
        }
1518
 
 
1519
 
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1520
 
        assert(index < st->nb_index_entries);
1521
 
        if(index >= 0){
1522
 
            e= &st->index_entries[index];
1523
 
            assert(e->timestamp >= target_ts);
1524
 
            pos_max= e->pos;
1525
 
            ts_max= e->timestamp;
1526
 
            pos_limit= pos_max - e->min_distance;
1527
 
            av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1528
 
                    pos_max,pos_limit, ts_max);
1529
 
        }
1530
 
    }
1531
 
 
1532
 
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1533
 
    if(pos<0)
1534
 
        return -1;
1535
 
 
1536
 
    /* do the seek */
1537
 
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1538
 
        return ret;
1539
 
 
1540
 
    av_update_cur_dts(s, st, ts);
1541
 
 
1542
 
    return 0;
1543
 
}
1544
 
 
1545
 
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1546
 
    int64_t pos, ts;
1547
 
    int64_t start_pos, filesize;
1548
 
    int no_change;
1549
 
 
1550
 
    av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1551
 
 
1552
 
    if(ts_min == AV_NOPTS_VALUE){
1553
 
        pos_min = s->data_offset;
1554
 
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1555
 
        if (ts_min == AV_NOPTS_VALUE)
1556
 
            return -1;
1557
 
    }
1558
 
 
1559
 
    if(ts_max == AV_NOPTS_VALUE){
1560
 
        int step= 1024;
1561
 
        filesize = avio_size(s->pb);
1562
 
        pos_max = filesize - 1;
1563
 
        do{
1564
 
            pos_max -= step;
1565
 
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1566
 
            step += step;
1567
 
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1568
 
        if (ts_max == AV_NOPTS_VALUE)
1569
 
            return -1;
1570
 
 
1571
 
        for(;;){
1572
 
            int64_t tmp_pos= pos_max + 1;
1573
 
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1574
 
            if(tmp_ts == AV_NOPTS_VALUE)
1575
 
                break;
1576
 
            ts_max= tmp_ts;
1577
 
            pos_max= tmp_pos;
1578
 
            if(tmp_pos >= filesize)
1579
 
                break;
1580
 
        }
1581
 
        pos_limit= pos_max;
1582
 
    }
1583
 
 
1584
 
    if(ts_min > ts_max){
1585
 
        return -1;
1586
 
    }else if(ts_min == ts_max){
1587
 
        pos_limit= pos_min;
1588
 
    }
1589
 
 
1590
 
    no_change=0;
1591
 
    while (pos_min < pos_limit) {
1592
 
        av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1593
 
                pos_min, pos_max, ts_min, ts_max);
1594
 
        assert(pos_limit <= pos_max);
1595
 
 
1596
 
        if(no_change==0){
1597
 
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1598
 
            // interpolate position (better than dichotomy)
1599
 
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1600
 
                + pos_min - approximate_keyframe_distance;
1601
 
        }else if(no_change==1){
1602
 
            // bisection, if interpolation failed to change min or max pos last time
1603
 
            pos = (pos_min + pos_limit)>>1;
1604
 
        }else{
1605
 
            /* linear search if bisection failed, can only happen if there
1606
 
               are very few or no keyframes between min/max */
1607
 
            pos=pos_min;
1608
 
        }
1609
 
        if(pos <= pos_min)
1610
 
            pos= pos_min + 1;
1611
 
        else if(pos > pos_limit)
1612
 
            pos= pos_limit;
1613
 
        start_pos= pos;
1614
 
 
1615
 
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1616
 
        if(pos == pos_max)
1617
 
            no_change++;
1618
 
        else
1619
 
            no_change=0;
1620
 
        av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1621
 
                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1622
 
                pos_limit, start_pos, no_change);
1623
 
        if(ts == AV_NOPTS_VALUE){
1624
 
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1625
 
            return -1;
1626
 
        }
1627
 
        assert(ts != AV_NOPTS_VALUE);
1628
 
        if (target_ts <= ts) {
1629
 
            pos_limit = start_pos - 1;
1630
 
            pos_max = pos;
1631
 
            ts_max = ts;
1632
 
        }
1633
 
        if (target_ts >= ts) {
1634
 
            pos_min = pos;
1635
 
            ts_min = ts;
1636
 
        }
1637
 
    }
1638
 
 
1639
 
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1640
 
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1641
 
    pos_min = pos;
1642
 
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1643
 
    pos_min++;
1644
 
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1645
 
    av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1646
 
            pos, ts_min, target_ts, ts_max);
1647
 
    *ts_ret= ts;
1648
 
    return pos;
1649
 
}
1650
 
 
1651
 
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1652
 
    int64_t pos_min, pos_max;
1653
 
#if 0
1654
 
    AVStream *st;
1655
 
 
1656
 
    if (stream_index < 0)
1657
 
        return -1;
1658
 
 
1659
 
    st= s->streams[stream_index];
1660
 
#endif
1661
 
 
1662
 
    pos_min = s->data_offset;
1663
 
    pos_max = avio_size(s->pb) - 1;
1664
 
 
1665
 
    if     (pos < pos_min) pos= pos_min;
1666
 
    else if(pos > pos_max) pos= pos_max;
1667
 
 
1668
 
    avio_seek(s->pb, pos, SEEK_SET);
1669
 
 
1670
 
#if 0
1671
 
    av_update_cur_dts(s, st, ts);
1672
 
#endif
1673
 
    return 0;
1674
 
}
1675
 
 
1676
 
static int av_seek_frame_generic(AVFormatContext *s,
1677
 
                                 int stream_index, int64_t timestamp, int flags)
1678
 
{
1679
 
    int index;
1680
 
    int64_t ret;
1681
 
    AVStream *st;
1682
 
    AVIndexEntry *ie;
1683
 
 
1684
 
    st = s->streams[stream_index];
1685
 
 
1686
 
    index = av_index_search_timestamp(st, timestamp, flags);
1687
 
 
1688
 
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1689
 
        return -1;
1690
 
 
1691
 
    if(index < 0 || index==st->nb_index_entries-1){
1692
 
        int i;
1693
 
        AVPacket pkt;
1694
 
 
1695
 
        if(st->nb_index_entries){
1696
 
            assert(st->index_entries);
1697
 
            ie= &st->index_entries[st->nb_index_entries-1];
1698
 
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1699
 
                return ret;
1700
 
            av_update_cur_dts(s, st, ie->timestamp);
1701
 
        }else{
1702
 
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1703
 
                return ret;
1704
 
        }
1705
 
        for(i=0;; i++) {
1706
 
            int ret;
1707
 
            do{
1708
 
                ret = av_read_frame(s, &pkt);
1709
 
            }while(ret == AVERROR(EAGAIN));
1710
 
            if(ret<0)
1711
 
                break;
1712
 
            av_free_packet(&pkt);
1713
 
            if(stream_index == pkt.stream_index){
1714
 
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1715
 
                    break;
1716
 
            }
1717
 
        }
1718
 
        index = av_index_search_timestamp(st, timestamp, flags);
1719
 
    }
1720
 
    if (index < 0)
1721
 
        return -1;
1722
 
 
1723
 
    ff_read_frame_flush(s);
1724
 
    if (s->iformat->read_seek){
1725
 
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1726
 
            return 0;
1727
 
    }
1728
 
    ie = &st->index_entries[index];
1729
 
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1730
 
        return ret;
1731
 
    av_update_cur_dts(s, st, ie->timestamp);
1732
 
 
1733
 
    return 0;
1734
 
}
1735
 
 
1736
 
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1737
 
{
1738
 
    int ret;
1739
 
    AVStream *st;
1740
 
 
1741
 
    ff_read_frame_flush(s);
1742
 
 
1743
 
    if(flags & AVSEEK_FLAG_BYTE)
1744
 
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1745
 
 
1746
 
    if(stream_index < 0){
1747
 
        stream_index= av_find_default_stream_index(s);
1748
 
        if(stream_index < 0)
1749
 
            return -1;
1750
 
 
1751
 
        st= s->streams[stream_index];
1752
 
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1753
 
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1754
 
    }
1755
 
 
1756
 
    /* first, we try the format specific seek */
1757
 
    if (s->iformat->read_seek)
1758
 
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1759
 
    else
1760
 
        ret = -1;
1761
 
    if (ret >= 0) {
1762
 
        return 0;
1763
 
    }
1764
 
 
1765
 
    if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1766
 
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1767
 
    else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1768
 
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1769
 
    else
1770
 
        return -1;
1771
 
}
1772
 
 
1773
 
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1774
 
{
1775
 
    if(min_ts > ts || max_ts < ts)
1776
 
        return -1;
1777
 
 
1778
 
    ff_read_frame_flush(s);
1779
 
 
1780
 
    if (s->iformat->read_seek2)
1781
 
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1782
 
 
1783
 
    if(s->iformat->read_timestamp){
1784
 
        //try to seek via read_timestamp()
1785
 
    }
1786
 
 
1787
 
    //Fallback to old API if new is not implemented but old is
1788
 
    //Note the old has somewat different sematics
1789
 
    if(s->iformat->read_seek || 1)
1790
 
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1791
 
 
1792
 
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1793
 
}
1794
 
 
1795
 
/*******************************************************/
1796
 
 
1797
 
/**
1798
 
 * Return TRUE if the stream has accurate duration in any stream.
1799
 
 *
1800
 
 * @return TRUE if the stream has accurate duration for at least one component.
1801
 
 */
1802
 
static int av_has_duration(AVFormatContext *ic)
1803
 
{
1804
 
    int i;
1805
 
    AVStream *st;
1806
 
 
1807
 
    for(i = 0;i < ic->nb_streams; i++) {
1808
 
        st = ic->streams[i];
1809
 
        if (st->duration != AV_NOPTS_VALUE)
1810
 
            return 1;
1811
 
    }
1812
 
    return 0;
1813
 
}
1814
 
 
1815
 
/**
1816
 
 * Estimate the stream timings from the one of each components.
1817
 
 *
1818
 
 * Also computes the global bitrate if possible.
1819
 
 */
1820
 
static void av_update_stream_timings(AVFormatContext *ic)
1821
 
{
1822
 
    int64_t start_time, start_time1, end_time, end_time1;
1823
 
    int64_t duration, duration1;
1824
 
    int i;
1825
 
    AVStream *st;
1826
 
 
1827
 
    start_time = INT64_MAX;
1828
 
    end_time = INT64_MIN;
1829
 
    duration = INT64_MIN;
1830
 
    for(i = 0;i < ic->nb_streams; i++) {
1831
 
        st = ic->streams[i];
1832
 
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1833
 
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1834
 
            if (start_time1 < start_time)
1835
 
                start_time = start_time1;
1836
 
            if (st->duration != AV_NOPTS_VALUE) {
1837
 
                end_time1 = start_time1
1838
 
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1839
 
                if (end_time1 > end_time)
1840
 
                    end_time = end_time1;
1841
 
            }
1842
 
        }
1843
 
        if (st->duration != AV_NOPTS_VALUE) {
1844
 
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1845
 
            if (duration1 > duration)
1846
 
                duration = duration1;
1847
 
        }
1848
 
    }
1849
 
    if (start_time != INT64_MAX) {
1850
 
        ic->start_time = start_time;
1851
 
        if (end_time != INT64_MIN) {
1852
 
            if (end_time - start_time > duration)
1853
 
                duration = end_time - start_time;
1854
 
        }
1855
 
    }
1856
 
    if (duration != INT64_MIN) {
1857
 
        ic->duration = duration;
1858
 
        if (ic->file_size > 0) {
1859
 
            /* compute the bitrate */
1860
 
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1861
 
                (double)ic->duration;
1862
 
        }
1863
 
    }
1864
 
}
1865
 
 
1866
 
static void fill_all_stream_timings(AVFormatContext *ic)
1867
 
{
1868
 
    int i;
1869
 
    AVStream *st;
1870
 
 
1871
 
    av_update_stream_timings(ic);
1872
 
    for(i = 0;i < ic->nb_streams; i++) {
1873
 
        st = ic->streams[i];
1874
 
        if (st->start_time == AV_NOPTS_VALUE) {
1875
 
            if(ic->start_time != AV_NOPTS_VALUE)
1876
 
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1877
 
            if(ic->duration != AV_NOPTS_VALUE)
1878
 
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1879
 
        }
1880
 
    }
1881
 
}
1882
 
 
1883
 
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1884
 
{
1885
 
    int64_t filesize, duration;
1886
 
    int bit_rate, i;
1887
 
    AVStream *st;
1888
 
 
1889
 
    /* if bit_rate is already set, we believe it */
1890
 
    if (ic->bit_rate <= 0) {
1891
 
        bit_rate = 0;
1892
 
        for(i=0;i<ic->nb_streams;i++) {
1893
 
            st = ic->streams[i];
1894
 
            if (st->codec->bit_rate > 0)
1895
 
            bit_rate += st->codec->bit_rate;
1896
 
        }
1897
 
        ic->bit_rate = bit_rate;
1898
 
    }
1899
 
 
1900
 
    /* if duration is already set, we believe it */
1901
 
    if (ic->duration == AV_NOPTS_VALUE &&
1902
 
        ic->bit_rate != 0 &&
1903
 
        ic->file_size != 0)  {
1904
 
        filesize = ic->file_size;
1905
 
        if (filesize > 0) {
1906
 
            for(i = 0; i < ic->nb_streams; i++) {
1907
 
                st = ic->streams[i];
1908
 
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1909
 
                if (st->duration == AV_NOPTS_VALUE)
1910
 
                    st->duration = duration;
1911
 
            }
1912
 
        }
1913
 
    }
1914
 
}
1915
 
 
1916
 
#define DURATION_MAX_READ_SIZE 250000
1917
 
#define DURATION_MAX_RETRY 3
1918
 
 
1919
 
/* only usable for MPEG-PS streams */
1920
 
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1921
 
{
1922
 
    AVPacket pkt1, *pkt = &pkt1;
1923
 
    AVStream *st;
1924
 
    int read_size, i, ret;
1925
 
    int64_t end_time;
1926
 
    int64_t filesize, offset, duration;
1927
 
    int retry=0;
1928
 
 
1929
 
    ic->cur_st = NULL;
1930
 
 
1931
 
    /* flush packet queue */
1932
 
    flush_packet_queue(ic);
1933
 
 
1934
 
    for (i=0; i<ic->nb_streams; i++) {
1935
 
        st = ic->streams[i];
1936
 
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1937
 
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1938
 
 
1939
 
        if (st->parser) {
1940
 
            av_parser_close(st->parser);
1941
 
            st->parser= NULL;
1942
 
            av_free_packet(&st->cur_pkt);
1943
 
        }
1944
 
    }
1945
 
 
1946
 
    /* estimate the end time (duration) */
1947
 
    /* XXX: may need to support wrapping */
1948
 
    filesize = ic->file_size;
1949
 
    end_time = AV_NOPTS_VALUE;
1950
 
    do{
1951
 
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1952
 
    if (offset < 0)
1953
 
        offset = 0;
1954
 
 
1955
 
    avio_seek(ic->pb, offset, SEEK_SET);
1956
 
    read_size = 0;
1957
 
    for(;;) {
1958
 
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1959
 
            break;
1960
 
 
1961
 
        do{
1962
 
            ret = av_read_packet(ic, pkt);
1963
 
        }while(ret == AVERROR(EAGAIN));
1964
 
        if (ret != 0)
1965
 
            break;
1966
 
        read_size += pkt->size;
1967
 
        st = ic->streams[pkt->stream_index];
1968
 
        if (pkt->pts != AV_NOPTS_VALUE &&
1969
 
            (st->start_time != AV_NOPTS_VALUE ||
1970
 
             st->first_dts  != AV_NOPTS_VALUE)) {
1971
 
            duration = end_time = pkt->pts;
1972
 
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1973
 
            else                                   duration -= st->first_dts;
1974
 
            if (duration < 0)
1975
 
                duration += 1LL<<st->pts_wrap_bits;
1976
 
            if (duration > 0) {
1977
 
                if (st->duration == AV_NOPTS_VALUE ||
1978
 
                    st->duration < duration)
1979
 
                    st->duration = duration;
1980
 
            }
1981
 
        }
1982
 
        av_free_packet(pkt);
1983
 
    }
1984
 
    }while(   end_time==AV_NOPTS_VALUE
1985
 
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1986
 
           && ++retry <= DURATION_MAX_RETRY);
1987
 
 
1988
 
    fill_all_stream_timings(ic);
1989
 
 
1990
 
    avio_seek(ic->pb, old_offset, SEEK_SET);
1991
 
    for (i=0; i<ic->nb_streams; i++) {
1992
 
        st= ic->streams[i];
1993
 
        st->cur_dts= st->first_dts;
1994
 
        st->last_IP_pts = AV_NOPTS_VALUE;
1995
 
        st->reference_dts = AV_NOPTS_VALUE;
1996
 
    }
1997
 
}
1998
 
 
1999
 
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2000
 
{
2001
 
    int64_t file_size;
2002
 
 
2003
 
    /* get the file size, if possible */
2004
 
    if (ic->iformat->flags & AVFMT_NOFILE) {
2005
 
        file_size = 0;
2006
 
    } else {
2007
 
        file_size = avio_size(ic->pb);
2008
 
        if (file_size < 0)
2009
 
            file_size = 0;
2010
 
    }
2011
 
    ic->file_size = file_size;
2012
 
 
2013
 
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2014
 
         !strcmp(ic->iformat->name, "mpegts")) &&
2015
 
        file_size && ic->pb->seekable) {
2016
 
        /* get accurate estimate from the PTSes */
2017
 
        av_estimate_timings_from_pts(ic, old_offset);
2018
 
    } else if (av_has_duration(ic)) {
2019
 
        /* at least one component has timings - we use them for all
2020
 
           the components */
2021
 
        fill_all_stream_timings(ic);
2022
 
    } else {
2023
 
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2024
 
        /* less precise: use bitrate info */
2025
 
        av_estimate_timings_from_bit_rate(ic);
2026
 
    }
2027
 
    av_update_stream_timings(ic);
2028
 
 
2029
 
    {
2030
 
        int i;
2031
 
        AVStream av_unused *st;
2032
 
        for(i = 0;i < ic->nb_streams; i++) {
2033
 
            st = ic->streams[i];
2034
 
            av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2035
 
                    (double) st->start_time / AV_TIME_BASE,
2036
 
                    (double) st->duration   / AV_TIME_BASE);
2037
 
        }
2038
 
        av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2039
 
                (double) ic->start_time / AV_TIME_BASE,
2040
 
                (double) ic->duration   / AV_TIME_BASE,
2041
 
                ic->bit_rate / 1000);
2042
 
    }
2043
 
}
2044
 
 
2045
 
static int has_codec_parameters(AVCodecContext *enc)
2046
 
{
2047
 
    int val;
2048
 
    switch(enc->codec_type) {
2049
 
    case AVMEDIA_TYPE_AUDIO:
2050
 
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2051
 
        if(!enc->frame_size &&
2052
 
           (enc->codec_id == CODEC_ID_VORBIS ||
2053
 
            enc->codec_id == CODEC_ID_AAC ||
2054
 
            enc->codec_id == CODEC_ID_MP1 ||
2055
 
            enc->codec_id == CODEC_ID_MP2 ||
2056
 
            enc->codec_id == CODEC_ID_MP3 ||
2057
 
            enc->codec_id == CODEC_ID_SPEEX))
2058
 
            return 0;
2059
 
        break;
2060
 
    case AVMEDIA_TYPE_VIDEO:
2061
 
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2062
 
        break;
2063
 
    default:
2064
 
        val = 1;
2065
 
        break;
2066
 
    }
2067
 
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2068
 
}
2069
 
 
2070
 
static int has_decode_delay_been_guessed(AVStream *st)
2071
 
{
2072
 
    return st->codec->codec_id != CODEC_ID_H264 ||
2073
 
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2074
 
}
2075
 
 
2076
 
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2077
 
{
2078
 
    int16_t *samples;
2079
 
    AVCodec *codec;
2080
 
    int got_picture, data_size, ret=0;
2081
 
    AVFrame picture;
2082
 
 
2083
 
    if(!st->codec->codec){
2084
 
        codec = avcodec_find_decoder(st->codec->codec_id);
2085
 
        if (!codec)
2086
 
            return -1;
2087
 
        ret = avcodec_open(st->codec, codec);
2088
 
        if (ret < 0)
2089
 
            return ret;
2090
 
    }
2091
 
 
2092
 
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2093
 
        switch(st->codec->codec_type) {
2094
 
        case AVMEDIA_TYPE_VIDEO:
2095
 
            avcodec_get_frame_defaults(&picture);
2096
 
            ret = avcodec_decode_video2(st->codec, &picture,
2097
 
                                        &got_picture, avpkt);
2098
 
            break;
2099
 
        case AVMEDIA_TYPE_AUDIO:
2100
 
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2101
 
            samples = av_malloc(data_size);
2102
 
            if (!samples)
2103
 
                goto fail;
2104
 
            ret = avcodec_decode_audio3(st->codec, samples,
2105
 
                                        &data_size, avpkt);
2106
 
            av_free(samples);
2107
 
            break;
2108
 
        default:
2109
 
            break;
2110
 
        }
2111
 
    }
2112
 
 fail:
2113
 
    return ret;
2114
 
}
2115
 
 
2116
 
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2117
 
{
2118
 
    while (tags->id != CODEC_ID_NONE) {
2119
 
        if (tags->id == id)
2120
 
            return tags->tag;
2121
 
        tags++;
2122
 
    }
2123
 
    return 0;
2124
 
}
2125
 
 
2126
 
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2127
 
{
2128
 
    int i;
2129
 
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2130
 
        if(tag == tags[i].tag)
2131
 
            return tags[i].id;
2132
 
    }
2133
 
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2134
 
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2135
 
            return tags[i].id;
2136
 
    }
2137
 
    return CODEC_ID_NONE;
2138
 
}
2139
 
 
2140
 
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2141
 
{
2142
 
    int i;
2143
 
    for(i=0; tags && tags[i]; i++){
2144
 
        int tag= ff_codec_get_tag(tags[i], id);
2145
 
        if(tag) return tag;
2146
 
    }
2147
 
    return 0;
2148
 
}
2149
 
 
2150
 
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2151
 
{
2152
 
    int i;
2153
 
    for(i=0; tags && tags[i]; i++){
2154
 
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2155
 
        if(id!=CODEC_ID_NONE) return id;
2156
 
    }
2157
 
    return CODEC_ID_NONE;
2158
 
}
2159
 
 
2160
 
static void compute_chapters_end(AVFormatContext *s)
2161
 
{
2162
 
    unsigned int i, j;
2163
 
    int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2164
 
 
2165
 
    for (i = 0; i < s->nb_chapters; i++)
2166
 
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2167
 
            AVChapter *ch = s->chapters[i];
2168
 
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2169
 
                                     : INT64_MAX;
2170
 
 
2171
 
            for (j = 0; j < s->nb_chapters; j++) {
2172
 
                AVChapter *ch1 = s->chapters[j];
2173
 
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2174
 
                if (j != i && next_start > ch->start && next_start < end)
2175
 
                    end = next_start;
2176
 
            }
2177
 
            ch->end = (end == INT64_MAX) ? ch->start : end;
2178
 
        }
2179
 
}
2180
 
 
2181
 
static int get_std_framerate(int i){
2182
 
    if(i<60*12) return i*1001;
2183
 
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2184
 
}
2185
 
 
2186
 
/*
2187
 
 * Is the time base unreliable.
2188
 
 * This is a heuristic to balance between quick acceptance of the values in
2189
 
 * the headers vs. some extra checks.
2190
 
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2191
 
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2192
 
 * And there are "variable" fps files this needs to detect as well.
2193
 
 */
2194
 
static int tb_unreliable(AVCodecContext *c){
2195
 
    if(   c->time_base.den >= 101L*c->time_base.num
2196
 
       || c->time_base.den <    5L*c->time_base.num
2197
 
/*       || c->codec_tag == AV_RL32("DIVX")
2198
 
       || c->codec_tag == AV_RL32("XVID")*/
2199
 
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2200
 
       || c->codec_id == CODEC_ID_H264
2201
 
       )
2202
 
        return 1;
2203
 
    return 0;
2204
 
}
2205
 
 
2206
 
int av_find_stream_info(AVFormatContext *ic)
2207
 
{
2208
 
    int i, count, ret, read_size, j;
2209
 
    AVStream *st;
2210
 
    AVPacket pkt1, *pkt;
2211
 
    int64_t old_offset = avio_tell(ic->pb);
2212
 
 
2213
 
    for(i=0;i<ic->nb_streams;i++) {
2214
 
        AVCodec *codec;
2215
 
        st = ic->streams[i];
2216
 
        if (st->codec->codec_id == CODEC_ID_AAC) {
2217
 
            st->codec->sample_rate = 0;
2218
 
            st->codec->frame_size = 0;
2219
 
            st->codec->channels = 0;
2220
 
        }
2221
 
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2222
 
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2223
 
/*            if(!st->time_base.num)
2224
 
                st->time_base= */
2225
 
            if(!st->codec->time_base.num)
2226
 
                st->codec->time_base= st->time_base;
2227
 
        }
2228
 
        //only for the split stuff
2229
 
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2230
 
            st->parser = av_parser_init(st->codec->codec_id);
2231
 
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2232
 
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2233
 
            }
2234
 
        }
2235
 
        assert(!st->codec->codec);
2236
 
        codec = avcodec_find_decoder(st->codec->codec_id);
2237
 
 
2238
 
        /* Force decoding of at least one frame of codec data
2239
 
         * this makes sure the codec initializes the channel configuration
2240
 
         * and does not trust the values from the container.
2241
 
         */
2242
 
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2243
 
            st->codec->channels = 0;
2244
 
 
2245
 
        /* Ensure that subtitle_header is properly set. */
2246
 
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2247
 
            && codec && !st->codec->codec)
2248
 
            avcodec_open(st->codec, codec);
2249
 
 
2250
 
        //try to just open decoders, in case this is enough to get parameters
2251
 
        if(!has_codec_parameters(st->codec)){
2252
 
            if (codec && !st->codec->codec)
2253
 
                avcodec_open(st->codec, codec);
2254
 
        }
2255
 
    }
2256
 
 
2257
 
    for (i=0; i<ic->nb_streams; i++) {
2258
 
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2259
 
    }
2260
 
 
2261
 
    count = 0;
2262
 
    read_size = 0;
2263
 
    for(;;) {
2264
 
        if(url_interrupt_cb()){
2265
 
            ret= AVERROR_EXIT;
2266
 
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2267
 
            break;
2268
 
        }
2269
 
 
2270
 
        /* check if one codec still needs to be handled */
2271
 
        for(i=0;i<ic->nb_streams;i++) {
2272
 
            int fps_analyze_framecount = 20;
2273
 
 
2274
 
            st = ic->streams[i];
2275
 
            if (!has_codec_parameters(st->codec))
2276
 
                break;
2277
 
            /* if the timebase is coarse (like the usual millisecond precision
2278
 
               of mkv), we need to analyze more frames to reliably arrive at
2279
 
               the correct fps */
2280
 
            if (av_q2d(st->time_base) > 0.0005)
2281
 
                fps_analyze_framecount *= 2;
2282
 
            if (ic->fps_probe_size >= 0)
2283
 
                fps_analyze_framecount = ic->fps_probe_size;
2284
 
            /* variable fps and no guess at the real fps */
2285
 
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2286
 
               && st->info->duration_count < fps_analyze_framecount
2287
 
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2288
 
                break;
2289
 
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2290
 
                break;
2291
 
            if(st->first_dts == AV_NOPTS_VALUE)
2292
 
                break;
2293
 
        }
2294
 
        if (i == ic->nb_streams) {
2295
 
            /* NOTE: if the format has no header, then we need to read
2296
 
               some packets to get most of the streams, so we cannot
2297
 
               stop here */
2298
 
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2299
 
                /* if we found the info for all the codecs, we can stop */
2300
 
                ret = count;
2301
 
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2302
 
                break;
2303
 
            }
2304
 
        }
2305
 
        /* we did not get all the codec info, but we read too much data */
2306
 
        if (read_size >= ic->probesize) {
2307
 
            ret = count;
2308
 
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2309
 
            break;
2310
 
        }
2311
 
 
2312
 
        /* NOTE: a new stream can be added there if no header in file
2313
 
           (AVFMTCTX_NOHEADER) */
2314
 
        ret = av_read_frame_internal(ic, &pkt1);
2315
 
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2316
 
            /* EOF or error */
2317
 
            ret = -1; /* we could not have all the codec parameters before EOF */
2318
 
            for(i=0;i<ic->nb_streams;i++) {
2319
 
                st = ic->streams[i];
2320
 
                if (!has_codec_parameters(st->codec)){
2321
 
                    char buf[256];
2322
 
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2323
 
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2324
 
                } else {
2325
 
                    ret = 0;
2326
 
                }
2327
 
            }
2328
 
            break;
2329
 
        }
2330
 
 
2331
 
        if (ret == AVERROR(EAGAIN))
2332
 
            continue;
2333
 
 
2334
 
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2335
 
        if ((ret = av_dup_packet(pkt)) < 0)
2336
 
            goto find_stream_info_err;
2337
 
 
2338
 
        read_size += pkt->size;
2339
 
 
2340
 
        st = ic->streams[pkt->stream_index];
2341
 
        if (st->codec_info_nb_frames>1) {
2342
 
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2343
 
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2344
 
                break;
2345
 
            }
2346
 
            st->info->codec_info_duration += pkt->duration;
2347
 
        }
2348
 
        {
2349
 
            int64_t last = st->info->last_dts;
2350
 
            int64_t duration= pkt->dts - last;
2351
 
 
2352
 
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2353
 
                double dur= duration * av_q2d(st->time_base);
2354
 
 
2355
 
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2356
 
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2357
 
                if (st->info->duration_count < 2)
2358
 
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2359
 
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2360
 
                    int framerate= get_std_framerate(i);
2361
 
                    int ticks= lrintf(dur*framerate/(1001*12));
2362
 
                    double error= dur - ticks*1001*12/(double)framerate;
2363
 
                    st->info->duration_error[i] += error*error;
2364
 
                }
2365
 
                st->info->duration_count++;
2366
 
                // ignore the first 4 values, they might have some random jitter
2367
 
                if (st->info->duration_count > 3)
2368
 
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2369
 
            }
2370
 
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2371
 
                st->info->last_dts = pkt->dts;
2372
 
        }
2373
 
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2374
 
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2375
 
            if(i){
2376
 
                st->codec->extradata_size= i;
2377
 
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2378
 
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2379
 
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2380
 
            }
2381
 
        }
2382
 
 
2383
 
        /* if still no information, we try to open the codec and to
2384
 
           decompress the frame. We try to avoid that in most cases as
2385
 
           it takes longer and uses more memory. For MPEG-4, we need to
2386
 
           decompress for QuickTime. */
2387
 
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2388
 
            try_decode_frame(st, pkt);
2389
 
 
2390
 
        st->codec_info_nb_frames++;
2391
 
        count++;
2392
 
    }
2393
 
 
2394
 
    // close codecs which were opened in try_decode_frame()
2395
 
    for(i=0;i<ic->nb_streams;i++) {
2396
 
        st = ic->streams[i];
2397
 
        if(st->codec->codec)
2398
 
            avcodec_close(st->codec);
2399
 
    }
2400
 
    for(i=0;i<ic->nb_streams;i++) {
2401
 
        st = ic->streams[i];
2402
 
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2403
 
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2404
 
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2405
 
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2406
 
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2407
 
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2408
 
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2409
 
 
2410
 
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2411
 
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2412
 
            // ipmovie.c produces.
2413
 
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2414
 
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2415
 
            if (st->info->duration_count && !st->r_frame_rate.num
2416
 
               && tb_unreliable(st->codec) /*&&
2417
 
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2418
 
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2419
 
                int num = 0;
2420
 
                double best_error= 2*av_q2d(st->time_base);
2421
 
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2422
 
 
2423
 
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2424
 
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2425
 
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2426
 
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2427
 
                    if(error < best_error){
2428
 
                        best_error= error;
2429
 
                        num = get_std_framerate(j);
2430
 
                    }
2431
 
                }
2432
 
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2433
 
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2434
 
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2435
 
            }
2436
 
 
2437
 
            if (!st->r_frame_rate.num){
2438
 
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2439
 
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2440
 
                    st->r_frame_rate.num = st->codec->time_base.den;
2441
 
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2442
 
                }else{
2443
 
                    st->r_frame_rate.num = st->time_base.den;
2444
 
                    st->r_frame_rate.den = st->time_base.num;
2445
 
                }
2446
 
            }
2447
 
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2448
 
            if(!st->codec->bits_per_coded_sample)
2449
 
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2450
 
            // set stream disposition based on audio service type
2451
 
            switch (st->codec->audio_service_type) {
2452
 
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2453
 
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2454
 
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2455
 
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2456
 
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2457
 
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2458
 
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2459
 
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2460
 
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2461
 
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2462
 
            }
2463
 
        }
2464
 
    }
2465
 
 
2466
 
    av_estimate_timings(ic, old_offset);
2467
 
 
2468
 
    compute_chapters_end(ic);
2469
 
 
2470
 
#if 0
2471
 
    /* correct DTS for B-frame streams with no timestamps */
2472
 
    for(i=0;i<ic->nb_streams;i++) {
2473
 
        st = ic->streams[i];
2474
 
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2475
 
            if(b-frames){
2476
 
                ppktl = &ic->packet_buffer;
2477
 
                while(ppkt1){
2478
 
                    if(ppkt1->stream_index != i)
2479
 
                        continue;
2480
 
                    if(ppkt1->pkt->dts < 0)
2481
 
                        break;
2482
 
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2483
 
                        break;
2484
 
                    ppkt1->pkt->dts -= delta;
2485
 
                    ppkt1= ppkt1->next;
2486
 
                }
2487
 
                if(ppkt1)
2488
 
                    continue;
2489
 
                st->cur_dts -= delta;
2490
 
            }
2491
 
        }
2492
 
    }
2493
 
#endif
2494
 
 
2495
 
 find_stream_info_err:
2496
 
    for (i=0; i < ic->nb_streams; i++)
2497
 
        av_freep(&ic->streams[i]->info);
2498
 
    return ret;
2499
 
}
2500
 
 
2501
 
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2502
 
{
2503
 
    int i, j;
2504
 
 
2505
 
    for (i = 0; i < ic->nb_programs; i++)
2506
 
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2507
 
            if (ic->programs[i]->stream_index[j] == s)
2508
 
                return ic->programs[i];
2509
 
    return NULL;
2510
 
}
2511
 
 
2512
 
int av_find_best_stream(AVFormatContext *ic,
2513
 
                        enum AVMediaType type,
2514
 
                        int wanted_stream_nb,
2515
 
                        int related_stream,
2516
 
                        AVCodec **decoder_ret,
2517
 
                        int flags)
2518
 
{
2519
 
    int i, nb_streams = ic->nb_streams;
2520
 
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2521
 
    unsigned *program = NULL;
2522
 
    AVCodec *decoder = NULL, *best_decoder = NULL;
2523
 
 
2524
 
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2525
 
        AVProgram *p = find_program_from_stream(ic, related_stream);
2526
 
        if (p) {
2527
 
            program = p->stream_index;
2528
 
            nb_streams = p->nb_stream_indexes;
2529
 
        }
2530
 
    }
2531
 
    for (i = 0; i < nb_streams; i++) {
2532
 
        int real_stream_index = program ? program[i] : i;
2533
 
        AVStream *st = ic->streams[real_stream_index];
2534
 
        AVCodecContext *avctx = st->codec;
2535
 
        if (avctx->codec_type != type)
2536
 
            continue;
2537
 
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2538
 
            continue;
2539
 
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2540
 
            continue;
2541
 
        if (decoder_ret) {
2542
 
            decoder = avcodec_find_decoder(st->codec->codec_id);
2543
 
            if (!decoder) {
2544
 
                if (ret < 0)
2545
 
                    ret = AVERROR_DECODER_NOT_FOUND;
2546
 
                continue;
2547
 
            }
2548
 
        }
2549
 
        if (best_count >= st->codec_info_nb_frames)
2550
 
            continue;
2551
 
        best_count = st->codec_info_nb_frames;
2552
 
        ret = real_stream_index;
2553
 
        best_decoder = decoder;
2554
 
        if (program && i == nb_streams - 1 && ret < 0) {
2555
 
            program = NULL;
2556
 
            nb_streams = ic->nb_streams;
2557
 
            i = 0; /* no related stream found, try again with everything */
2558
 
        }
2559
 
    }
2560
 
    if (decoder_ret)
2561
 
        *decoder_ret = best_decoder;
2562
 
    return ret;
2563
 
}
2564
 
 
2565
 
/*******************************************************/
2566
 
 
2567
 
int av_read_play(AVFormatContext *s)
2568
 
{
2569
 
    if (s->iformat->read_play)
2570
 
        return s->iformat->read_play(s);
2571
 
    if (s->pb)
2572
 
        return avio_pause(s->pb, 0);
2573
 
    return AVERROR(ENOSYS);
2574
 
}
2575
 
 
2576
 
int av_read_pause(AVFormatContext *s)
2577
 
{
2578
 
    if (s->iformat->read_pause)
2579
 
        return s->iformat->read_pause(s);
2580
 
    if (s->pb)
2581
 
        return avio_pause(s->pb, 1);
2582
 
    return AVERROR(ENOSYS);
2583
 
}
2584
 
 
2585
 
void av_close_input_stream(AVFormatContext *s)
2586
 
{
2587
 
    flush_packet_queue(s);
2588
 
    if (s->iformat->read_close)
2589
 
        s->iformat->read_close(s);
2590
 
    avformat_free_context(s);
2591
 
}
2592
 
 
2593
 
void avformat_free_context(AVFormatContext *s)
2594
 
{
2595
 
    int i;
2596
 
    AVStream *st;
2597
 
 
2598
 
    av_opt_free(s);
2599
 
    if (s->iformat && s->iformat->priv_class && s->priv_data)
2600
 
        av_opt_free(s->priv_data);
2601
 
 
2602
 
    for(i=0;i<s->nb_streams;i++) {
2603
 
        /* free all data in a stream component */
2604
 
        st = s->streams[i];
2605
 
        if (st->parser) {
2606
 
            av_parser_close(st->parser);
2607
 
            av_free_packet(&st->cur_pkt);
2608
 
        }
2609
 
        av_dict_free(&st->metadata);
2610
 
        av_free(st->index_entries);
2611
 
        av_free(st->codec->extradata);
2612
 
        av_free(st->codec->subtitle_header);
2613
 
        av_free(st->codec);
2614
 
        av_free(st->priv_data);
2615
 
        av_free(st->info);
2616
 
        av_free(st);
2617
 
    }
2618
 
    for(i=s->nb_programs-1; i>=0; i--) {
2619
 
        av_dict_free(&s->programs[i]->metadata);
2620
 
        av_freep(&s->programs[i]->stream_index);
2621
 
        av_freep(&s->programs[i]);
2622
 
    }
2623
 
    av_freep(&s->programs);
2624
 
    av_freep(&s->priv_data);
2625
 
    while(s->nb_chapters--) {
2626
 
        av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2627
 
        av_free(s->chapters[s->nb_chapters]);
2628
 
    }
2629
 
    av_freep(&s->chapters);
2630
 
    av_dict_free(&s->metadata);
2631
 
    av_freep(&s->streams);
2632
 
    av_free(s);
2633
 
}
2634
 
 
2635
 
void av_close_input_file(AVFormatContext *s)
2636
 
{
2637
 
    AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2638
 
                       NULL : s->pb;
2639
 
    av_close_input_stream(s);
2640
 
    if (pb)
2641
 
        avio_close(pb);
2642
 
}
2643
 
 
2644
 
AVStream *av_new_stream(AVFormatContext *s, int id)
2645
 
{
2646
 
    AVStream *st;
2647
 
    int i;
2648
 
    AVStream **streams;
2649
 
 
2650
 
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2651
 
        return NULL;
2652
 
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2653
 
    if (!streams)
2654
 
        return NULL;
2655
 
    s->streams = streams;
2656
 
 
2657
 
    st = av_mallocz(sizeof(AVStream));
2658
 
    if (!st)
2659
 
        return NULL;
2660
 
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2661
 
        av_free(st);
2662
 
        return NULL;
2663
 
    }
2664
 
 
2665
 
    st->codec= avcodec_alloc_context();
2666
 
    if (s->iformat) {
2667
 
        /* no default bitrate if decoding */
2668
 
        st->codec->bit_rate = 0;
2669
 
    }
2670
 
    st->index = s->nb_streams;
2671
 
    st->id = id;
2672
 
    st->start_time = AV_NOPTS_VALUE;
2673
 
    st->duration = AV_NOPTS_VALUE;
2674
 
        /* we set the current DTS to 0 so that formats without any timestamps
2675
 
           but durations get some timestamps, formats with some unknown
2676
 
           timestamps have their first few packets buffered and the
2677
 
           timestamps corrected before they are returned to the user */
2678
 
    st->cur_dts = 0;
2679
 
    st->first_dts = AV_NOPTS_VALUE;
2680
 
    st->probe_packets = MAX_PROBE_PACKETS;
2681
 
 
2682
 
    /* default pts setting is MPEG-like */
2683
 
    av_set_pts_info(st, 33, 1, 90000);
2684
 
    st->last_IP_pts = AV_NOPTS_VALUE;
2685
 
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2686
 
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2687
 
    st->reference_dts = AV_NOPTS_VALUE;
2688
 
 
2689
 
    st->sample_aspect_ratio = (AVRational){0,1};
2690
 
 
2691
 
    s->streams[s->nb_streams++] = st;
2692
 
    return st;
2693
 
}
2694
 
 
2695
 
AVProgram *av_new_program(AVFormatContext *ac, int id)
2696
 
{
2697
 
    AVProgram *program=NULL;
2698
 
    int i;
2699
 
 
2700
 
    av_dlog(ac, "new_program: id=0x%04x\n", id);
2701
 
 
2702
 
    for(i=0; i<ac->nb_programs; i++)
2703
 
        if(ac->programs[i]->id == id)
2704
 
            program = ac->programs[i];
2705
 
 
2706
 
    if(!program){
2707
 
        program = av_mallocz(sizeof(AVProgram));
2708
 
        if (!program)
2709
 
            return NULL;
2710
 
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2711
 
        program->discard = AVDISCARD_NONE;
2712
 
    }
2713
 
    program->id = id;
2714
 
 
2715
 
    return program;
2716
 
}
2717
 
 
2718
 
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2719
 
{
2720
 
    AVChapter *chapter = NULL;
2721
 
    int i;
2722
 
 
2723
 
    for(i=0; i<s->nb_chapters; i++)
2724
 
        if(s->chapters[i]->id == id)
2725
 
            chapter = s->chapters[i];
2726
 
 
2727
 
    if(!chapter){
2728
 
        chapter= av_mallocz(sizeof(AVChapter));
2729
 
        if(!chapter)
2730
 
            return NULL;
2731
 
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2732
 
    }
2733
 
    av_dict_set(&chapter->metadata, "title", title, 0);
2734
 
    chapter->id    = id;
2735
 
    chapter->time_base= time_base;
2736
 
    chapter->start = start;
2737
 
    chapter->end   = end;
2738
 
 
2739
 
    return chapter;
2740
 
}
2741
 
 
2742
 
/************************************************************/
2743
 
/* output media file */
2744
 
 
2745
 
#if FF_API_FORMAT_PARAMETERS
2746
 
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2747
 
{
2748
 
    int ret;
2749
 
 
2750
 
    if (s->oformat->priv_data_size > 0) {
2751
 
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2752
 
        if (!s->priv_data)
2753
 
            return AVERROR(ENOMEM);
2754
 
        if (s->oformat->priv_class) {
2755
 
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2756
 
            av_opt_set_defaults(s->priv_data);
2757
 
        }
2758
 
    } else
2759
 
        s->priv_data = NULL;
2760
 
 
2761
 
    if (s->oformat->set_parameters) {
2762
 
        ret = s->oformat->set_parameters(s, ap);
2763
 
        if (ret < 0)
2764
 
            return ret;
2765
 
    }
2766
 
    return 0;
2767
 
}
2768
 
#endif
2769
 
 
2770
 
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2771
 
{
2772
 
    const AVCodecTag *avctag;
2773
 
    int n;
2774
 
    enum CodecID id = CODEC_ID_NONE;
2775
 
    unsigned int tag = 0;
2776
 
 
2777
 
    /**
2778
 
     * Check that tag + id is in the table
2779
 
     * If neither is in the table -> OK
2780
 
     * If tag is in the table with another id -> FAIL
2781
 
     * If id is in the table with another tag -> FAIL unless strict < normal
2782
 
     */
2783
 
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2784
 
        avctag = s->oformat->codec_tag[n];
2785
 
        while (avctag->id != CODEC_ID_NONE) {
2786
 
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2787
 
                id = avctag->id;
2788
 
                if (id == st->codec->codec_id)
2789
 
                    return 1;
2790
 
            }
2791
 
            if (avctag->id == st->codec->codec_id)
2792
 
                tag = avctag->tag;
2793
 
            avctag++;
2794
 
        }
2795
 
    }
2796
 
    if (id != CODEC_ID_NONE)
2797
 
        return 0;
2798
 
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2799
 
        return 0;
2800
 
    return 1;
2801
 
}
2802
 
 
2803
 
#if FF_API_FORMAT_PARAMETERS
2804
 
int av_write_header(AVFormatContext *s)
2805
 
{
2806
 
    return avformat_write_header(s, NULL);
2807
 
}
2808
 
#endif
2809
 
 
2810
 
int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2811
 
{
2812
 
    int ret = 0, i;
2813
 
    AVStream *st;
2814
 
    AVDictionary *tmp = NULL;
2815
 
 
2816
 
    if (options)
2817
 
        av_dict_copy(&tmp, *options, 0);
2818
 
    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2819
 
        goto fail;
2820
 
 
2821
 
    // some sanity checks
2822
 
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2823
 
        av_log(s, AV_LOG_ERROR, "no streams\n");
2824
 
        ret = AVERROR(EINVAL);
2825
 
        goto fail;
2826
 
    }
2827
 
 
2828
 
    for(i=0;i<s->nb_streams;i++) {
2829
 
        st = s->streams[i];
2830
 
 
2831
 
        switch (st->codec->codec_type) {
2832
 
        case AVMEDIA_TYPE_AUDIO:
2833
 
            if(st->codec->sample_rate<=0){
2834
 
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2835
 
                ret = AVERROR(EINVAL);
2836
 
                goto fail;
2837
 
            }
2838
 
            if(!st->codec->block_align)
2839
 
                st->codec->block_align = st->codec->channels *
2840
 
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2841
 
            break;
2842
 
        case AVMEDIA_TYPE_VIDEO:
2843
 
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2844
 
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2845
 
                ret = AVERROR(EINVAL);
2846
 
                goto fail;
2847
 
            }
2848
 
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2849
 
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2850
 
                ret = AVERROR(EINVAL);
2851
 
                goto fail;
2852
 
            }
2853
 
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2854
 
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2855
 
                ret = AVERROR(EINVAL);
2856
 
                goto fail;
2857
 
            }
2858
 
            break;
2859
 
        }
2860
 
 
2861
 
        if(s->oformat->codec_tag){
2862
 
            if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2863
 
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2864
 
                st->codec->codec_tag= 0;
2865
 
            }
2866
 
            if(st->codec->codec_tag){
2867
 
                if (!validate_codec_tag(s, st)) {
2868
 
                    char tagbuf[32];
2869
 
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2870
 
                    av_log(s, AV_LOG_ERROR,
2871
 
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2872
 
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2873
 
                    ret = AVERROR_INVALIDDATA;
2874
 
                    goto fail;
2875
 
                }
2876
 
            }else
2877
 
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2878
 
        }
2879
 
 
2880
 
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2881
 
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2882
 
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2883
 
    }
2884
 
 
2885
 
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2886
 
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2887
 
        if (!s->priv_data) {
2888
 
            ret = AVERROR(ENOMEM);
2889
 
            goto fail;
2890
 
        }
2891
 
        if (s->oformat->priv_class) {
2892
 
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2893
 
            av_opt_set_defaults(s->priv_data);
2894
 
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2895
 
                goto fail;
2896
 
        }
2897
 
    }
2898
 
 
2899
 
    /* set muxer identification string */
2900
 
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2901
 
        av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2902
 
    }
2903
 
 
2904
 
    if(s->oformat->write_header){
2905
 
        ret = s->oformat->write_header(s);
2906
 
        if (ret < 0)
2907
 
            goto fail;
2908
 
    }
2909
 
 
2910
 
    /* init PTS generation */
2911
 
    for(i=0;i<s->nb_streams;i++) {
2912
 
        int64_t den = AV_NOPTS_VALUE;
2913
 
        st = s->streams[i];
2914
 
 
2915
 
        switch (st->codec->codec_type) {
2916
 
        case AVMEDIA_TYPE_AUDIO:
2917
 
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2918
 
            break;
2919
 
        case AVMEDIA_TYPE_VIDEO:
2920
 
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2921
 
            break;
2922
 
        default:
2923
 
            break;
2924
 
        }
2925
 
        if (den != AV_NOPTS_VALUE) {
2926
 
            if (den <= 0) {
2927
 
                ret = AVERROR_INVALIDDATA;
2928
 
                goto fail;
2929
 
            }
2930
 
            av_frac_init(&st->pts, 0, 0, den);
2931
 
        }
2932
 
    }
2933
 
 
2934
 
    if (options) {
2935
 
        av_dict_free(options);
2936
 
        *options = tmp;
2937
 
    }
2938
 
    return 0;
2939
 
fail:
2940
 
    av_dict_free(&tmp);
2941
 
    return ret;
2942
 
}
2943
 
 
2944
 
//FIXME merge with compute_pkt_fields
2945
 
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2946
 
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2947
 
    int num, den, frame_size, i;
2948
 
 
2949
 
    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2950
 
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2951
 
 
2952
 
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2953
 
        return AVERROR(EINVAL);*/
2954
 
 
2955
 
    /* duration field */
2956
 
    if (pkt->duration == 0) {
2957
 
        compute_frame_duration(&num, &den, st, NULL, pkt);
2958
 
        if (den && num) {
2959
 
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2960
 
        }
2961
 
    }
2962
 
 
2963
 
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2964
 
        pkt->pts= pkt->dts;
2965
 
 
2966
 
    //XXX/FIXME this is a temporary hack until all encoders output pts
2967
 
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2968
 
        pkt->dts=
2969
 
//        pkt->pts= st->cur_dts;
2970
 
        pkt->pts= st->pts.val;
2971
 
    }
2972
 
 
2973
 
    //calculate dts from pts
2974
 
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2975
 
        st->pts_buffer[0]= pkt->pts;
2976
 
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2977
 
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2978
 
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2979
 
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2980
 
 
2981
 
        pkt->dts= st->pts_buffer[0];
2982
 
    }
2983
 
 
2984
 
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2985
 
        av_log(s, AV_LOG_ERROR,
2986
 
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2987
 
               st->index, st->cur_dts, pkt->dts);
2988
 
        return AVERROR(EINVAL);
2989
 
    }
2990
 
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2991
 
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2992
 
        return AVERROR(EINVAL);
2993
 
    }
2994
 
 
2995
 
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2996
 
    st->cur_dts= pkt->dts;
2997
 
    st->pts.val= pkt->dts;
2998
 
 
2999
 
    /* update pts */
3000
 
    switch (st->codec->codec_type) {
3001
 
    case AVMEDIA_TYPE_AUDIO:
3002
 
        frame_size = get_audio_frame_size(st->codec, pkt->size);
3003
 
 
3004
 
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
3005
 
           likely equal to the encoder delay, but it would be better if we
3006
 
           had the real timestamps from the encoder */
3007
 
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3008
 
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3009
 
        }
3010
 
        break;
3011
 
    case AVMEDIA_TYPE_VIDEO:
3012
 
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3013
 
        break;
3014
 
    default:
3015
 
        break;
3016
 
    }
3017
 
    return 0;
3018
 
}
3019
 
 
3020
 
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3021
 
{
3022
 
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3023
 
 
3024
 
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3025
 
        return ret;
3026
 
 
3027
 
    ret= s->oformat->write_packet(s, pkt);
3028
 
    return ret;
3029
 
}
3030
 
 
3031
 
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3032
 
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3033
 
{
3034
 
    AVPacketList **next_point, *this_pktl;
3035
 
 
3036
 
    this_pktl = av_mallocz(sizeof(AVPacketList));
3037
 
    this_pktl->pkt= *pkt;
3038
 
    pkt->destruct= NULL;             // do not free original but only the copy
3039
 
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3040
 
 
3041
 
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3042
 
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3043
 
    }else
3044
 
        next_point = &s->packet_buffer;
3045
 
 
3046
 
    if(*next_point){
3047
 
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3048
 
            while(!compare(s, &(*next_point)->pkt, pkt)){
3049
 
                next_point= &(*next_point)->next;
3050
 
            }
3051
 
            goto next_non_null;
3052
 
        }else{
3053
 
            next_point = &(s->packet_buffer_end->next);
3054
 
        }
3055
 
    }
3056
 
    assert(!*next_point);
3057
 
 
3058
 
    s->packet_buffer_end= this_pktl;
3059
 
next_non_null:
3060
 
 
3061
 
    this_pktl->next= *next_point;
3062
 
 
3063
 
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3064
 
    *next_point= this_pktl;
3065
 
}
3066
 
 
3067
 
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3068
 
{
3069
 
    AVStream *st = s->streams[ pkt ->stream_index];
3070
 
    AVStream *st2= s->streams[ next->stream_index];
3071
 
    int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3072
 
                             st->time_base);
3073
 
 
3074
 
    if (comp == 0)
3075
 
        return pkt->stream_index < next->stream_index;
3076
 
    return comp > 0;
3077
 
}
3078
 
 
3079
 
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3080
 
    AVPacketList *pktl;
3081
 
    int stream_count=0;
3082
 
    int i;
3083
 
 
3084
 
    if(pkt){
3085
 
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3086
 
    }
3087
 
 
3088
 
    for(i=0; i < s->nb_streams; i++)
3089
 
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3090
 
 
3091
 
    if(stream_count && (s->nb_streams == stream_count || flush)){
3092
 
        pktl= s->packet_buffer;
3093
 
        *out= pktl->pkt;
3094
 
 
3095
 
        s->packet_buffer= pktl->next;
3096
 
        if(!s->packet_buffer)
3097
 
            s->packet_buffer_end= NULL;
3098
 
 
3099
 
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3100
 
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3101
 
        av_freep(&pktl);
3102
 
        return 1;
3103
 
    }else{
3104
 
        av_init_packet(out);
3105
 
        return 0;
3106
 
    }
3107
 
}
3108
 
 
3109
 
/**
3110
 
 * Interleave an AVPacket correctly so it can be muxed.
3111
 
 * @param out the interleaved packet will be output here
3112
 
 * @param in the input packet
3113
 
 * @param flush 1 if no further packets are available as input and all
3114
 
 *              remaining packets should be output
3115
 
 * @return 1 if a packet was output, 0 if no packet could be output,
3116
 
 *         < 0 if an error occurred
3117
 
 */
3118
 
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3119
 
    if(s->oformat->interleave_packet)
3120
 
        return s->oformat->interleave_packet(s, out, in, flush);
3121
 
    else
3122
 
        return av_interleave_packet_per_dts(s, out, in, flush);
3123
 
}
3124
 
 
3125
 
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3126
 
    AVStream *st= s->streams[ pkt->stream_index];
3127
 
    int ret;
3128
 
 
3129
 
    //FIXME/XXX/HACK drop zero sized packets
3130
 
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3131
 
        return 0;
3132
 
 
3133
 
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3134
 
            pkt->size, pkt->dts, pkt->pts);
3135
 
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3136
 
        return ret;
3137
 
 
3138
 
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3139
 
        return AVERROR(EINVAL);
3140
 
 
3141
 
    for(;;){
3142
 
        AVPacket opkt;
3143
 
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3144
 
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3145
 
            return ret;
3146
 
 
3147
 
        ret= s->oformat->write_packet(s, &opkt);
3148
 
 
3149
 
        av_free_packet(&opkt);
3150
 
        pkt= NULL;
3151
 
 
3152
 
        if(ret<0)
3153
 
            return ret;
3154
 
    }
3155
 
}
3156
 
 
3157
 
int av_write_trailer(AVFormatContext *s)
3158
 
{
3159
 
    int ret, i;
3160
 
 
3161
 
    for(;;){
3162
 
        AVPacket pkt;
3163
 
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3164
 
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3165
 
            goto fail;
3166
 
        if(!ret)
3167
 
            break;
3168
 
 
3169
 
        ret= s->oformat->write_packet(s, &pkt);
3170
 
 
3171
 
        av_free_packet(&pkt);
3172
 
 
3173
 
        if(ret<0)
3174
 
            goto fail;
3175
 
    }
3176
 
 
3177
 
    if(s->oformat->write_trailer)
3178
 
        ret = s->oformat->write_trailer(s);
3179
 
fail:
3180
 
    for(i=0;i<s->nb_streams;i++) {
3181
 
        av_freep(&s->streams[i]->priv_data);
3182
 
        av_freep(&s->streams[i]->index_entries);
3183
 
    }
3184
 
    if (s->iformat && s->iformat->priv_class)
3185
 
        av_opt_free(s->priv_data);
3186
 
    av_freep(&s->priv_data);
3187
 
    return ret;
3188
 
}
3189
 
 
3190
 
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3191
 
{
3192
 
    int i, j;
3193
 
    AVProgram *program=NULL;
3194
 
    void *tmp;
3195
 
 
3196
 
    if (idx >= ac->nb_streams) {
3197
 
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3198
 
        return;
3199
 
    }
3200
 
 
3201
 
    for(i=0; i<ac->nb_programs; i++){
3202
 
        if(ac->programs[i]->id != progid)
3203
 
            continue;
3204
 
        program = ac->programs[i];
3205
 
        for(j=0; j<program->nb_stream_indexes; j++)
3206
 
            if(program->stream_index[j] == idx)
3207
 
                return;
3208
 
 
3209
 
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3210
 
        if(!tmp)
3211
 
            return;
3212
 
        program->stream_index = tmp;
3213
 
        program->stream_index[program->nb_stream_indexes++] = idx;
3214
 
        return;
3215
 
    }
3216
 
}
3217
 
 
3218
 
static void print_fps(double d, const char *postfix){
3219
 
    uint64_t v= lrintf(d*100);
3220
 
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3221
 
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3222
 
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3223
 
}
3224
 
 
3225
 
static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3226
 
{
3227
 
    if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3228
 
        AVDictionaryEntry *tag=NULL;
3229
 
 
3230
 
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3231
 
        while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3232
 
            if(strcmp("language", tag->key))
3233
 
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3234
 
        }
3235
 
    }
3236
 
}
3237
 
 
3238
 
/* "user interface" functions */
3239
 
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3240
 
{
3241
 
    char buf[256];
3242
 
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3243
 
    AVStream *st = ic->streams[i];
3244
 
    int g = av_gcd(st->time_base.num, st->time_base.den);
3245
 
    AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3246
 
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3247
 
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3248
 
    /* the pid is an important information, so we display it */
3249
 
    /* XXX: add a generic system */
3250
 
    if (flags & AVFMT_SHOW_IDS)
3251
 
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3252
 
    if (lang)
3253
 
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3254
 
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3255
 
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3256
 
    if (st->sample_aspect_ratio.num && // default
3257
 
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3258
 
        AVRational display_aspect_ratio;
3259
 
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3260
 
                  st->codec->width*st->sample_aspect_ratio.num,
3261
 
                  st->codec->height*st->sample_aspect_ratio.den,
3262
 
                  1024*1024);
3263
 
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3264
 
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3265
 
                 display_aspect_ratio.num, display_aspect_ratio.den);
3266
 
    }
3267
 
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3268
 
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3269
 
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3270
 
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3271
 
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3272
 
        if(st->time_base.den && st->time_base.num)
3273
 
            print_fps(1/av_q2d(st->time_base), "tbn");
3274
 
        if(st->codec->time_base.den && st->codec->time_base.num)
3275
 
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3276
 
    }
3277
 
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3278
 
        av_log(NULL, AV_LOG_INFO, " (default)");
3279
 
    if (st->disposition & AV_DISPOSITION_DUB)
3280
 
        av_log(NULL, AV_LOG_INFO, " (dub)");
3281
 
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3282
 
        av_log(NULL, AV_LOG_INFO, " (original)");
3283
 
    if (st->disposition & AV_DISPOSITION_COMMENT)
3284
 
        av_log(NULL, AV_LOG_INFO, " (comment)");
3285
 
    if (st->disposition & AV_DISPOSITION_LYRICS)
3286
 
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3287
 
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3288
 
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3289
 
    if (st->disposition & AV_DISPOSITION_FORCED)
3290
 
        av_log(NULL, AV_LOG_INFO, " (forced)");
3291
 
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3292
 
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3293
 
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3294
 
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3295
 
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3296
 
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3297
 
    av_log(NULL, AV_LOG_INFO, "\n");
3298
 
    dump_metadata(NULL, st->metadata, "    ");
3299
 
}
3300
 
 
3301
 
#if FF_API_DUMP_FORMAT
3302
 
void dump_format(AVFormatContext *ic,
3303
 
                 int index,
3304
 
                 const char *url,
3305
 
                 int is_output)
3306
 
{
3307
 
    av_dump_format(ic, index, url, is_output);
3308
 
}
3309
 
#endif
3310
 
 
3311
 
void av_dump_format(AVFormatContext *ic,
3312
 
                    int index,
3313
 
                    const char *url,
3314
 
                    int is_output)
3315
 
{
3316
 
    int i;
3317
 
    uint8_t *printed = av_mallocz(ic->nb_streams);
3318
 
    if (ic->nb_streams && !printed)
3319
 
        return;
3320
 
 
3321
 
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3322
 
            is_output ? "Output" : "Input",
3323
 
            index,
3324
 
            is_output ? ic->oformat->name : ic->iformat->name,
3325
 
            is_output ? "to" : "from", url);
3326
 
    dump_metadata(NULL, ic->metadata, "  ");
3327
 
    if (!is_output) {
3328
 
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3329
 
        if (ic->duration != AV_NOPTS_VALUE) {
3330
 
            int hours, mins, secs, us;
3331
 
            secs = ic->duration / AV_TIME_BASE;
3332
 
            us = ic->duration % AV_TIME_BASE;
3333
 
            mins = secs / 60;
3334
 
            secs %= 60;
3335
 
            hours = mins / 60;
3336
 
            mins %= 60;
3337
 
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3338
 
                   (100 * us) / AV_TIME_BASE);
3339
 
        } else {
3340
 
            av_log(NULL, AV_LOG_INFO, "N/A");
3341
 
        }
3342
 
        if (ic->start_time != AV_NOPTS_VALUE) {
3343
 
            int secs, us;
3344
 
            av_log(NULL, AV_LOG_INFO, ", start: ");
3345
 
            secs = ic->start_time / AV_TIME_BASE;
3346
 
            us = abs(ic->start_time % AV_TIME_BASE);
3347
 
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3348
 
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3349
 
        }
3350
 
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3351
 
        if (ic->bit_rate) {
3352
 
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3353
 
        } else {
3354
 
            av_log(NULL, AV_LOG_INFO, "N/A");
3355
 
        }
3356
 
        av_log(NULL, AV_LOG_INFO, "\n");
3357
 
    }
3358
 
    for (i = 0; i < ic->nb_chapters; i++) {
3359
 
        AVChapter *ch = ic->chapters[i];
3360
 
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3361
 
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3362
 
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3363
 
 
3364
 
        dump_metadata(NULL, ch->metadata, "    ");
3365
 
    }
3366
 
    if(ic->nb_programs) {
3367
 
        int j, k, total = 0;
3368
 
        for(j=0; j<ic->nb_programs; j++) {
3369
 
            AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3370
 
                                                  "name", NULL, 0);
3371
 
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3372
 
                   name ? name->value : "");
3373
 
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3374
 
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3375
 
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3376
 
                printed[ic->programs[j]->stream_index[k]] = 1;
3377
 
            }
3378
 
            total += ic->programs[j]->nb_stream_indexes;
3379
 
        }
3380
 
        if (total < ic->nb_streams)
3381
 
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3382
 
    }
3383
 
    for(i=0;i<ic->nb_streams;i++)
3384
 
        if (!printed[i])
3385
 
            dump_stream_format(ic, i, index, is_output);
3386
 
 
3387
 
    av_free(printed);
3388
 
}
3389
 
 
3390
 
int64_t av_gettime(void)
3391
 
{
3392
 
    struct timeval tv;
3393
 
    gettimeofday(&tv,NULL);
3394
 
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3395
 
}
3396
 
 
3397
 
uint64_t ff_ntp_time(void)
3398
 
{
3399
 
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3400
 
}
3401
 
 
3402
 
#if FF_API_PARSE_DATE
3403
 
#include "libavutil/parseutils.h"
3404
 
 
3405
 
int64_t parse_date(const char *timestr, int duration)
3406
 
{
3407
 
    int64_t timeval;
3408
 
    av_parse_time(&timeval, timestr, duration);
3409
 
    return timeval;
3410
 
}
3411
 
#endif
3412
 
 
3413
 
#if FF_API_FIND_INFO_TAG
3414
 
#include "libavutil/parseutils.h"
3415
 
 
3416
 
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3417
 
{
3418
 
    return av_find_info_tag(arg, arg_size, tag1, info);
3419
 
}
3420
 
#endif
3421
 
 
3422
 
int av_get_frame_filename(char *buf, int buf_size,
3423
 
                          const char *path, int number)
3424
 
{
3425
 
    const char *p;
3426
 
    char *q, buf1[20], c;
3427
 
    int nd, len, percentd_found;
3428
 
 
3429
 
    q = buf;
3430
 
    p = path;
3431
 
    percentd_found = 0;
3432
 
    for(;;) {
3433
 
        c = *p++;
3434
 
        if (c == '\0')
3435
 
            break;
3436
 
        if (c == '%') {
3437
 
            do {
3438
 
                nd = 0;
3439
 
                while (isdigit(*p)) {
3440
 
                    nd = nd * 10 + *p++ - '0';
3441
 
                }
3442
 
                c = *p++;
3443
 
            } while (isdigit(c));
3444
 
 
3445
 
            switch(c) {
3446
 
            case '%':
3447
 
                goto addchar;
3448
 
            case 'd':
3449
 
                if (percentd_found)
3450
 
                    goto fail;
3451
 
                percentd_found = 1;
3452
 
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3453
 
                len = strlen(buf1);
3454
 
                if ((q - buf + len) > buf_size - 1)
3455
 
                    goto fail;
3456
 
                memcpy(q, buf1, len);
3457
 
                q += len;
3458
 
                break;
3459
 
            default:
3460
 
                goto fail;
3461
 
            }
3462
 
        } else {
3463
 
        addchar:
3464
 
            if ((q - buf) < buf_size - 1)
3465
 
                *q++ = c;
3466
 
        }
3467
 
    }
3468
 
    if (!percentd_found)
3469
 
        goto fail;
3470
 
    *q = '\0';
3471
 
    return 0;
3472
 
 fail:
3473
 
    *q = '\0';
3474
 
    return -1;
3475
 
}
3476
 
 
3477
 
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3478
 
{
3479
 
    int len, i, j, c;
3480
 
#undef fprintf
3481
 
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3482
 
 
3483
 
    for(i=0;i<size;i+=16) {
3484
 
        len = size - i;
3485
 
        if (len > 16)
3486
 
            len = 16;
3487
 
        PRINT("%08x ", i);
3488
 
        for(j=0;j<16;j++) {
3489
 
            if (j < len)
3490
 
                PRINT(" %02x", buf[i+j]);
3491
 
            else
3492
 
                PRINT("   ");
3493
 
        }
3494
 
        PRINT(" ");
3495
 
        for(j=0;j<len;j++) {
3496
 
            c = buf[i+j];
3497
 
            if (c < ' ' || c > '~')
3498
 
                c = '.';
3499
 
            PRINT("%c", c);
3500
 
        }
3501
 
        PRINT("\n");
3502
 
    }
3503
 
#undef PRINT
3504
 
}
3505
 
 
3506
 
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3507
 
{
3508
 
    hex_dump_internal(NULL, f, 0, buf, size);
3509
 
}
3510
 
 
3511
 
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3512
 
{
3513
 
    hex_dump_internal(avcl, NULL, level, buf, size);
3514
 
}
3515
 
 
3516
 
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3517
 
{
3518
 
#undef fprintf
3519
 
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3520
 
    PRINT("stream #%d:\n", pkt->stream_index);
3521
 
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3522
 
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3523
 
    /* DTS is _always_ valid after av_read_frame() */
3524
 
    PRINT("  dts=");
3525
 
    if (pkt->dts == AV_NOPTS_VALUE)
3526
 
        PRINT("N/A");
3527
 
    else
3528
 
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3529
 
    /* PTS may not be known if B-frames are present. */
3530
 
    PRINT("  pts=");
3531
 
    if (pkt->pts == AV_NOPTS_VALUE)
3532
 
        PRINT("N/A");
3533
 
    else
3534
 
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3535
 
    PRINT("\n");
3536
 
    PRINT("  size=%d\n", pkt->size);
3537
 
#undef PRINT
3538
 
    if (dump_payload)
3539
 
        av_hex_dump(f, pkt->data, pkt->size);
3540
 
}
3541
 
 
3542
 
#if FF_API_PKT_DUMP
3543
 
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3544
 
{
3545
 
    AVRational tb = { 1, AV_TIME_BASE };
3546
 
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3547
 
}
3548
 
#endif
3549
 
 
3550
 
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3551
 
{
3552
 
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3553
 
}
3554
 
 
3555
 
#if FF_API_PKT_DUMP
3556
 
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3557
 
{
3558
 
    AVRational tb = { 1, AV_TIME_BASE };
3559
 
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3560
 
}
3561
 
#endif
3562
 
 
3563
 
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3564
 
                      AVStream *st)
3565
 
{
3566
 
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3567
 
}
3568
 
 
3569
 
void av_url_split(char *proto, int proto_size,
3570
 
                  char *authorization, int authorization_size,
3571
 
                  char *hostname, int hostname_size,
3572
 
                  int *port_ptr,
3573
 
                  char *path, int path_size,
3574
 
                  const char *url)
3575
 
{
3576
 
    const char *p, *ls, *at, *col, *brk;
3577
 
 
3578
 
    if (port_ptr)               *port_ptr = -1;
3579
 
    if (proto_size > 0)         proto[0] = 0;
3580
 
    if (authorization_size > 0) authorization[0] = 0;
3581
 
    if (hostname_size > 0)      hostname[0] = 0;
3582
 
    if (path_size > 0)          path[0] = 0;
3583
 
 
3584
 
    /* parse protocol */
3585
 
    if ((p = strchr(url, ':'))) {
3586
 
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3587
 
        p++; /* skip ':' */
3588
 
        if (*p == '/') p++;
3589
 
        if (*p == '/') p++;
3590
 
    } else {
3591
 
        /* no protocol means plain filename */
3592
 
        av_strlcpy(path, url, path_size);
3593
 
        return;
3594
 
    }
3595
 
 
3596
 
    /* separate path from hostname */
3597
 
    ls = strchr(p, '/');
3598
 
    if(!ls)
3599
 
        ls = strchr(p, '?');
3600
 
    if(ls)
3601
 
        av_strlcpy(path, ls, path_size);
3602
 
    else
3603
 
        ls = &p[strlen(p)]; // XXX
3604
 
 
3605
 
    /* the rest is hostname, use that to parse auth/port */
3606
 
    if (ls != p) {
3607
 
        /* authorization (user[:pass]@hostname) */
3608
 
        if ((at = strchr(p, '@')) && at < ls) {
3609
 
            av_strlcpy(authorization, p,
3610
 
                       FFMIN(authorization_size, at + 1 - p));
3611
 
            p = at + 1; /* skip '@' */
3612
 
        }
3613
 
 
3614
 
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3615
 
            /* [host]:port */
3616
 
            av_strlcpy(hostname, p + 1,
3617
 
                       FFMIN(hostname_size, brk - p));
3618
 
            if (brk[1] == ':' && port_ptr)
3619
 
                *port_ptr = atoi(brk + 2);
3620
 
        } else if ((col = strchr(p, ':')) && col < ls) {
3621
 
            av_strlcpy(hostname, p,
3622
 
                       FFMIN(col + 1 - p, hostname_size));
3623
 
            if (port_ptr) *port_ptr = atoi(col + 1);
3624
 
        } else
3625
 
            av_strlcpy(hostname, p,
3626
 
                       FFMIN(ls + 1 - p, hostname_size));
3627
 
    }
3628
 
}
3629
 
 
3630
 
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3631
 
{
3632
 
    int i;
3633
 
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3634
 
                                           '4', '5', '6', '7',
3635
 
                                           '8', '9', 'A', 'B',
3636
 
                                           'C', 'D', 'E', 'F' };
3637
 
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3638
 
                                           '4', '5', '6', '7',
3639
 
                                           '8', '9', 'a', 'b',
3640
 
                                           'c', 'd', 'e', 'f' };
3641
 
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3642
 
 
3643
 
    for(i = 0; i < s; i++) {
3644
 
        buff[i * 2]     = hex_table[src[i] >> 4];
3645
 
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3646
 
    }
3647
 
 
3648
 
    return buff;
3649
 
}
3650
 
 
3651
 
int ff_hex_to_data(uint8_t *data, const char *p)
3652
 
{
3653
 
    int c, len, v;
3654
 
 
3655
 
    len = 0;
3656
 
    v = 1;
3657
 
    for (;;) {
3658
 
        p += strspn(p, SPACE_CHARS);
3659
 
        if (*p == '\0')
3660
 
            break;
3661
 
        c = toupper((unsigned char) *p++);
3662
 
        if (c >= '0' && c <= '9')
3663
 
            c = c - '0';
3664
 
        else if (c >= 'A' && c <= 'F')
3665
 
            c = c - 'A' + 10;
3666
 
        else
3667
 
            break;
3668
 
        v = (v << 4) | c;
3669
 
        if (v & 0x100) {
3670
 
            if (data)
3671
 
                data[len] = v;
3672
 
            len++;
3673
 
            v = 1;
3674
 
        }
3675
 
    }
3676
 
    return len;
3677
 
}
3678
 
 
3679
 
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3680
 
                     unsigned int pts_num, unsigned int pts_den)
3681
 
{
3682
 
    AVRational new_tb;
3683
 
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3684
 
        if(new_tb.num != pts_num)
3685
 
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3686
 
    }else
3687
 
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3688
 
 
3689
 
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3690
 
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3691
 
        return;
3692
 
    }
3693
 
    s->time_base = new_tb;
3694
 
    s->pts_wrap_bits = pts_wrap_bits;
3695
 
}
3696
 
 
3697
 
int ff_url_join(char *str, int size, const char *proto,
3698
 
                const char *authorization, const char *hostname,
3699
 
                int port, const char *fmt, ...)
3700
 
{
3701
 
#if CONFIG_NETWORK
3702
 
    struct addrinfo hints, *ai;
3703
 
#endif
3704
 
 
3705
 
    str[0] = '\0';
3706
 
    if (proto)
3707
 
        av_strlcatf(str, size, "%s://", proto);
3708
 
    if (authorization && authorization[0])
3709
 
        av_strlcatf(str, size, "%s@", authorization);
3710
 
#if CONFIG_NETWORK && defined(AF_INET6)
3711
 
    /* Determine if hostname is a numerical IPv6 address,
3712
 
     * properly escape it within [] in that case. */
3713
 
    memset(&hints, 0, sizeof(hints));
3714
 
    hints.ai_flags = AI_NUMERICHOST;
3715
 
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3716
 
        if (ai->ai_family == AF_INET6) {
3717
 
            av_strlcat(str, "[", size);
3718
 
            av_strlcat(str, hostname, size);
3719
 
            av_strlcat(str, "]", size);
3720
 
        } else {
3721
 
            av_strlcat(str, hostname, size);
3722
 
        }
3723
 
        freeaddrinfo(ai);
3724
 
    } else
3725
 
#endif
3726
 
        /* Not an IPv6 address, just output the plain string. */
3727
 
        av_strlcat(str, hostname, size);
3728
 
 
3729
 
    if (port >= 0)
3730
 
        av_strlcatf(str, size, ":%d", port);
3731
 
    if (fmt) {
3732
 
        va_list vl;
3733
 
        int len = strlen(str);
3734
 
 
3735
 
        va_start(vl, fmt);
3736
 
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3737
 
        va_end(vl);
3738
 
    }
3739
 
    return strlen(str);
3740
 
}
3741
 
 
3742
 
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3743
 
                     AVFormatContext *src)
3744
 
{
3745
 
    AVPacket local_pkt;
3746
 
 
3747
 
    local_pkt = *pkt;
3748
 
    local_pkt.stream_index = dst_stream;
3749
 
    if (pkt->pts != AV_NOPTS_VALUE)
3750
 
        local_pkt.pts = av_rescale_q(pkt->pts,
3751
 
                                     src->streams[pkt->stream_index]->time_base,
3752
 
                                     dst->streams[dst_stream]->time_base);
3753
 
    if (pkt->dts != AV_NOPTS_VALUE)
3754
 
        local_pkt.dts = av_rescale_q(pkt->dts,
3755
 
                                     src->streams[pkt->stream_index]->time_base,
3756
 
                                     dst->streams[dst_stream]->time_base);
3757
 
    return av_write_frame(dst, &local_pkt);
3758
 
}
3759
 
 
3760
 
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3761
 
                        void *context)
3762
 
{
3763
 
    const char *ptr = str;
3764
 
 
3765
 
    /* Parse key=value pairs. */
3766
 
    for (;;) {
3767
 
        const char *key;
3768
 
        char *dest = NULL, *dest_end;
3769
 
        int key_len, dest_len = 0;
3770
 
 
3771
 
        /* Skip whitespace and potential commas. */
3772
 
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3773
 
            ptr++;
3774
 
        if (!*ptr)
3775
 
            break;
3776
 
 
3777
 
        key = ptr;
3778
 
 
3779
 
        if (!(ptr = strchr(key, '=')))
3780
 
            break;
3781
 
        ptr++;
3782
 
        key_len = ptr - key;
3783
 
 
3784
 
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3785
 
        dest_end = dest + dest_len - 1;
3786
 
 
3787
 
        if (*ptr == '\"') {
3788
 
            ptr++;
3789
 
            while (*ptr && *ptr != '\"') {
3790
 
                if (*ptr == '\\') {
3791
 
                    if (!ptr[1])
3792
 
                        break;
3793
 
                    if (dest && dest < dest_end)
3794
 
                        *dest++ = ptr[1];
3795
 
                    ptr += 2;
3796
 
                } else {
3797
 
                    if (dest && dest < dest_end)
3798
 
                        *dest++ = *ptr;
3799
 
                    ptr++;
3800
 
                }
3801
 
            }
3802
 
            if (*ptr == '\"')
3803
 
                ptr++;
3804
 
        } else {
3805
 
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3806
 
                if (dest && dest < dest_end)
3807
 
                    *dest++ = *ptr;
3808
 
        }
3809
 
        if (dest)
3810
 
            *dest = 0;
3811
 
    }
3812
 
}
3813
 
 
3814
 
int ff_find_stream_index(AVFormatContext *s, int id)
3815
 
{
3816
 
    int i;
3817
 
    for (i = 0; i < s->nb_streams; i++) {
3818
 
        if (s->streams[i]->id == id)
3819
 
            return i;
3820
 
    }
3821
 
    return -1;
3822
 
}
3823
 
 
3824
 
void ff_make_absolute_url(char *buf, int size, const char *base,
3825
 
                          const char *rel)
3826
 
{
3827
 
    char *sep;
3828
 
    /* Absolute path, relative to the current server */
3829
 
    if (base && strstr(base, "://") && rel[0] == '/') {
3830
 
        if (base != buf)
3831
 
            av_strlcpy(buf, base, size);
3832
 
        sep = strstr(buf, "://");
3833
 
        if (sep) {
3834
 
            sep += 3;
3835
 
            sep = strchr(sep, '/');
3836
 
            if (sep)
3837
 
                *sep = '\0';
3838
 
        }
3839
 
        av_strlcat(buf, rel, size);
3840
 
        return;
3841
 
    }
3842
 
    /* If rel actually is an absolute url, just copy it */
3843
 
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3844
 
        av_strlcpy(buf, rel, size);
3845
 
        return;
3846
 
    }
3847
 
    if (base != buf)
3848
 
        av_strlcpy(buf, base, size);
3849
 
    /* Remove the file name from the base url */
3850
 
    sep = strrchr(buf, '/');
3851
 
    if (sep)
3852
 
        sep[1] = '\0';
3853
 
    else
3854
 
        buf[0] = '\0';
3855
 
    while (av_strstart(rel, "../", NULL) && sep) {
3856
 
        /* Remove the path delimiter at the end */
3857
 
        sep[0] = '\0';
3858
 
        sep = strrchr(buf, '/');
3859
 
        /* If the next directory name to pop off is "..", break here */
3860
 
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3861
 
            /* Readd the slash we just removed */
3862
 
            av_strlcat(buf, "/", size);
3863
 
            break;
3864
 
        }
3865
 
        /* Cut off the directory name */
3866
 
        if (sep)
3867
 
            sep[1] = '\0';
3868
 
        else
3869
 
            buf[0] = '\0';
3870
 
        rel += 3;
3871
 
    }
3872
 
    av_strlcat(buf, rel, size);
3873
 
}