Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 19 Aug 2012 12:55:58 +0000 (14:55 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 19 Aug 2012 12:55:58 +0000 (14:55 +0200)
* qatar/master:
  vorbisdec: remove some pointless comments
  avprobe: add const to AVCodec pointer
  libavformat: add const to AVCodec pointers
  pthread: add const to AVCodec pointers

Conflicts:
ffprobe.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
ffprobe.c
libavcodec/pthread.c
libavcodec/vorbisdec.c
libavformat/utils.c

diff --combined ffprobe.c
index a40f756,0000000..95548c7
mode 100644,000000..100644
--- /dev/null
+++ b/ffprobe.c
@@@ -1,2206 -1,0 +1,2206 @@@
-     AVCodec *dec;
 +/*
 + * Copyright (c) 2007-2010 Stefano Sabatini
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * simple media prober based on the FFmpeg libraries
 + */
 +
 +#include "config.h"
 +#include "version.h"
 +
 +#include "libavformat/avformat.h"
 +#include "libavcodec/avcodec.h"
 +#include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavutil/dict.h"
 +#include "libavutil/libm.h"
 +#include "libavutil/timecode.h"
 +#include "libavdevice/avdevice.h"
 +#include "libswscale/swscale.h"
 +#include "libswresample/swresample.h"
 +#include "libpostproc/postprocess.h"
 +#include "cmdutils.h"
 +
 +const char program_name[] = "ffprobe";
 +const int program_birth_year = 2007;
 +
 +static int do_count_frames = 0;
 +static int do_count_packets = 0;
 +static int do_read_frames  = 0;
 +static int do_read_packets = 0;
 +static int do_show_error   = 0;
 +static int do_show_format  = 0;
 +static int do_show_frames  = 0;
 +static AVDictionary *fmt_entries_to_show = NULL;
 +static int do_show_packets = 0;
 +static int do_show_streams = 0;
 +static int do_show_data    = 0;
 +static int do_show_program_version  = 0;
 +static int do_show_library_versions = 0;
 +
 +static int show_value_unit              = 0;
 +static int use_value_prefix             = 0;
 +static int use_byte_value_binary_prefix = 0;
 +static int use_value_sexagesimal_format = 0;
 +static int show_private_data            = 1;
 +
 +static char *print_format;
 +
 +static const OptionDef *options;
 +
 +/* FFprobe context */
 +static const char *input_filename;
 +static AVInputFormat *iformat = NULL;
 +
 +static const char *const binary_unit_prefixes [] = { "", "Ki", "Mi", "Gi", "Ti", "Pi" };
 +static const char *const decimal_unit_prefixes[] = { "", "K" , "M" , "G" , "T" , "P"  };
 +
 +static const char unit_second_str[]         = "s"    ;
 +static const char unit_hertz_str[]          = "Hz"   ;
 +static const char unit_byte_str[]           = "byte" ;
 +static const char unit_bit_per_second_str[] = "bit/s";
 +static uint64_t *nb_streams_packets;
 +static uint64_t *nb_streams_frames;
 +
 +void av_noreturn exit_program(int ret)
 +{
 +    av_dict_free(&fmt_entries_to_show);
 +    exit(ret);
 +}
 +
 +struct unit_value {
 +    union { double d; long long int i; } val;
 +    const char *unit;
 +};
 +
 +static char *value_string(char *buf, int buf_size, struct unit_value uv)
 +{
 +    double vald;
 +    int show_float = 0;
 +
 +    if (uv.unit == unit_second_str) {
 +        vald = uv.val.d;
 +        show_float = 1;
 +    } else {
 +        vald = uv.val.i;
 +    }
 +
 +    if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
 +        double secs;
 +        int hours, mins;
 +        secs  = vald;
 +        mins  = (int)secs / 60;
 +        secs  = secs - mins * 60;
 +        hours = mins / 60;
 +        mins %= 60;
 +        snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
 +    } else {
 +        const char *prefix_string = "";
 +        int l;
 +
 +        if (use_value_prefix && vald > 1) {
 +            long long int index;
 +
 +            if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
 +                index = (long long int) (log2(vald)) / 10;
 +                index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);
 +                vald /= pow(2, index * 10);
 +                prefix_string = binary_unit_prefixes[index];
 +            } else {
 +                index = (long long int) (log10(vald)) / 3;
 +                index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) - 1);
 +                vald /= pow(10, index * 3);
 +                prefix_string = decimal_unit_prefixes[index];
 +            }
 +        }
 +
 +        if (show_float || (use_value_prefix && vald != (long long int)vald))
 +            l = snprintf(buf, buf_size, "%f", vald);
 +        else
 +            l = snprintf(buf, buf_size, "%lld", (long long int)vald);
 +        snprintf(buf+l, buf_size-l, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
 +                 prefix_string, show_value_unit ? uv.unit : "");
 +    }
 +
 +    return buf;
 +}
 +
 +/* WRITERS API */
 +
 +typedef struct WriterContext WriterContext;
 +
 +#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
 +#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
 +
 +typedef struct Writer {
 +    int priv_size;                  ///< private size for the writer context
 +    const char *name;
 +
 +    int  (*init)  (WriterContext *wctx, const char *args, void *opaque);
 +    void (*uninit)(WriterContext *wctx);
 +
 +    void (*print_header)(WriterContext *ctx);
 +    void (*print_footer)(WriterContext *ctx);
 +
 +    void (*print_chapter_header)(WriterContext *wctx, const char *);
 +    void (*print_chapter_footer)(WriterContext *wctx, const char *);
 +    void (*print_section_header)(WriterContext *wctx, const char *);
 +    void (*print_section_footer)(WriterContext *wctx, const char *);
 +    void (*print_integer)       (WriterContext *wctx, const char *, long long int);
 +    void (*print_rational)      (WriterContext *wctx, AVRational *q, char *sep);
 +    void (*print_string)        (WriterContext *wctx, const char *, const char *);
 +    void (*show_tags)           (WriterContext *wctx, AVDictionary *dict);
 +    int flags;                  ///< a combination or WRITER_FLAG_*
 +} Writer;
 +
 +struct WriterContext {
 +    const AVClass *class;           ///< class of the writer
 +    const Writer *writer;           ///< the Writer of which this is an instance
 +    char *name;                     ///< name of this writer instance
 +    void *priv;                     ///< private data for use by the filter
 +    unsigned int nb_item;           ///< number of the item printed in the given section, starting at 0
 +    unsigned int nb_section;        ///< number of the section printed in the given section sequence, starting at 0
 +    unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
 +    unsigned int nb_section_frame;  ///< number of the frame  section in case we are in "packets_and_frames" section
 +    unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
 +    unsigned int nb_chapter;        ///< number of the chapter, starting at 0
 +
 +    int multiple_sections;          ///< tells if the current chapter can contain multiple sections
 +    int is_fmt_chapter;             ///< tells if the current chapter is "format", required by the print_format_entry option
 +    int is_packets_and_frames;      ///< tells if the current section is "packets_and_frames"
 +};
 +
 +static const char *writer_get_name(void *p)
 +{
 +    WriterContext *wctx = p;
 +    return wctx->writer->name;
 +}
 +
 +static const AVClass writer_class = {
 +    "Writer",
 +    writer_get_name,
 +    NULL,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +static void writer_close(WriterContext **wctx)
 +{
 +    if (!*wctx)
 +        return;
 +
 +    if ((*wctx)->writer->uninit)
 +        (*wctx)->writer->uninit(*wctx);
 +    av_freep(&((*wctx)->priv));
 +    av_freep(wctx);
 +}
 +
 +static int writer_open(WriterContext **wctx, const Writer *writer,
 +                       const char *args, void *opaque)
 +{
 +    int ret = 0;
 +
 +    if (!(*wctx = av_malloc(sizeof(WriterContext)))) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    (*wctx)->class = &writer_class;
 +    (*wctx)->writer = writer;
 +    if ((*wctx)->writer->init)
 +        ret = (*wctx)->writer->init(*wctx, args, opaque);
 +    if (ret < 0)
 +        goto fail;
 +
 +    return 0;
 +
 +fail:
 +    writer_close(wctx);
 +    return ret;
 +}
 +
 +static inline void writer_print_header(WriterContext *wctx)
 +{
 +    if (wctx->writer->print_header)
 +        wctx->writer->print_header(wctx);
 +    wctx->nb_chapter = 0;
 +}
 +
 +static inline void writer_print_footer(WriterContext *wctx)
 +{
 +    if (wctx->writer->print_footer)
 +        wctx->writer->print_footer(wctx);
 +}
 +
 +static inline void writer_print_chapter_header(WriterContext *wctx,
 +                                               const char *chapter)
 +{
 +    wctx->nb_section =
 +    wctx->nb_section_packet = wctx->nb_section_frame =
 +    wctx->nb_section_packet_frame = 0;
 +    wctx->is_packets_and_frames = !strcmp(chapter, "packets_and_frames");
 +    wctx->multiple_sections = !strcmp(chapter, "packets") || !strcmp(chapter, "frames" ) ||
 +                              wctx->is_packets_and_frames ||
 +                              !strcmp(chapter, "streams") || !strcmp(chapter, "library_versions");
 +    wctx->is_fmt_chapter = !strcmp(chapter, "format");
 +
 +    if (wctx->writer->print_chapter_header)
 +        wctx->writer->print_chapter_header(wctx, chapter);
 +}
 +
 +static inline void writer_print_chapter_footer(WriterContext *wctx,
 +                                               const char *chapter)
 +{
 +    if (wctx->writer->print_chapter_footer)
 +        wctx->writer->print_chapter_footer(wctx, chapter);
 +    wctx->nb_chapter++;
 +}
 +
 +static inline void writer_print_section_header(WriterContext *wctx,
 +                                               const char *section)
 +{
 +    if (wctx->is_packets_and_frames)
 +        wctx->nb_section_packet_frame = !strcmp(section, "packet") ? wctx->nb_section_packet
 +                                                                   : wctx->nb_section_frame;
 +    if (wctx->writer->print_section_header)
 +        wctx->writer->print_section_header(wctx, section);
 +    wctx->nb_item = 0;
 +}
 +
 +static inline void writer_print_section_footer(WriterContext *wctx,
 +                                               const char *section)
 +{
 +    if (wctx->writer->print_section_footer)
 +        wctx->writer->print_section_footer(wctx, section);
 +    if (wctx->is_packets_and_frames) {
 +        if (!strcmp(section, "packet")) wctx->nb_section_packet++;
 +        else                            wctx->nb_section_frame++;
 +    }
 +    wctx->nb_section++;
 +}
 +
 +static inline void writer_print_integer(WriterContext *wctx,
 +                                        const char *key, long long int val)
 +{
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        wctx->writer->print_integer(wctx, key, val);
 +        wctx->nb_item++;
 +    }
 +}
 +
 +static inline void writer_print_rational(WriterContext *wctx,
 +                                         const char *key, AVRational q, char sep)
 +{
 +    AVBPrint buf;
 +    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
 +    av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
 +    wctx->writer->print_string(wctx, key, buf.str);
 +    wctx->nb_item++;
 +}
 +
 +static inline void writer_print_string(WriterContext *wctx,
 +                                       const char *key, const char *val, int opt)
 +{
 +    if (opt && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS))
 +        return;
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        wctx->writer->print_string(wctx, key, val);
 +        wctx->nb_item++;
 +    }
 +}
 +
 +static void writer_print_time(WriterContext *wctx, const char *key,
 +                              int64_t ts, const AVRational *time_base, int is_duration)
 +{
 +    char buf[128];
 +
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
 +            writer_print_string(wctx, key, "N/A", 1);
 +        } else {
 +            double d = ts * av_q2d(*time_base);
 +            value_string(buf, sizeof(buf), (struct unit_value){.val.d=d, .unit=unit_second_str});
 +            writer_print_string(wctx, key, buf, 0);
 +        }
 +    }
 +}
 +
 +static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
 +{
 +    if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
 +        writer_print_string(wctx, key, "N/A", 1);
 +    } else {
 +        writer_print_integer(wctx, key, ts);
 +    }
 +}
 +
 +static inline void writer_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    wctx->writer->show_tags(wctx, dict);
 +}
 +
 +static void writer_print_data(WriterContext *wctx, const char *name,
 +                              uint8_t *data, int size)
 +{
 +    AVBPrint bp;
 +    int offset = 0, l, i;
 +
 +    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
 +    av_bprintf(&bp, "\n");
 +    while (size) {
 +        av_bprintf(&bp, "%08x: ", offset);
 +        l = FFMIN(size, 16);
 +        for (i = 0; i < l; i++) {
 +            av_bprintf(&bp, "%02x", data[i]);
 +            if (i & 1)
 +                av_bprintf(&bp, " ");
 +        }
 +        av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
 +        for (i = 0; i < l; i++)
 +            av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
 +        av_bprintf(&bp, "\n");
 +        offset += l;
 +        data   += l;
 +        size   -= l;
 +    }
 +    writer_print_string(wctx, name, bp.str, 0);
 +    av_bprint_finalize(&bp, NULL);
 +}
 +
 +#define MAX_REGISTERED_WRITERS_NB 64
 +
 +static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
 +
 +static int writer_register(const Writer *writer)
 +{
 +    static int next_registered_writer_idx = 0;
 +
 +    if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
 +        return AVERROR(ENOMEM);
 +
 +    registered_writers[next_registered_writer_idx++] = writer;
 +    return 0;
 +}
 +
 +static const Writer *writer_get_by_name(const char *name)
 +{
 +    int i;
 +
 +    for (i = 0; registered_writers[i]; i++)
 +        if (!strcmp(registered_writers[i]->name, name))
 +            return registered_writers[i];
 +
 +    return NULL;
 +}
 +
 +
 +/* WRITERS */
 +
 +/* Default output */
 +
 +typedef struct DefaultContext {
 +    const AVClass *class;
 +    int nokey;
 +    int noprint_wrappers;
 +} DefaultContext;
 +
 +#define OFFSET(x) offsetof(DefaultContext, x)
 +
 +static const AVOption default_options[] = {
 +    { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nw",               "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nokey",          "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nk",             "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *default_get_name(void *ctx)
 +{
 +    return "default";
 +}
 +
 +static const AVClass default_class = {
 +    "DefaultContext",
 +    default_get_name,
 +    default_options
 +};
 +
 +static av_cold int default_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    DefaultContext *def = wctx->priv;
 +    int err;
 +
 +    def->class = &default_class;
 +    av_opt_set_defaults(def);
 +
 +    if (args &&
 +        (err = (av_set_options_string(def, args, "=", ":"))) < 0)
 +        return err;
 +
 +    return 0;
 +}
 +
 +static void default_print_footer(WriterContext *wctx)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->noprint_wrappers)
 +        printf("\n");
 +}
 +
 +static void default_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->noprint_wrappers && wctx->nb_chapter)
 +        printf("\n");
 +}
 +
 +/* lame uppercasing routine, assumes the string is lower case ASCII */
 +static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
 +{
 +    int i;
 +    for (i = 0; src[i] && i < dst_size-1; i++)
 +        dst[i] = av_toupper(src[i]);
 +    dst[i] = 0;
 +    return dst;
 +}
 +
 +static void default_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    DefaultContext *def = wctx->priv;
 +    char buf[32];
 +
 +    if (wctx->nb_section)
 +        printf("\n");
 +    if (!def->noprint_wrappers)
 +        printf("[%s]\n", upcase_string(buf, sizeof(buf), section));
 +}
 +
 +static void default_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    DefaultContext *def = wctx->priv;
 +    char buf[32];
 +
 +    if (!def->noprint_wrappers)
 +        printf("[/%s]", upcase_string(buf, sizeof(buf), section));
 +}
 +
 +static void default_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    DefaultContext *def = wctx->priv;
 +    if (!def->nokey)
 +        printf("%s=", key);
 +    printf("%s\n", value);
 +}
 +
 +static void default_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->nokey)
 +        printf("%s=", key);
 +    printf("%lld\n", value);
 +}
 +
 +static void default_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    AVDictionaryEntry *tag = NULL;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (!fmt_entries_to_show || (tag->key && av_dict_get(fmt_entries_to_show, tag->key, NULL, 0)))
 +            printf("TAG:");
 +        writer_print_string(wctx, tag->key, tag->value, 0);
 +    }
 +}
 +
 +static const Writer default_writer = {
 +    .name                  = "default",
 +    .priv_size             = sizeof(DefaultContext),
 +    .init                  = default_init,
 +    .print_footer          = default_print_footer,
 +    .print_chapter_header  = default_print_chapter_header,
 +    .print_section_header  = default_print_section_header,
 +    .print_section_footer  = default_print_section_footer,
 +    .print_integer         = default_print_int,
 +    .print_string          = default_print_str,
 +    .show_tags             = default_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* Compact output */
 +
 +/**
 + * Apply C-language-like string escaping.
 + */
 +static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '\b': av_bprintf(dst, "%s", "\\b");  break;
 +        case '\f': av_bprintf(dst, "%s", "\\f");  break;
 +        case '\n': av_bprintf(dst, "%s", "\\n");  break;
 +        case '\r': av_bprintf(dst, "%s", "\\r");  break;
 +        case '\\': av_bprintf(dst, "%s", "\\\\"); break;
 +        default:
 +            if (*p == sep)
 +                av_bprint_chars(dst, '\\', 1);
 +            av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +/**
 + * Quote fields containing special characters, check RFC4180.
 + */
 +static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    const char *p;
 +    int quote = 0;
 +
 +    /* check if input needs quoting */
 +    for (p = src; *p; p++)
 +        if (*p == '"' || *p == sep || *p == '\n' || *p == '\r')
 +            quote = 1;
 +
 +    if (quote)
 +        av_bprint_chars(dst, '\"', 1);
 +
 +    for (p = src; *p; p++) {
 +        if (*p == '"')
 +            av_bprint_chars(dst, '\"', 1);
 +        av_bprint_chars(dst, *p, 1);
 +    }
 +    if (quote)
 +        av_bprint_chars(dst, '\"', 1);
 +    return dst->str;
 +}
 +
 +static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    return src;
 +}
 +
 +typedef struct CompactContext {
 +    const AVClass *class;
 +    char *item_sep_str;
 +    char item_sep;
 +    int nokey;
 +    char *escape_mode_str;
 +    const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
 +} CompactContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(CompactContext, x)
 +
 +static const AVOption compact_options[]= {
 +    {"item_sep", "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
 +    {"s",        "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
 +    {"nokey",    "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_INT,    {.dbl=0},    0,        1        },
 +    {"nk",       "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_INT,    {.dbl=0},    0,        1        },
 +    {"escape",   "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
 +    {"e",        "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
 +    {NULL},
 +};
 +
 +static const char *compact_get_name(void *ctx)
 +{
 +    return "compact";
 +}
 +
 +static const AVClass compact_class = {
 +    "CompactContext",
 +    compact_get_name,
 +    compact_options
 +};
 +
 +static av_cold int compact_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    CompactContext *compact = wctx->priv;
 +    int err;
 +
 +    compact->class = &compact_class;
 +    av_opt_set_defaults(compact);
 +
 +    if (args &&
 +        (err = (av_set_options_string(compact, args, "=", ":"))) < 0)
 +        return err;
 +    if (strlen(compact->item_sep_str) != 1) {
 +        av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
 +               compact->item_sep_str);
 +        return AVERROR(EINVAL);
 +    }
 +    compact->item_sep = compact->item_sep_str[0];
 +
 +    if      (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
 +    else if (!strcmp(compact->escape_mode_str, "c"   )) compact->escape_str = c_escape_str;
 +    else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
 +    else {
 +        av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    return 0;
 +}
 +
 +static av_cold void compact_uninit(WriterContext *wctx)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    av_freep(&compact->item_sep_str);
 +    av_freep(&compact->escape_mode_str);
 +}
 +
 +static void compact_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    printf("%s%c", section, compact->item_sep);
 +}
 +
 +static void compact_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    printf("\n");
 +}
 +
 +static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    CompactContext *compact = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item) printf("%c", compact->item_sep);
 +    if (!compact->nokey)
 +        printf("%s=", key);
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s", compact->escape_str(&buf, value, compact->item_sep, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    if (wctx->nb_item) printf("%c", compact->item_sep);
 +    if (!compact->nokey)
 +        printf("%s=", key);
 +    printf("%lld", value);
 +}
 +
 +static void compact_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    CompactContext *compact = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (wctx->nb_item) printf("%c", compact->item_sep);
 +        if (!compact->nokey) {
 +            av_bprint_clear(&buf);
 +            printf("tag:%s=", compact->escape_str(&buf, tag->key, compact->item_sep, wctx));
 +        }
 +        av_bprint_clear(&buf);
 +        printf("%s", compact->escape_str(&buf, tag->value, compact->item_sep, wctx));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static const Writer compact_writer = {
 +    .name                 = "compact",
 +    .priv_size            = sizeof(CompactContext),
 +    .init                 = compact_init,
 +    .uninit               = compact_uninit,
 +    .print_section_header = compact_print_section_header,
 +    .print_section_footer = compact_print_section_footer,
 +    .print_integer        = compact_print_int,
 +    .print_string         = compact_print_str,
 +    .show_tags            = compact_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* CSV output */
 +
 +static av_cold int csv_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    return compact_init(wctx, "item_sep=,:nokey=1:escape=csv", opaque);
 +}
 +
 +static const Writer csv_writer = {
 +    .name                 = "csv",
 +    .priv_size            = sizeof(CompactContext),
 +    .init                 = csv_init,
 +    .uninit               = compact_uninit,
 +    .print_section_header = compact_print_section_header,
 +    .print_section_footer = compact_print_section_footer,
 +    .print_integer        = compact_print_int,
 +    .print_string         = compact_print_str,
 +    .show_tags            = compact_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* Flat output */
 +
 +typedef struct FlatContext {
 +    const AVClass *class;
 +    const char *section, *chapter;
 +    const char *sep_str;
 +    char sep;
 +    int hierarchical;
 +} FlatContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(FlatContext, x)
 +
 +static const AVOption flat_options[]= {
 +    {"sep_char", "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
 +    {"s",        "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
 +    {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {"h",           "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *flat_get_name(void *ctx)
 +{
 +    return "flat";
 +}
 +
 +static const AVClass flat_class = {
 +    "FlatContext",
 +    flat_get_name,
 +    flat_options
 +};
 +
 +static av_cold int flat_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    FlatContext *flat = wctx->priv;
 +    int err;
 +
 +    flat->class = &flat_class;
 +    av_opt_set_defaults(flat);
 +
 +    if (args &&
 +        (err = (av_set_options_string(flat, args, "=", ":"))) < 0)
 +        return err;
 +    if (strlen(flat->sep_str) != 1) {
 +        av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
 +               flat->sep_str);
 +        return AVERROR(EINVAL);
 +    }
 +    flat->sep = flat->sep_str[0];
 +    return 0;
 +}
 +
 +static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        if (!((*p >= '0' && *p <= '9') ||
 +              (*p >= 'a' && *p <= 'z') ||
 +              (*p >= 'A' && *p <= 'Z')))
 +            av_bprint_chars(dst, '_', 1);
 +        else
 +            av_bprint_chars(dst, *p, 1);
 +    }
 +    return dst->str;
 +}
 +
 +static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '\n': av_bprintf(dst, "%s", "\\n");  break;
 +        case '\r': av_bprintf(dst, "%s", "\\r");  break;
 +        case '\\': av_bprintf(dst, "%s", "\\\\"); break;
 +        case '"':  av_bprintf(dst, "%s", "\\\""); break;
 +        case '`':  av_bprintf(dst, "%s", "\\`");  break;
 +        case '$':  av_bprintf(dst, "%s", "\\$");  break;
 +        default:   av_bprint_chars(dst, *p, 1);   break;
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void flat_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    FlatContext *flat = wctx->priv;
 +    flat->chapter = chapter;
 +}
 +
 +static void flat_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    FlatContext *flat = wctx->priv;
 +    flat->section = section;
 +}
 +
 +static void flat_print_section(WriterContext *wctx)
 +{
 +    FlatContext *flat = wctx->priv;
 +    int n = wctx->is_packets_and_frames ? wctx->nb_section_packet_frame
 +                                        : wctx->nb_section;
 +
 +    if (flat->hierarchical && wctx->multiple_sections)
 +        printf("%s%c", flat->chapter, flat->sep);
 +    printf("%s%c", flat->section, flat->sep);
 +    if (wctx->multiple_sections)
 +        printf("%d%c", n, flat->sep);
 +}
 +
 +static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    flat_print_section(wctx);
 +    printf("%s=%lld\n", key, value);
 +}
 +
 +static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    FlatContext *flat = wctx->priv;
 +    AVBPrint buf;
 +
 +    flat_print_section(wctx);
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=", flat_escape_key_str(&buf, key, flat->sep));
 +    av_bprint_clear(&buf);
 +    printf("\"%s\"\n", flat_escape_value_str(&buf, value));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void flat_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    FlatContext *flat = wctx->priv;
 +    AVBPrint buf;
 +    AVDictionaryEntry *tag = NULL;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        flat_print_section(wctx);
 +        av_bprint_clear(&buf);
 +        printf("tags%c%s=", flat->sep, flat_escape_key_str(&buf, tag->key, flat->sep));
 +        av_bprint_clear(&buf);
 +        printf("\"%s\"\n", flat_escape_value_str(&buf, tag->value));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static const Writer flat_writer = {
 +    .name                  = "flat",
 +    .priv_size             = sizeof(FlatContext),
 +    .init                  = flat_init,
 +    .print_chapter_header  = flat_print_chapter_header,
 +    .print_section_header  = flat_print_section_header,
 +    .print_integer         = flat_print_int,
 +    .print_string          = flat_print_str,
 +    .show_tags             = flat_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* INI format output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    AVBPrint chapter_name, section_name;
 +    int hierarchical;
 +} INIContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(INIContext, x)
 +
 +static const AVOption ini_options[] = {
 +    {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {"h",           "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *ini_get_name(void *ctx)
 +{
 +    return "ini";
 +}
 +
 +static const AVClass ini_class = {
 +    "INIContext",
 +    ini_get_name,
 +    ini_options
 +};
 +
 +static av_cold int ini_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    INIContext *ini = wctx->priv;
 +    int err;
 +
 +    av_bprint_init(&ini->chapter_name, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    av_bprint_init(&ini->section_name, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    ini->class = &ini_class;
 +    av_opt_set_defaults(ini);
 +
 +    if (args && (err = av_set_options_string(ini, args, "=", ":")) < 0)
 +        return err;
 +
 +    return 0;
 +}
 +
 +static av_cold void ini_uninit(WriterContext *wctx)
 +{
 +    INIContext *ini = wctx->priv;
 +    av_bprint_finalize(&ini->chapter_name, NULL);
 +    av_bprint_finalize(&ini->section_name, NULL);
 +}
 +
 +static void ini_print_header(WriterContext *wctx)
 +{
 +    printf("# ffprobe output\n\n");
 +}
 +
 +static char *ini_escape_str(AVBPrint *dst, const char *src)
 +{
 +    int i = 0;
 +    char c = 0;
 +
 +    while (c = src[i++]) {
 +        switch (c) {
 +        case '\b': av_bprintf(dst, "%s", "\\b"); break;
 +        case '\f': av_bprintf(dst, "%s", "\\f"); break;
 +        case '\n': av_bprintf(dst, "%s", "\\n"); break;
 +        case '\r': av_bprintf(dst, "%s", "\\r"); break;
 +        case '\t': av_bprintf(dst, "%s", "\\t"); break;
 +        case '\\':
 +        case '#' :
 +        case '=' :
 +        case ':' : av_bprint_chars(dst, '\\', 1);
 +        default:
 +            if ((unsigned char)c < 32)
 +                av_bprintf(dst, "\\x00%02x", c & 0xff);
 +            else
 +                av_bprint_chars(dst, c, 1);
 +            break;
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void ini_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    INIContext *ini = wctx->priv;
 +
 +    av_bprint_clear(&ini->chapter_name);
 +    av_bprintf(&ini->chapter_name, "%s", chapter);
 +
 +    if (wctx->nb_chapter)
 +        printf("\n");
 +}
 +
 +static void ini_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    INIContext *ini = wctx->priv;
 +    int n = wctx->is_packets_and_frames ? wctx->nb_section_packet_frame
 +                                        : wctx->nb_section;
 +    if (wctx->nb_section)
 +        printf("\n");
 +    av_bprint_clear(&ini->section_name);
 +
 +    if (ini->hierarchical && wctx->multiple_sections)
 +        av_bprintf(&ini->section_name, "%s.", ini->chapter_name.str);
 +    av_bprintf(&ini->section_name, "%s", section);
 +
 +    if (wctx->multiple_sections)
 +        av_bprintf(&ini->section_name, ".%d", n);
 +    printf("[%s]\n", ini->section_name.str);
 +}
 +
 +static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=", ini_escape_str(&buf, key));
 +    av_bprint_clear(&buf);
 +    printf("%s\n", ini_escape_str(&buf, value));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    printf("%s=%lld\n", key, value);
 +}
 +
 +static void ini_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    INIContext *ini = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) {
 +            printf("\n[%s.tags]\n", ini->section_name.str);
 +            is_first = 0;
 +        }
 +        writer_print_string(wctx, tag->key, tag->value, 0);
 +    }
 +}
 +
 +static const Writer ini_writer = {
 +    .name                  = "ini",
 +    .priv_size             = sizeof(INIContext),
 +    .init                  = ini_init,
 +    .uninit                = ini_uninit,
 +    .print_header          = ini_print_header,
 +    .print_chapter_header  = ini_print_chapter_header,
 +    .print_section_header  = ini_print_section_header,
 +    .print_integer         = ini_print_int,
 +    .print_string          = ini_print_str,
 +    .show_tags             = ini_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* JSON output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    int indent_level;
 +    int compact;
 +    const char *item_sep, *item_start_end;
 +} JSONContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(JSONContext, x)
 +
 +static const AVOption json_options[]= {
 +    { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "c",       "enable compact output", OFFSET(compact), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { NULL }
 +};
 +
 +static const char *json_get_name(void *ctx)
 +{
 +    return "json";
 +}
 +
 +static const AVClass json_class = {
 +    "JSONContext",
 +    json_get_name,
 +    json_options
 +};
 +
 +static av_cold int json_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    JSONContext *json = wctx->priv;
 +    int err;
 +
 +    json->class = &json_class;
 +    av_opt_set_defaults(json);
 +
 +    if (args &&
 +        (err = (av_set_options_string(json, args, "=", ":"))) < 0)
 +        return err;
 +
 +    json->item_sep       = json->compact ? ", " : ",\n";
 +    json->item_start_end = json->compact ? " "  : "\n";
 +
 +    return 0;
 +}
 +
 +static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
 +{
 +    static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
 +    static const char json_subst[]  = {'"', '\\',  'b',  'f',  'n',  'r',  't', 0};
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        char *s = strchr(json_escape, *p);
 +        if (s) {
 +            av_bprint_chars(dst, '\\', 1);
 +            av_bprint_chars(dst, json_subst[s - json_escape], 1);
 +        } else if ((unsigned char)*p < 32) {
 +            av_bprintf(dst, "\\u00%02x", *p & 0xff);
 +        } else {
 +            av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void json_print_header(WriterContext *wctx)
 +{
 +    JSONContext *json = wctx->priv;
 +    printf("{");
 +    json->indent_level++;
 +}
 +
 +static void json_print_footer(WriterContext *wctx)
 +{
 +    JSONContext *json = wctx->priv;
 +    json->indent_level--;
 +    printf("\n}\n");
 +}
 +
 +#define JSON_INDENT() printf("%*c", json->indent_level * 4, ' ')
 +
 +static void json_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_chapter)
 +        printf(",");
 +    printf("\n");
 +    if (wctx->multiple_sections) {
 +        JSON_INDENT();
 +        av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +        printf("\"%s\": [\n", json_escape_str(&buf, chapter, wctx));
 +        av_bprint_finalize(&buf, NULL);
 +        json->indent_level++;
 +    }
 +}
 +
 +static void json_print_chapter_footer(WriterContext *wctx, const char *chapter)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->multiple_sections) {
 +        printf("\n");
 +        json->indent_level--;
 +        JSON_INDENT();
 +        printf("]");
 +    }
 +}
 +
 +static void json_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->nb_section)
 +        printf(",\n");
 +    JSON_INDENT();
 +    if (!wctx->multiple_sections)
 +        printf("\"%s\": ", section);
 +    printf("{%s", json->item_start_end);
 +    json->indent_level++;
 +    /* this is required so the parser can distinguish between packets and frames */
 +    if (wctx->is_packets_and_frames) {
 +        if (!json->compact)
 +            JSON_INDENT();
 +        printf("\"type\": \"%s\"%s", section, json->item_sep);
 +    }
 +}
 +
 +static void json_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    printf("%s", json->item_start_end);
 +    json->indent_level--;
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("}");
 +}
 +
 +static inline void json_print_item_str(WriterContext *wctx,
 +                                       const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("\"%s\":", json_escape_str(&buf, key,   wctx));
 +    av_bprint_clear(&buf);
 +    printf(" \"%s\"", json_escape_str(&buf, value, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void json_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->nb_item) printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    json_print_item_str(wctx, key, value);
 +}
 +
 +static void json_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item) printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void json_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +    if (!dict)
 +        return;
 +    printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("\"tags\": {%s", json->item_start_end);
 +    json->indent_level++;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) is_first = 0;
 +        else          printf("%s", json->item_sep);
 +        if (!json->compact)
 +            JSON_INDENT();
 +        json_print_item_str(wctx, tag->key, tag->value);
 +    }
 +    json->indent_level--;
 +    printf("%s", json->item_start_end);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("}");
 +}
 +
 +static const Writer json_writer = {
 +    .name                 = "json",
 +    .priv_size            = sizeof(JSONContext),
 +    .init                 = json_init,
 +    .print_header         = json_print_header,
 +    .print_footer         = json_print_footer,
 +    .print_chapter_header = json_print_chapter_header,
 +    .print_chapter_footer = json_print_chapter_footer,
 +    .print_section_header = json_print_section_header,
 +    .print_section_footer = json_print_section_footer,
 +    .print_integer        = json_print_int,
 +    .print_string         = json_print_str,
 +    .show_tags            = json_show_tags,
 +    .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* XML output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    int within_tag;
 +    int indent_level;
 +    int fully_qualified;
 +    int xsd_strict;
 +} XMLContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(XMLContext, x)
 +
 +static const AVOption xml_options[] = {
 +    {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"q",               "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"xsd_strict",      "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"x",               "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {NULL},
 +};
 +
 +static const char *xml_get_name(void *ctx)
 +{
 +    return "xml";
 +}
 +
 +static const AVClass xml_class = {
 +    "XMLContext",
 +    xml_get_name,
 +    xml_options
 +};
 +
 +static av_cold int xml_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    XMLContext *xml = wctx->priv;
 +    int err;
 +
 +    xml->class = &xml_class;
 +    av_opt_set_defaults(xml);
 +
 +    if (args &&
 +        (err = (av_set_options_string(xml, args, "=", ":"))) < 0)
 +        return err;
 +
 +    if (xml->xsd_strict) {
 +        xml->fully_qualified = 1;
 +#define CHECK_COMPLIANCE(opt, opt_name)                                 \
 +        if (opt) {                                                      \
 +            av_log(wctx, AV_LOG_ERROR,                                  \
 +                   "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
 +                   "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
 +            return AVERROR(EINVAL);                                     \
 +        }
 +        CHECK_COMPLIANCE(show_private_data, "private");
 +        CHECK_COMPLIANCE(show_value_unit,   "unit");
 +        CHECK_COMPLIANCE(use_value_prefix,  "prefix");
 +
 +        if (do_show_frames && do_show_packets) {
 +            av_log(wctx, AV_LOG_ERROR,
 +                   "Interleaved frames and packets are not allowed in XSD. "
 +                   "Select only one between the -show_frames and the -show_packets options.\n");
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static const char *xml_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '&' : av_bprintf(dst, "%s", "&amp;");  break;
 +        case '<' : av_bprintf(dst, "%s", "&lt;");   break;
 +        case '>' : av_bprintf(dst, "%s", "&gt;");   break;
 +        case '\"': av_bprintf(dst, "%s", "&quot;"); break;
 +        case '\'': av_bprintf(dst, "%s", "&apos;"); break;
 +        default: av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +
 +    return dst->str;
 +}
 +
 +static void xml_print_header(WriterContext *wctx)
 +{
 +    XMLContext *xml = wctx->priv;
 +    const char *qual = " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
 +        "xmlns:ffprobe='http://www.ffmpeg.org/schema/ffprobe' "
 +        "xsi:schemaLocation='http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd'";
 +
 +    printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 +    printf("<%sffprobe%s>\n",
 +           xml->fully_qualified ? "ffprobe:" : "",
 +           xml->fully_qualified ? qual : "");
 +
 +    xml->indent_level++;
 +}
 +
 +static void xml_print_footer(WriterContext *wctx)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    xml->indent_level--;
 +    printf("</%sffprobe>\n", xml->fully_qualified ? "ffprobe:" : "");
 +}
 +
 +#define XML_INDENT() printf("%*c", xml->indent_level * 4, ' ')
 +
 +static void xml_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (wctx->nb_chapter)
 +        printf("\n");
 +    if (wctx->multiple_sections) {
 +        XML_INDENT(); printf("<%s>\n", chapter);
 +        xml->indent_level++;
 +    }
 +}
 +
 +static void xml_print_chapter_footer(WriterContext *wctx, const char *chapter)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (wctx->multiple_sections) {
 +        xml->indent_level--;
 +        XML_INDENT(); printf("</%s>\n", chapter);
 +    }
 +}
 +
 +static void xml_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    XML_INDENT(); printf("<%s ", section);
 +    xml->within_tag = 1;
 +}
 +
 +static void xml_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (xml->within_tag)
 +        printf("/>\n");
 +    else {
 +        XML_INDENT(); printf("</%s>\n", section);
 +    }
 +}
 +
 +static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item)
 +        printf(" ");
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=\"%s\"", key, xml_escape_str(&buf, value, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    if (wctx->nb_item)
 +        printf(" ");
 +    printf("%s=\"%lld\"", key, value);
 +}
 +
 +static void xml_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    XMLContext *xml = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    xml->indent_level++;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) {
 +            /* close section tag */
 +            printf(">\n");
 +            xml->within_tag = 0;
 +            is_first = 0;
 +        }
 +        XML_INDENT();
 +
 +        av_bprint_clear(&buf);
 +        printf("<tag key=\"%s\"", xml_escape_str(&buf, tag->key, wctx));
 +        av_bprint_clear(&buf);
 +        printf(" value=\"%s\"/>\n", xml_escape_str(&buf, tag->value, wctx));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +    xml->indent_level--;
 +}
 +
 +static Writer xml_writer = {
 +    .name                 = "xml",
 +    .priv_size            = sizeof(XMLContext),
 +    .init                 = xml_init,
 +    .print_header         = xml_print_header,
 +    .print_footer         = xml_print_footer,
 +    .print_chapter_header = xml_print_chapter_header,
 +    .print_chapter_footer = xml_print_chapter_footer,
 +    .print_section_header = xml_print_section_header,
 +    .print_section_footer = xml_print_section_footer,
 +    .print_integer        = xml_print_int,
 +    .print_string         = xml_print_str,
 +    .show_tags            = xml_show_tags,
 +    .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +static void writer_register_all(void)
 +{
 +    static int initialized;
 +
 +    if (initialized)
 +        return;
 +    initialized = 1;
 +
 +    writer_register(&default_writer);
 +    writer_register(&compact_writer);
 +    writer_register(&csv_writer);
 +    writer_register(&flat_writer);
 +    writer_register(&ini_writer);
 +    writer_register(&json_writer);
 +    writer_register(&xml_writer);
 +}
 +
 +#define print_fmt(k, f, ...) do {              \
 +    av_bprint_clear(&pbuf);                    \
 +    av_bprintf(&pbuf, f, __VA_ARGS__);         \
 +    writer_print_string(w, k, pbuf.str, 0);    \
 +} while (0)
 +
 +#define print_int(k, v)         writer_print_integer(w, k, v)
 +#define print_q(k, v, s)        writer_print_rational(w, k, v, s)
 +#define print_str(k, v)         writer_print_string(w, k, v, 0)
 +#define print_str_opt(k, v)     writer_print_string(w, k, v, 1)
 +#define print_time(k, v, tb)    writer_print_time(w, k, v, tb, 0)
 +#define print_ts(k, v)          writer_print_ts(w, k, v, 0)
 +#define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
 +#define print_duration_ts(k, v)       writer_print_ts(w, k, v, 1)
 +#define print_val(k, v, u)      writer_print_string(w, k, \
 +    value_string(val_str, sizeof(val_str), (struct unit_value){.val.i = v, .unit=u}), 0)
 +#define print_section_header(s) writer_print_section_header(w, s)
 +#define print_section_footer(s) writer_print_section_footer(w, s)
 +#define show_tags(metadata)     writer_show_tags(w, metadata)
 +
 +static void show_packet(WriterContext *w, AVFormatContext *fmt_ctx, AVPacket *pkt, int packet_idx)
 +{
 +    char val_str[128];
 +    AVStream *st = fmt_ctx->streams[pkt->stream_index];
 +    AVBPrint pbuf;
 +    const char *s;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("packet");
 +    s = av_get_media_type_string(st->codec->codec_type);
 +    if (s) print_str    ("codec_type", s);
 +    else   print_str_opt("codec_type", "unknown");
 +    print_int("stream_index",     pkt->stream_index);
 +    print_ts  ("pts",             pkt->pts);
 +    print_time("pts_time",        pkt->pts, &st->time_base);
 +    print_ts  ("dts",             pkt->dts);
 +    print_time("dts_time",        pkt->dts, &st->time_base);
 +    print_duration_ts("duration",        pkt->duration);
 +    print_duration_time("duration_time", pkt->duration, &st->time_base);
 +    print_duration_ts("convergence_duration", pkt->convergence_duration);
 +    print_duration_time("convergence_duration_time", pkt->convergence_duration, &st->time_base);
 +    print_val("size",             pkt->size, unit_byte_str);
 +    if (pkt->pos != -1) print_fmt    ("pos", "%"PRId64, pkt->pos);
 +    else                print_str_opt("pos", "N/A");
 +    print_fmt("flags", "%c",      pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');
 +    if (do_show_data)
 +        writer_print_data(w, "data", pkt->data, pkt->size);
 +    print_section_footer("packet");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
 +                       AVFormatContext *fmt_ctx)
 +{
 +    AVBPrint pbuf;
 +    const char *s;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("frame");
 +
 +    s = av_get_media_type_string(stream->codec->codec_type);
 +    if (s) print_str    ("media_type", s);
 +    else   print_str_opt("media_type", "unknown");
 +    print_int("key_frame",              frame->key_frame);
 +    print_ts  ("pkt_pts",               frame->pkt_pts);
 +    print_time("pkt_pts_time",          frame->pkt_pts, &stream->time_base);
 +    print_ts  ("pkt_dts",               frame->pkt_dts);
 +    print_time("pkt_dts_time",          frame->pkt_dts, &stream->time_base);
 +    print_duration_ts  ("pkt_duration",      frame->pkt_duration);
 +    print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
 +    if (frame->pkt_pos != -1) print_fmt    ("pkt_pos", "%"PRId64, frame->pkt_pos);
 +    else                      print_str_opt("pkt_pos", "N/A");
 +
 +    switch (stream->codec->codec_type) {
 +        AVRational sar;
 +
 +    case AVMEDIA_TYPE_VIDEO:
 +        print_int("width",                  frame->width);
 +        print_int("height",                 frame->height);
 +        s = av_get_pix_fmt_name(frame->format);
 +        if (s) print_str    ("pix_fmt", s);
 +        else   print_str_opt("pix_fmt", "unknown");
 +        sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
 +        if (sar.num) {
 +            print_q("sample_aspect_ratio", sar, ':');
 +        } else {
 +            print_str_opt("sample_aspect_ratio", "N/A");
 +        }
 +        print_fmt("pict_type",              "%c", av_get_picture_type_char(frame->pict_type));
 +        print_int("coded_picture_number",   frame->coded_picture_number);
 +        print_int("display_picture_number", frame->display_picture_number);
 +        print_int("interlaced_frame",       frame->interlaced_frame);
 +        print_int("top_field_first",        frame->top_field_first);
 +        print_int("repeat_pict",            frame->repeat_pict);
 +        print_int("reference",              frame->reference);
 +        break;
 +
 +    case AVMEDIA_TYPE_AUDIO:
 +        s = av_get_sample_fmt_name(frame->format);
 +        if (s) print_str    ("sample_fmt", s);
 +        else   print_str_opt("sample_fmt", "unknown");
 +        print_int("nb_samples",         frame->nb_samples);
 +        print_int("channels", av_frame_get_channels(frame));
 +        if (av_frame_get_channel_layout(frame)) {
 +            av_bprint_clear(&pbuf);
 +            av_bprint_channel_layout(&pbuf, av_frame_get_channels(frame),
 +                                     av_frame_get_channel_layout(frame));
 +            print_str    ("channel_layout", pbuf.str);
 +        } else
 +            print_str_opt("channel_layout", "unknown");
 +        break;
 +    }
 +    show_tags(av_frame_get_metadata(frame));
 +
 +    print_section_footer("frame");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static av_always_inline int process_frame(WriterContext *w,
 +                                          AVFormatContext *fmt_ctx,
 +                                          AVFrame *frame, AVPacket *pkt)
 +{
 +    AVCodecContext *dec_ctx = fmt_ctx->streams[pkt->stream_index]->codec;
 +    int ret = 0, got_frame = 0;
 +
 +    avcodec_get_frame_defaults(frame);
 +    if (dec_ctx->codec) {
 +        switch (dec_ctx->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, pkt);
 +            break;
 +
 +        case AVMEDIA_TYPE_AUDIO:
 +            ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, pkt);
 +            break;
 +        }
 +    }
 +
 +    if (ret < 0)
 +        return ret;
 +    ret = FFMIN(ret, pkt->size); /* guard against bogus return values */
 +    pkt->data += ret;
 +    pkt->size -= ret;
 +    if (got_frame) {
 +        nb_streams_frames[pkt->stream_index]++;
 +        if (do_show_frames)
 +            show_frame(w, frame, fmt_ctx->streams[pkt->stream_index], fmt_ctx);
 +    }
 +    return got_frame;
 +}
 +
 +static void read_packets(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    AVPacket pkt, pkt1;
 +    AVFrame frame;
 +    int i = 0;
 +
 +    av_init_packet(&pkt);
 +
 +    while (!av_read_frame(fmt_ctx, &pkt)) {
 +        if (do_read_packets) {
 +            if (do_show_packets)
 +                show_packet(w, fmt_ctx, &pkt, i++);
 +            nb_streams_packets[pkt.stream_index]++;
 +        }
 +        if (do_read_frames) {
 +            pkt1 = pkt;
 +            while (pkt1.size && process_frame(w, fmt_ctx, &frame, &pkt1) > 0);
 +        }
 +        av_free_packet(&pkt);
 +    }
 +    av_init_packet(&pkt);
 +    pkt.data = NULL;
 +    pkt.size = 0;
 +    //Flush remaining frames that are cached in the decoder
 +    for (i = 0; i < fmt_ctx->nb_streams; i++) {
 +        pkt.stream_index = i;
 +        if (do_read_frames)
 +            while (process_frame(w, fmt_ctx, &frame, &pkt) > 0);
 +    }
 +}
 +
 +static void show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx)
 +{
 +    AVStream *stream = fmt_ctx->streams[stream_idx];
 +    AVCodecContext *dec_ctx;
++    const AVCodec *dec;
 +    char val_str[128];
 +    const char *s;
 +    AVRational sar, dar;
 +    AVBPrint pbuf;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("stream");
 +
 +    print_int("index", stream->index);
 +
 +    if ((dec_ctx = stream->codec)) {
 +        const char *profile = NULL;
 +        if ((dec = dec_ctx->codec)) {
 +            print_str("codec_name",      dec->name);
 +            print_str("codec_long_name", dec->long_name);
 +        } else {
 +            print_str_opt("codec_name",      "unknown");
 +            print_str_opt("codec_long_name", "unknown");
 +        }
 +
 +        if (dec && (profile = av_get_profile_name(dec, dec_ctx->profile)))
 +            print_str("profile", profile);
 +        else
 +            print_str_opt("profile", "unknown");
 +
 +        s = av_get_media_type_string(dec_ctx->codec_type);
 +        if (s) print_str    ("codec_type", s);
 +        else   print_str_opt("codec_type", "unknown");
 +        print_q("codec_time_base", dec_ctx->time_base, '/');
 +
 +        /* print AVI/FourCC tag */
 +        av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
 +        print_str("codec_tag_string",    val_str);
 +        print_fmt("codec_tag", "0x%04x", dec_ctx->codec_tag);
 +
 +        switch (dec_ctx->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            print_int("width",        dec_ctx->width);
 +            print_int("height",       dec_ctx->height);
 +            print_int("has_b_frames", dec_ctx->has_b_frames);
 +            sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
 +            if (sar.den) {
 +                print_q("sample_aspect_ratio", sar, ':');
 +                av_reduce(&dar.num, &dar.den,
 +                          dec_ctx->width  * sar.num,
 +                          dec_ctx->height * sar.den,
 +                          1024*1024);
 +                print_q("display_aspect_ratio", dar, ':');
 +            } else {
 +                print_str_opt("sample_aspect_ratio", "N/A");
 +                print_str_opt("display_aspect_ratio", "N/A");
 +            }
 +            s = av_get_pix_fmt_name(dec_ctx->pix_fmt);
 +            if (s) print_str    ("pix_fmt", s);
 +            else   print_str_opt("pix_fmt", "unknown");
 +            print_int("level",   dec_ctx->level);
 +            if (dec_ctx->timecode_frame_start >= 0) {
 +                char tcbuf[AV_TIMECODE_STR_SIZE];
 +                av_timecode_make_mpeg_tc_string(tcbuf, dec_ctx->timecode_frame_start);
 +                print_str("timecode", tcbuf);
 +            } else {
 +                print_str_opt("timecode", "N/A");
 +            }
 +            break;
 +
 +        case AVMEDIA_TYPE_AUDIO:
 +            s = av_get_sample_fmt_name(dec_ctx->sample_fmt);
 +            if (s) print_str    ("sample_fmt", s);
 +            else   print_str_opt("sample_fmt", "unknown");
 +            print_val("sample_rate",     dec_ctx->sample_rate, unit_hertz_str);
 +            print_int("channels",        dec_ctx->channels);
 +            print_int("bits_per_sample", av_get_bits_per_sample(dec_ctx->codec_id));
 +            break;
 +        }
 +    } else {
 +        print_str_opt("codec_type", "unknown");
 +    }
 +    if (dec_ctx->codec && dec_ctx->codec->priv_class && show_private_data) {
 +        const AVOption *opt = NULL;
 +        while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
 +            uint8_t *str;
 +            if (opt->flags) continue;
 +            if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
 +                print_str(opt->name, str);
 +                av_free(str);
 +            }
 +        }
 +    }
 +
 +    if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt    ("id", "0x%x", stream->id);
 +    else                                          print_str_opt("id", "N/A");
 +    print_q("r_frame_rate",   stream->r_frame_rate,   '/');
 +    print_q("avg_frame_rate", stream->avg_frame_rate, '/');
 +    print_q("time_base",      stream->time_base,      '/');
 +    print_time("start_time",    stream->start_time, &stream->time_base);
 +    print_time("duration",      stream->duration,   &stream->time_base);
 +    if (dec_ctx->bit_rate > 0) print_val    ("bit_rate", dec_ctx->bit_rate, unit_bit_per_second_str);
 +    else                       print_str_opt("bit_rate", "N/A");
 +    if (stream->nb_frames) print_fmt    ("nb_frames", "%"PRId64, stream->nb_frames);
 +    else                   print_str_opt("nb_frames", "N/A");
 +    if (nb_streams_frames[stream_idx])  print_fmt    ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
 +    else                                print_str_opt("nb_read_frames", "N/A");
 +    if (nb_streams_packets[stream_idx]) print_fmt    ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
 +    else                                print_str_opt("nb_read_packets", "N/A");
 +    if (do_show_data)
 +        writer_print_data(w, "extradata", dec_ctx->extradata,
 +                                          dec_ctx->extradata_size);
 +    show_tags(stream->metadata);
 +
 +    print_section_footer("stream");
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static void show_streams(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    int i;
 +    for (i = 0; i < fmt_ctx->nb_streams; i++)
 +        show_stream(w, fmt_ctx, i);
 +}
 +
 +static void show_format(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    char val_str[128];
 +    int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
 +
 +    print_section_header("format");
 +    print_str("filename",         fmt_ctx->filename);
 +    print_int("nb_streams",       fmt_ctx->nb_streams);
 +    print_str("format_name",      fmt_ctx->iformat->name);
 +    print_str("format_long_name", fmt_ctx->iformat->long_name);
 +    print_time("start_time",      fmt_ctx->start_time, &AV_TIME_BASE_Q);
 +    print_time("duration",        fmt_ctx->duration,   &AV_TIME_BASE_Q);
 +    if (size >= 0) print_val    ("size", size, unit_byte_str);
 +    else           print_str_opt("size", "N/A");
 +    if (fmt_ctx->bit_rate > 0) print_val    ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
 +    else                       print_str_opt("bit_rate", "N/A");
 +    show_tags(fmt_ctx->metadata);
 +    print_section_footer("format");
 +    fflush(stdout);
 +}
 +
 +static void show_error(WriterContext *w, int err)
 +{
 +    char errbuf[128];
 +    const char *errbuf_ptr = errbuf;
 +
 +    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 +        errbuf_ptr = strerror(AVUNERROR(err));
 +
 +    writer_print_chapter_header(w, "error");
 +    print_section_header("error");
 +    print_int("code", err);
 +    print_str("string", errbuf_ptr);
 +    print_section_footer("error");
 +    writer_print_chapter_footer(w, "error");
 +}
 +
 +static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
 +{
 +    int err, i;
 +    AVFormatContext *fmt_ctx = NULL;
 +    AVDictionaryEntry *t;
 +
 +    if ((err = avformat_open_input(&fmt_ctx, filename,
 +                                   iformat, &format_opts)) < 0) {
 +        print_error(filename, err);
 +        return err;
 +    }
 +    if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 +        av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
 +        return AVERROR_OPTION_NOT_FOUND;
 +    }
 +
 +
 +    /* fill the streams in the format context */
 +    if ((err = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
 +        print_error(filename, err);
 +        return err;
 +    }
 +
 +    av_dump_format(fmt_ctx, 0, filename, 0);
 +
 +    /* bind a decoder to each input stream */
 +    for (i = 0; i < fmt_ctx->nb_streams; i++) {
 +        AVStream *stream = fmt_ctx->streams[i];
 +        AVCodec *codec;
 +
 +        if (stream->codec->codec_id == AV_CODEC_ID_PROBE) {
 +            av_log(NULL, AV_LOG_ERROR,
 +                   "Failed to probe codec for input stream %d\n",
 +                    stream->index);
 +        } else if (!(codec = avcodec_find_decoder(stream->codec->codec_id))) {
 +            av_log(NULL, AV_LOG_ERROR,
 +                    "Unsupported codec with id %d for input stream %d\n",
 +                    stream->codec->codec_id, stream->index);
 +        } else if (avcodec_open2(stream->codec, codec, NULL) < 0) {
 +            av_log(NULL, AV_LOG_ERROR, "Error while opening codec for input stream %d\n",
 +                   stream->index);
 +        }
 +    }
 +
 +    *fmt_ctx_ptr = fmt_ctx;
 +    return 0;
 +}
 +
 +static void close_input_file(AVFormatContext **ctx_ptr)
 +{
 +    int i;
 +    AVFormatContext *fmt_ctx = *ctx_ptr;
 +
 +    /* close decoder for each stream */
 +    for (i = 0; i < fmt_ctx->nb_streams; i++)
 +        if (fmt_ctx->streams[i]->codec->codec_id != AV_CODEC_ID_NONE)
 +            avcodec_close(fmt_ctx->streams[i]->codec);
 +
 +    avformat_close_input(ctx_ptr);
 +}
 +
 +#define PRINT_CHAPTER(name) do {                                        \
 +    if (do_show_ ## name) {                                             \
 +        writer_print_chapter_header(wctx, #name);                       \
 +        show_ ## name (wctx, fmt_ctx);                                  \
 +        writer_print_chapter_footer(wctx, #name);                       \
 +    }                                                                   \
 +} while (0)
 +
 +static int probe_file(WriterContext *wctx, const char *filename)
 +{
 +    AVFormatContext *fmt_ctx;
 +    int ret;
 +
 +    do_read_frames = do_show_frames || do_count_frames;
 +    do_read_packets = do_show_packets || do_count_packets;
 +
 +    ret = open_input_file(&fmt_ctx, filename);
 +    if (ret >= 0) {
 +        nb_streams_frames  = av_calloc(fmt_ctx->nb_streams, sizeof(*nb_streams_frames));
 +        nb_streams_packets = av_calloc(fmt_ctx->nb_streams, sizeof(*nb_streams_packets));
 +        if (do_read_frames || do_read_packets) {
 +            const char *chapter;
 +            if (do_show_frames && do_show_packets &&
 +                wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
 +                chapter = "packets_and_frames";
 +            else if (do_show_packets && !do_show_frames)
 +                chapter = "packets";
 +            else // (!do_show_packets && do_show_frames)
 +                chapter = "frames";
 +            if (do_show_frames || do_show_packets)
 +                writer_print_chapter_header(wctx, chapter);
 +            read_packets(wctx, fmt_ctx);
 +            if (do_show_frames || do_show_packets)
 +                writer_print_chapter_footer(wctx, chapter);
 +        }
 +        PRINT_CHAPTER(streams);
 +        PRINT_CHAPTER(format);
 +        close_input_file(&fmt_ctx);
 +        av_freep(&nb_streams_frames);
 +        av_freep(&nb_streams_packets);
 +    }
 +    return ret;
 +}
 +
 +static void show_usage(void)
 +{
 +    av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
 +    av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] [INPUT_FILE]\n", program_name);
 +    av_log(NULL, AV_LOG_INFO, "\n");
 +}
 +
 +static void ffprobe_show_program_version(WriterContext *w)
 +{
 +    AVBPrint pbuf;
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    writer_print_chapter_header(w, "program_version");
 +    print_section_header("program_version");
 +    print_str("version", FFMPEG_VERSION);
 +    print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
 +              program_birth_year, this_year);
 +    print_str("build_date", __DATE__);
 +    print_str("build_time", __TIME__);
 +    print_str("compiler_ident", CC_IDENT);
 +    print_str("configuration", FFMPEG_CONFIGURATION);
 +    print_section_footer("program_version");
 +    writer_print_chapter_footer(w, "program_version");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +}
 +
 +#define SHOW_LIB_VERSION(libname, LIBNAME)                              \
 +    do {                                                                \
 +        if (CONFIG_##LIBNAME) {                                         \
 +            unsigned int version = libname##_version();                 \
 +            print_section_header("library_version");                    \
 +            print_str("name",    "lib" #libname);                       \
 +            print_int("major",   LIB##LIBNAME##_VERSION_MAJOR);         \
 +            print_int("minor",   LIB##LIBNAME##_VERSION_MINOR);         \
 +            print_int("micro",   LIB##LIBNAME##_VERSION_MICRO);         \
 +            print_int("version", version);                              \
 +            print_section_footer("library_version");                    \
 +        }                                                               \
 +    } while (0)
 +
 +static void ffprobe_show_library_versions(WriterContext *w)
 +{
 +    writer_print_chapter_header(w, "library_versions");
 +    SHOW_LIB_VERSION(avutil,     AVUTIL);
 +    SHOW_LIB_VERSION(avcodec,    AVCODEC);
 +    SHOW_LIB_VERSION(avformat,   AVFORMAT);
 +    SHOW_LIB_VERSION(avdevice,   AVDEVICE);
 +    SHOW_LIB_VERSION(avfilter,   AVFILTER);
 +    SHOW_LIB_VERSION(swscale,    SWSCALE);
 +    SHOW_LIB_VERSION(swresample, SWRESAMPLE);
 +    SHOW_LIB_VERSION(postproc,   POSTPROC);
 +    writer_print_chapter_footer(w, "library_versions");
 +}
 +
 +static int opt_format(const char *opt, const char *arg)
 +{
 +    iformat = av_find_input_format(arg);
 +    if (!iformat) {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    return 0;
 +}
 +
 +static int opt_show_format_entry(const char *opt, const char *arg)
 +{
 +    do_show_format = 1;
 +    av_dict_set(&fmt_entries_to_show, arg, "", 0);
 +    return 0;
 +}
 +
 +static void opt_input_file(void *optctx, const char *arg)
 +{
 +    if (input_filename) {
 +        av_log(NULL, AV_LOG_ERROR,
 +                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
 +                arg, input_filename);
 +        exit(1);
 +    }
 +    if (!strcmp(arg, "-"))
 +        arg = "pipe:";
 +    input_filename = arg;
 +}
 +
 +static int opt_help(const char *opt, const char *arg)
 +{
 +    av_log_set_callback(log_callback_help);
 +    show_usage();
 +    show_help_options(options, "Main options:\n", 0, 0);
 +    printf("\n");
 +
 +    show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
 +
 +    return 0;
 +}
 +
 +static int opt_pretty(const char *opt, const char *arg)
 +{
 +    show_value_unit              = 1;
 +    use_value_prefix             = 1;
 +    use_byte_value_binary_prefix = 1;
 +    use_value_sexagesimal_format = 1;
 +    return 0;
 +}
 +
 +static int opt_show_versions(const char *opt, const char *arg)
 +{
 +    do_show_program_version  = 1;
 +    do_show_library_versions = 1;
 +    return 0;
 +}
 +
 +static const OptionDef real_options[] = {
 +#include "cmdutils_common_opts.h"
 +    { "f", HAS_ARG, {(void*)opt_format}, "force format", "format" },
 +    { "unit", OPT_BOOL, {(void*)&show_value_unit}, "show unit of the displayed values" },
 +    { "prefix", OPT_BOOL, {(void*)&use_value_prefix}, "use SI prefixes for the displayed values" },
 +    { "byte_binary_prefix", OPT_BOOL, {(void*)&use_byte_value_binary_prefix},
 +      "use binary prefixes for byte units" },
 +    { "sexagesimal", OPT_BOOL,  {(void*)&use_value_sexagesimal_format},
 +      "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
 +    { "pretty", 0, {(void*)&opt_pretty},
 +      "prettify the format of displayed values, make it more human readable" },
 +    { "print_format", OPT_STRING | HAS_ARG, {(void*)&print_format},
 +      "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
 +    { "of", OPT_STRING | HAS_ARG, {(void*)&print_format}, "alias for -print_format", "format" },
 +    { "show_data",    OPT_BOOL, {(void*)&do_show_data}, "show packets data" },
 +    { "show_error",   OPT_BOOL, {(void*)&do_show_error} ,  "show probing error" },
 +    { "show_format",  OPT_BOOL, {(void*)&do_show_format} , "show format/container info" },
 +    { "show_frames",  OPT_BOOL, {(void*)&do_show_frames} , "show frames info" },
 +    { "show_format_entry", HAS_ARG, {(void*)opt_show_format_entry},
 +      "show a particular entry from the format/container info", "entry" },
 +    { "show_packets", OPT_BOOL, {(void*)&do_show_packets}, "show packets info" },
 +    { "show_streams", OPT_BOOL, {(void*)&do_show_streams}, "show streams info" },
 +    { "count_frames", OPT_BOOL, {(void*)&do_count_frames}, "count the number of frames per stream" },
 +    { "count_packets", OPT_BOOL, {(void*)&do_count_packets}, "count the number of packets per stream" },
 +    { "show_program_version",  OPT_BOOL, {(void*)&do_show_program_version},  "show ffprobe version" },
 +    { "show_library_versions", OPT_BOOL, {(void*)&do_show_library_versions}, "show library versions" },
 +    { "show_versions",         0, {(void*)&opt_show_versions}, "show program and library versions" },
 +    { "show_private_data", OPT_BOOL, {(void*)&show_private_data}, "show private data" },
 +    { "private",           OPT_BOOL, {(void*)&show_private_data}, "same as show_private_data" },
 +    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
 +    { "i", HAS_ARG, {(void *)opt_input_file}, "read specified file", "input_file"},
 +    { NULL, },
 +};
 +
 +int main(int argc, char **argv)
 +{
 +    const Writer *w;
 +    WriterContext *wctx;
 +    char *buf;
 +    char *w_name = NULL, *w_args = NULL;
 +    int ret;
 +
 +    av_log_set_flags(AV_LOG_SKIP_REPEATED);
 +    options = real_options;
 +    parse_loglevel(argc, argv, options);
 +    av_register_all();
 +    avformat_network_init();
 +    init_opts();
 +#if CONFIG_AVDEVICE
 +    avdevice_register_all();
 +#endif
 +
 +    show_banner(argc, argv, options);
 +    parse_options(NULL, argc, argv, options, opt_input_file);
 +
 +    writer_register_all();
 +
 +    if (!print_format)
 +        print_format = av_strdup("default");
 +    w_name = av_strtok(print_format, "=", &buf);
 +    w_args = buf;
 +
 +    w = writer_get_by_name(w_name);
 +    if (!w) {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
 +        ret = AVERROR(EINVAL);
 +        goto end;
 +    }
 +
 +    if ((ret = writer_open(&wctx, w, w_args, NULL)) >= 0) {
 +        writer_print_header(wctx);
 +
 +        if (do_show_program_version)
 +            ffprobe_show_program_version(wctx);
 +        if (do_show_library_versions)
 +            ffprobe_show_library_versions(wctx);
 +
 +        if (!input_filename &&
 +            ((do_show_format || do_show_streams || do_show_packets || do_show_error) ||
 +             (!do_show_program_version && !do_show_library_versions))) {
 +            show_usage();
 +            av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
 +            av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
 +            ret = AVERROR(EINVAL);
 +        } else if (input_filename) {
 +            ret = probe_file(wctx, input_filename);
 +            if (ret < 0 && do_show_error)
 +                show_error(wctx, ret);
 +        }
 +
 +        writer_print_footer(wctx);
 +        writer_close(&wctx);
 +    }
 +
 +end:
 +    av_freep(&print_format);
 +
 +    uninit_opts();
 +    av_dict_free(&fmt_entries_to_show);
 +
 +    avformat_network_deinit();
 +
 +    return ret;
 +}
diff --combined libavcodec/pthread.c
@@@ -6,20 -6,20 +6,20 @@@
   * to Michael Niedermayer <michaelni@gmx.at> for writing initial
   * implementation.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -43,7 -43,6 +43,7 @@@
  #include <sys/param.h>
  #endif
  #include <sys/types.h>
 +#include <sys/param.h>
  #include <sys/sysctl.h>
  #endif
  #if HAVE_SYSCONF
@@@ -59,8 -58,6 +59,8 @@@
  #include <pthread.h>
  #elif HAVE_W32THREADS
  #include "w32pthreads.h"
 +#elif HAVE_OS2THREADS
 +#include "os2threads.h"
  #endif
  
  typedef int (action_func)(AVCodecContext *c, void *arg);
@@@ -130,8 -127,8 +130,8 @@@ typedef struct PerThreadContext 
      /**
       * Array of progress values used by ff_thread_get_buffer().
       */
 -    int     progress[MAX_BUFFERS][2];
 -    uint8_t progress_used[MAX_BUFFERS];
 +    volatile int     progress[MAX_BUFFERS][2];
 +    volatile uint8_t progress_used[MAX_BUFFERS];
  
      AVFrame *requested_frame;       ///< AVFrame the codec passed to get_buffer()
  } PerThreadContext;
@@@ -161,7 -158,7 +161,7 @@@ typedef struct FrameThreadContext 
   * limit the number of threads to 16 for automatic detection */
  #define MAX_AUTO_THREADS 16
  
 -static int get_logical_cpus(AVCodecContext *avctx)
 +int ff_get_logical_cpus(AVCodecContext *avctx)
  {
      int ret, nb_cpus = 1;
  #if HAVE_SCHED_GETAFFINITY && defined(CPU_COUNT)
      nb_cpus = sysconf(_SC_NPROCESSORS_ONLN);
  #endif
      av_log(avctx, AV_LOG_DEBUG, "detected %d logical cores\n", nb_cpus);
 +
 +    if  (avctx->height)
 +        nb_cpus = FFMIN(nb_cpus, (avctx->height+15)/16);
 +
      return nb_cpus;
  }
  
@@@ -304,7 -297,7 +304,7 @@@ static int thread_init(AVCodecContext *
      int thread_count = avctx->thread_count;
  
      if (!thread_count) {
 -        int nb_cpus = get_logical_cpus(avctx);
 +        int nb_cpus = ff_get_logical_cpus(avctx);
          // use number of cores + 1 as thread count if there is more than one
          if (nb_cpus > 1)
              thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
@@@ -364,38 -357,36 +364,38 @@@ static attribute_align_arg void *frame_
      PerThreadContext *p = arg;
      FrameThreadContext *fctx = p->parent;
      AVCodecContext *avctx = p->avctx;
-     AVCodec *codec = avctx->codec;
+     const AVCodec *codec = avctx->codec;
  
 +    pthread_mutex_lock(&p->mutex);
      while (1) {
 -        if (p->state == STATE_INPUT_READY && !fctx->die) {
 -            pthread_mutex_lock(&p->mutex);
 +        int i;
              while (p->state == STATE_INPUT_READY && !fctx->die)
                  pthread_cond_wait(&p->input_cond, &p->mutex);
 -            pthread_mutex_unlock(&p->mutex);
 -        }
  
          if (fctx->die) break;
  
 -        if (!codec->update_thread_context && avctx->thread_safe_callbacks)
 +        if (!codec->update_thread_context && (avctx->thread_safe_callbacks || avctx->get_buffer == avcodec_default_get_buffer))
              ff_thread_finish_setup(avctx);
  
 -        pthread_mutex_lock(&p->mutex);
          avcodec_get_frame_defaults(&p->frame);
          p->got_frame = 0;
          p->result = codec->decode(avctx, &p->frame, &p->got_frame, &p->avpkt);
  
          if (p->state == STATE_SETTING_UP) ff_thread_finish_setup(avctx);
  
 +        pthread_mutex_lock(&p->progress_mutex);
 +        for (i = 0; i < MAX_BUFFERS; i++)
 +            if (p->progress_used[i] && (p->got_frame || p->result<0 || avctx->codec_id != AV_CODEC_ID_H264)) {
 +                p->progress[i][0] = INT_MAX;
 +                p->progress[i][1] = INT_MAX;
 +            }
          p->state = STATE_INPUT_READY;
  
 -        pthread_mutex_lock(&p->progress_mutex);
 +        pthread_cond_broadcast(&p->progress_cond);
          pthread_cond_signal(&p->output_cond);
          pthread_mutex_unlock(&p->progress_mutex);
 -
 -        pthread_mutex_unlock(&p->mutex);
      }
 +    pthread_mutex_unlock(&p->mutex);
  
      return NULL;
  }
@@@ -441,7 -432,6 +441,7 @@@ static int update_context_from_thread(A
      }
  
      if (for_user) {
 +        dst->delay       = src->thread_count - 1;
          dst->coded_frame = src->coded_frame;
      } else {
          if (dst->codec->update_thread_context)
@@@ -478,7 -468,6 +478,7 @@@ static int update_context_from_user(AVC
  
      dst->frame_number     = src->frame_number;
      dst->reordered_opaque = src->reordered_opaque;
 +    dst->thread_safe_callbacks = src->thread_safe_callbacks;
  
      if (src->slice_count && src->slice_offset) {
          if (dst->slice_count < src->slice_count) {
  static void free_progress(AVFrame *f)
  {
      PerThreadContext *p = f->owner->thread_opaque;
 -    int *progress = f->thread_opaque;
 +    volatile int *progress = f->thread_opaque;
  
      p->progress_used[(progress - p->progress[0]) / 2] = 0;
  }
@@@ -528,7 -517,7 +528,7 @@@ static int submit_packet(PerThreadConte
  {
      FrameThreadContext *fctx = p->parent;
      PerThreadContext *prev_thread = fctx->prev_thread;
-     AVCodec *codec = p->avctx->codec;
+     const AVCodec *codec = p->avctx->codec;
      uint8_t *buf = p->avpkt.data;
  
      if (!avpkt->size && !(codec->capabilities & CODEC_CAP_DELAY)) return 0;
@@@ -667,7 -656,7 +667,7 @@@ int ff_thread_decode_frame(AVCodecConte
  void ff_thread_report_progress(AVFrame *f, int n, int field)
  {
      PerThreadContext *p;
 -    int *progress = f->thread_opaque;
 +    volatile int *progress = f->thread_opaque;
  
      if (!progress || progress[field] >= n) return;
  
  void ff_thread_await_progress(AVFrame *f, int n, int field)
  {
      PerThreadContext *p;
 -    int *progress = f->thread_opaque;
 +    volatile int *progress = f->thread_opaque;
  
      if (!progress || progress[field] >= n) return;
  
@@@ -705,10 -694,6 +705,10 @@@ void ff_thread_finish_setup(AVCodecCont
  
      if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
  
 +    if(p->state == STATE_SETUP_FINISHED){
 +        av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
 +    }
 +
      pthread_mutex_lock(&p->progress_mutex);
      p->state = STATE_SETUP_FINISHED;
      pthread_cond_broadcast(&p->progress_cond);
@@@ -729,14 -714,13 +729,14 @@@ static void park_frame_worker_threads(F
                  pthread_cond_wait(&p->output_cond, &p->progress_mutex);
              pthread_mutex_unlock(&p->progress_mutex);
          }
 +        p->got_frame = 0;
      }
  }
  
  static void frame_thread_free(AVCodecContext *avctx, int thread_count)
  {
      FrameThreadContext *fctx = avctx->thread_opaque;
-     AVCodec *codec = avctx->codec;
+     const AVCodec *codec = avctx->codec;
      int i;
  
      park_frame_worker_threads(fctx, thread_count);
  
          if (p->thread_init)
              pthread_join(p->thread, NULL);
 +        p->thread_init=0;
  
          if (codec->close)
              codec->close(p->avctx);
  static int frame_thread_init(AVCodecContext *avctx)
  {
      int thread_count = avctx->thread_count;
-     AVCodec *codec = avctx->codec;
+     const AVCodec *codec = avctx->codec;
      AVCodecContext *src = avctx;
      FrameThreadContext *fctx;
      int i, err = 0;
  
      if (!thread_count) {
 -        int nb_cpus = get_logical_cpus(avctx);
 +        int nb_cpus = ff_get_logical_cpus(avctx);
 +        if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
 +            nb_cpus = 1;
          // use number of cores + 1 as thread count if there is more than one
          if (nb_cpus > 1)
              thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
  
          if (err) goto error;
  
 -        if (!pthread_create(&p->thread, NULL, frame_worker_thread, p))
 -            p->thread_init = 1;
 +        err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));
 +        p->thread_init= !err;
 +        if(!p->thread_init)
 +            goto error;
      }
  
      return 0;
@@@ -912,7 -891,7 +912,7 @@@ void ff_thread_flush(AVCodecContext *av
      }
  }
  
 -static int *allocate_progress(PerThreadContext *p)
 +static volatile int *allocate_progress(PerThreadContext *p)
  {
      int i;
  
      return p->progress[i];
  }
  
 +int ff_thread_can_start_frame(AVCodecContext *avctx)
 +{
 +    PerThreadContext *p = avctx->thread_opaque;
 +    if ((avctx->active_thread_type&FF_THREAD_FRAME) && p->state != STATE_SETTING_UP &&
 +        (avctx->codec->update_thread_context || (!avctx->thread_safe_callbacks &&
 +                avctx->get_buffer != avcodec_default_get_buffer))) {
 +        return 0;
 +    }
 +    return 1;
 +}
 +
  int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
  {
      PerThreadContext *p = avctx->thread_opaque;
 -    int *progress, err;
 +    int err;
 +    volatile int *progress;
  
      f->owner = avctx;
  
 +    ff_init_buffer_info(avctx, f);
 +
      if (!(avctx->active_thread_type&FF_THREAD_FRAME)) {
          f->thread_opaque = NULL;
          return avctx->get_buffer(avctx, f);
      }
  
      if (p->state != STATE_SETTING_UP &&
 -        (avctx->codec->update_thread_context || !avctx->thread_safe_callbacks)) {
 +        (avctx->codec->update_thread_context || (!avctx->thread_safe_callbacks &&
 +                avctx->get_buffer != avcodec_default_get_buffer))) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
          return -1;
      }
  
      pthread_mutex_lock(&p->parent->buffer_mutex);
 -    f->thread_opaque = progress = allocate_progress(p);
 +    f->thread_opaque = (int*)(progress = allocate_progress(p));
  
      if (!progress) {
          pthread_mutex_unlock(&p->parent->buffer_mutex);
          avctx->get_buffer == avcodec_default_get_buffer) {
          err = avctx->get_buffer(avctx, f);
      } else {
 +        pthread_mutex_lock(&p->progress_mutex);
          p->requested_frame = f;
          p->state = STATE_GET_BUFFER;
 -        pthread_mutex_lock(&p->progress_mutex);
 -        pthread_cond_signal(&p->progress_cond);
 +        pthread_cond_broadcast(&p->progress_cond);
  
          while (p->state != STATE_SETTING_UP)
              pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
diff --combined libavcodec/vorbisdec.c
@@@ -1,22 -1,18 +1,22 @@@
 -/*
 - * This file is part of Libav.
 +/**
 + * @file
 + * Vorbis I decoder
 + * @author Denes Balatoni  ( dbalatoni programozo hu )
 + *
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -31,7 -27,6 +31,7 @@@
  
  #define BITSTREAM_READER_LE
  #include "libavutil/float_dsp.h"
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
  #include "get_bits.h"
  #include "dsputil.h"
@@@ -46,6 -41,9 +46,6 @@@
  #define V_MAX_VLCS (1 << 16)
  #define V_MAX_PARTITIONS (1 << 20)
  
 -#undef NDEBUG
 -#include <assert.h>
 -
  typedef struct {
      uint8_t      dimensions;
      uint8_t      lookup_type;
@@@ -683,7 -681,7 +683,7 @@@ static int vorbis_parse_setup_hdr_resid
          res_setup->partition_size = get_bits(gb, 24) + 1;
          /* Validations to prevent a buffer overflow later. */
          if (res_setup->begin>res_setup->end ||
 -            res_setup->end > (res_setup->type == 2 ? vc->avccontext->channels : 1) * vc->blocksize[1] / 2 ||
 +            res_setup->end > (res_setup->type == 2 ? vc->audio_channels : 1) * vc->blocksize[1] / 2 ||
              (res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) {
              av_log(vc->avccontext, AV_LOG_ERROR,
                     "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",
@@@ -938,12 -936,12 +938,12 @@@ static int vorbis_parse_id_hdr(vorbis_c
      vc->bitrate_minimum = get_bits_long(gb, 32);
      bl0 = get_bits(gb, 4);
      bl1 = get_bits(gb, 4);
 -    vc->blocksize[0] = (1 << bl0);
 -    vc->blocksize[1] = (1 << bl1);
      if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
          av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
          return AVERROR_INVALIDDATA;
      }
 +    vc->blocksize[0] = (1 << bl0);
 +    vc->blocksize[1] = (1 << bl1);
      vc->win[0] = ff_vorbis_vwin[bl0 - 6];
      vc->win[1] = ff_vorbis_vwin[bl1 - 6];
  
@@@ -1167,7 -1165,7 +1167,7 @@@ static int vorbis_floor1_decode(vorbis_
      uint16_t floor1_Y[258];
      uint16_t floor1_Y_final[258];
      int floor1_flag[258];
 -    unsigned class, cdim, cbits, csub, cval, offset, i, j;
 +    unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
      int book, adx, ady, dy, off, predicted, err;
  
  
  
      offset = 2;
      for (i = 0; i < vf->partitions; ++i) {
 -        class = vf->partition_class[i];
 -        cdim   = vf->class_dimensions[class];
 -        cbits  = vf->class_subclasses[class];
 +        partition_class = vf->partition_class[i];
 +        cdim   = vf->class_dimensions[partition_class];
 +        cbits  = vf->class_subclasses[partition_class];
          csub = (1 << cbits) - 1;
          cval = 0;
  
          av_dlog(NULL, "Cbits %u\n", cbits);
  
          if (cbits) // this reads all subclasses for this partition's class
 -            cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[class]].vlc.table,
 -                            vc->codebooks[vf->class_masterbook[class]].nb_bits, 3);
 +            cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
 +                            vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
  
          for (j = 0; j < cdim; ++j) {
 -            book = vf->subclass_books[class][cval & csub];
 +            book = vf->subclass_books[partition_class][cval & csub];
  
              av_dlog(NULL, "book %d Cbits %u cval %u  bits:%d\n",
                      book, cbits, cval, get_bits_count(gb));
@@@ -1332,7 -1330,7 +1332,7 @@@ static av_always_inline int vorbis_resi
  
                          av_dlog(NULL, "Classword: %u\n", temp);
  
 -                        assert(vr->classifications > 1 && temp <= 65536); //needed for inverse[]
 +                        av_assert0(vr->classifications > 1 && temp <= 65536); //needed for inverse[]
                          for (i = 0; i < c_p_c; ++i) {
                              unsigned temp2;
  
                                  for (k = 0; k < step; ++k) {
                                      coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
                                      for (l = 0; l < dim; ++l)
-                                         vec[voffs + k + l * step] += codebook.codevectors[coffs + l];  // FPMATH
+                                         vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
                                  }
                              } else if (vr_type == 1) {
                                  voffs = voffset + j * vlen;
                                  for (k = 0; k < step; ++k) {
                                      coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
                                      for (l = 0; l < dim; ++l, ++voffs) {
-                                         vec[voffs]+=codebook.codevectors[coffs+l];  // FPMATH
+                                         vec[voffs]+=codebook.codevectors[coffs+l];
  
                                          av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d  \n",
                                                  pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
                                  if (dim == 2) {
                                      for (k = 0; k < step; ++k) {
                                          coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 2;
-                                         vec[voffs + k       ] += codebook.codevectors[coffs    ];  // FPMATH
-                                         vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];  // FPMATH
+                                         vec[voffs + k       ] += codebook.codevectors[coffs    ];
+                                         vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
                                      }
                                  } else if (dim == 4) {
                                      for (k = 0; k < step; ++k, voffs += 2) {
                                          coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 4;
-                                         vec[voffs           ] += codebook.codevectors[coffs    ];  // FPMATH
-                                         vec[voffs + 1       ] += codebook.codevectors[coffs + 2];  // FPMATH
-                                         vec[voffs + vlen    ] += codebook.codevectors[coffs + 1];  // FPMATH
-                                         vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];  // FPMATH
+                                         vec[voffs           ] += codebook.codevectors[coffs    ];
+                                         vec[voffs + 1       ] += codebook.codevectors[coffs + 2];
+                                         vec[voffs + vlen    ] += codebook.codevectors[coffs + 1];
+                                         vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
                                      }
                                  } else
                                  for (k = 0; k < step; ++k) {
                                      coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
                                      for (l = 0; l < dim; l += 2, voffs++) {
-                                         vec[voffs       ] += codebook.codevectors[coffs + l    ];  // FPMATH
-                                         vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];  // FPMATH
+                                         vec[voffs       ] += codebook.codevectors[coffs + l    ];
+                                         vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
  
                                          av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n",
                                                  pass, voffset / ch + (voffs % ch) * vlen,
                                  }
  
                              } else if (vr_type == 2) {
 -                                unsigned voffs_div = FASTDIV(voffset, ch);
 +                                unsigned voffs_div = ch == 1 ? voffset : FASTDIV(voffset, ch);
                                  unsigned voffs_mod = voffset - voffs_div * ch;
  
                                  for (k = 0; k < step; ++k) {
@@@ -1621,7 -1619,7 +1621,7 @@@ static int vorbis_parse_audio_packet(vo
          mdct->imdct_half(mdct, ch_res_ptr, ch_floor_ptr);
      }
  
- // Overlap/add, save data for next overlapping  FPMATH
+ // Overlap/add, save data for next overlapping
  
      retlen = (blocksize + vc->blocksize[previous_window]) / 4;
      for (j = 0; j < vc->audio_channels; j++) {
diff --combined libavformat/utils.c
@@@ -1,21 -1,21 +1,21 @@@
  /*
 - * various utility functions for use within Libav
 + * various utility functions for use within FFmpeg
   * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -25,9 -25,7 +25,9 @@@
  #include "avio_internal.h"
  #include "internal.h"
  #include "libavcodec/internal.h"
 +#include "libavcodec/raw.h"
  #include "libavcodec/bytestream.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/opt.h"
  #include "libavutil/dict.h"
  #include "libavutil/pixdesc.h"
@@@ -38,7 -36,6 +38,7 @@@
  #include "libavutil/mathematics.h"
  #include "libavutil/parseutils.h"
  #include "libavutil/time.h"
 +#include "libavutil/timestamp.h"
  #include "riff.h"
  #include "audiointerleave.h"
  #include "url.h"
  
  /**
   * @file
 - * various utility functions for use within Libav
 + * various utility functions for use within FFmpeg
   */
  
  unsigned avformat_version(void)
  {
 +    av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
      return LIBAVFORMAT_VERSION_INT;
  }
  
  const char *avformat_configuration(void)
  {
 -    return LIBAV_CONFIGURATION;
 +    return FFMPEG_CONFIGURATION;
  }
  
  const char *avformat_license(void)
  {
  #define LICENSE_PREFIX "libavformat license: "
 -    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +}
 +
 +#define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
 +
 +static int is_relative(int64_t ts) {
 +    return ts > (RELATIVE_TS_BASE - (1LL<<48));
  }
  
  /* fraction handling */
@@@ -227,7 -217,7 +227,7 @@@ AVOutputFormat *av_guess_format(const c
      score_max = 0;
      while ((fmt = av_oformat_next(fmt))) {
          score = 0;
 -        if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
 +        if (fmt->name && short_name && match_format(short_name, fmt->name))
              score += 100;
          if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
              score += 10;
@@@ -274,33 -264,10 +274,33 @@@ AVInputFormat *av_find_input_format(con
      return NULL;
  }
  
 +int ffio_limit(AVIOContext *s, int size)
 +{
 +    if(s->maxsize>=0){
 +        int64_t remaining= s->maxsize - avio_tell(s);
 +        if(remaining < size){
 +            int64_t newsize= avio_size(s);
 +            if(!s->maxsize || s->maxsize<newsize)
 +                s->maxsize= newsize - !newsize;
 +            remaining= s->maxsize - avio_tell(s);
 +            remaining= FFMAX(remaining, 0);
 +        }
 +
 +        if(s->maxsize>=0 && remaining+1 < size){
 +            av_log(0, AV_LOG_ERROR, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
 +            size= remaining+1;
 +        }
 +    }
 +    return size;
 +}
  
  int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
  {
 -    int ret= av_new_packet(pkt, size);
 +    int ret;
 +    int orig_size = size;
 +    size= ffio_limit(s, size);
 +
 +    ret= av_new_packet(pkt, size);
  
      if(ret<0)
          return ret;
          av_free_packet(pkt);
      else
          av_shrink_packet(pkt, ret);
 +    if (pkt->size < orig_size)
 +        pkt->flags |= AV_PKT_FLAG_CORRUPT;
  
      return ret;
  }
@@@ -340,19 -305,19 +340,19 @@@ int av_filename_number_test(const char 
      return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
  }
  
 -AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 +AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
  {
      AVProbeData lpd = *pd;
      AVInputFormat *fmt1 = NULL, *fmt;
 -    int score, id3 = 0;
 +    int score, nodat = 0, score_max=0;
  
      if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
          int id3len = ff_id3v2_tag_len(lpd.buf);
          if (lpd.buf_size > id3len + 16) {
              lpd.buf += id3len;
              lpd.buf_size -= id3len;
 -        }
 -        id3 = 1;
 +        }else
 +            nodat = 1;
      }
  
      fmt = NULL;
          score = 0;
          if (fmt1->read_probe) {
              score = fmt1->read_probe(&lpd);
 +            if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
 +                score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
          } else if (fmt1->extensions) {
              if (av_match_ext(lpd.filename, fmt1->extensions)) {
                  score = 50;
              }
          }
 -        if (score > *score_max) {
 -            *score_max = score;
 +        if (score > score_max) {
 +            score_max = score;
              fmt = fmt1;
 -        }else if (score == *score_max)
 +        }else if (score == score_max)
              fmt = NULL;
      }
 -
 -    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
 -    if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
 -        while ((fmt = av_iformat_next(fmt)))
 -            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
 -                *score_max = AVPROBE_SCORE_MAX/4;
 -                break;
 -            }
 -    }
 -
 -    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
 -        while ((fmt = av_iformat_next(fmt)))
 -            if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
 -                *score_max = AVPROBE_SCORE_MAX/4-1;
 -                break;
 -            }
 -    }
 +    *score_ret= score_max;
  
      return fmt;
  }
  
 +AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 +{
 +    int score_ret;
 +    AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
 +    if(score_ret > *score_max){
 +        *score_max= score_ret;
 +        return fmt;
 +    }else
 +        return NULL;
 +}
 +
  AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
      int score=0;
      return av_probe_input_format2(pd, is_opened, &score);
  }
  
 -static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 +static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
  {
      static const struct {
          const char *name; enum AVCodecID id; enum AVMediaType type;
          { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
          { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
          { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 +        { "loas"     , AV_CODEC_ID_AAC_LATM  , AVMEDIA_TYPE_AUDIO },
          { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
          { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
          { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
          { 0 }
      };
 -    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
 +    int score;
 +    AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
  
      if (fmt) {
          int i;
              }
          }
      }
 -    return !!fmt;
 +    return score;
  }
  
  /************************************************************/
  /* input media file */
  
 +int av_demuxer_open(AVFormatContext *ic){
 +    int err;
 +
 +    if (ic->iformat->read_header) {
 +        err = ic->iformat->read_header(ic);
 +        if (err < 0)
 +            return err;
 +    }
 +
 +    if (ic->pb && !ic->data_offset)
 +        ic->data_offset = avio_tell(ic->pb);
 +
 +    return 0;
 +}
 +
 +
  /** size of probe buffer, for guessing file type from file contents */
  #define PROBE_BUF_MIN 2048
  #define PROBE_BUF_MAX (1<<20)
@@@ -477,19 -427,13 +477,19 @@@ int av_probe_input_buffer(AVIOContext *
          probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
          int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
          int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
 +        void *buftmp;
  
          if (probe_size < offset) {
              continue;
          }
  
          /* read probe data */
 -        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
 +        buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
 +        if(!buftmp){
 +            av_free(buf);
 +            return AVERROR(ENOMEM);
 +        }
 +        buf=buftmp;
          if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
              /* fail if error was not end of file, otherwise, lower score */
              if (ret != AVERROR_EOF) {
          *fmt = av_probe_input_format2(&pd, 1, &score);
          if(*fmt){
              if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
 -                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
 +                av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
              }else
 -                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
 +                av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
          }
      }
  
@@@ -537,8 -481,7 +537,8 @@@ static int init_input(AVFormatContext *
          if (!s->iformat)
              return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
          else if (s->iformat->flags & AVFMT_NOFILE)
 -            return AVERROR(EINVAL);
 +            av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 +                                      "will be ignored with AVFMT_NOFILE format.\n");
          return 0;
      }
  
          (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
          return 0;
  
 -    if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
 +    if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
                            &s->interrupt_callback, options)) < 0)
          return ret;
      if (s->iformat)
@@@ -571,7 -514,7 +571,7 @@@ static AVPacket *add_to_pktbuf(AVPacket
      return &pktl->pkt;
  }
  
 -static void queue_attached_pictures(AVFormatContext *s)
 +void avformat_queue_attached_pictures(AVFormatContext *s)
  {
      int i;
      for (i = 0; i < s->nb_streams; i++)
@@@ -592,10 -535,6 +592,10 @@@ int avformat_open_input(AVFormatContex
  
      if (!s && !(s = avformat_alloc_context()))
          return AVERROR(ENOMEM);
 +    if (!s->av_class){
 +        av_log(0, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
 +        return AVERROR(EINVAL);
 +    }
      if (fmt)
          s->iformat = fmt;
  
      if (s->pb)
          ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
  
 -    if (s->iformat->read_header)
 +    if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
          if ((ret = s->iformat->read_header(s)) < 0)
              goto fail;
  
          goto fail;
      ff_id3v2_free_extra_meta(&id3v2_extra_meta);
  
 -    queue_attached_pictures(s);
 +    avformat_queue_attached_pictures(s);
  
 -    if (s->pb && !s->data_offset)
 +    if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
          s->data_offset = avio_tell(s->pb);
  
      s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
@@@ -674,39 -613,27 +674,39 @@@ fail
  
  static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
  {
 -    if(st->codec->codec_id == AV_CODEC_ID_PROBE){
 +    if(st->request_probe>0){
          AVProbeData *pd = &st->probe_data;
 -        av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
 +        int end;
 +        av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
          --st->probe_packets;
  
          if (pkt) {
 -            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 +            uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 +            if(!new_buf)
 +                goto no_packet;
 +            pd->buf = new_buf;
              memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
              pd->buf_size += pkt->size;
              memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
          } else {
 +no_packet:
              st->probe_packets = 0;
          }
  
 -        if (!st->probe_packets ||
 -            av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
 -            set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
 -            if(st->codec->codec_id != AV_CODEC_ID_PROBE){
 +        end=    s->raw_packet_buffer_remaining_size <= 0
 +                || st->probe_packets<=0;
 +
 +        if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 +            int score= set_codec_from_probe_data(s, st, pd);
 +            if(    (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
 +                || end){
                  pd->buf_size=0;
                  av_freep(&pd->buf);
 -                av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 +                st->request_probe= -1;
 +                if(st->codec->codec_id != AV_CODEC_ID_NONE){
 +                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 +                }else
 +                    av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
              }
          }
      }
@@@ -723,7 -650,15 +723,7 @@@ int ff_read_packet(AVFormatContext *s, 
          if (pktl) {
              *pkt = pktl->pkt;
              st = s->streams[pkt->stream_index];
 -            if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
 -                s->raw_packet_buffer_remaining_size < pkt->size) {
 -                AVProbeData *pd;
 -                if (st->probe_packets) {
 -                    probe_codec(s, st, NULL);
 -                }
 -                pd = &st->probe_data;
 -                av_freep(&pd->buf);
 -                pd->buf_size = 0;
 +            if(st->request_probe <= 0){
                  s->raw_packet_buffer = pktl->next;
                  s->raw_packet_buffer_remaining_size += pkt->size;
                  av_free(pktl);
                  if (st->probe_packets) {
                      probe_codec(s, st, NULL);
                  }
 +                av_assert0(st->request_probe <= 0);
              }
              continue;
          }
              continue;
          }
  
 +        if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
 +            av_packet_merge_side_data(pkt);
 +
 +        if(pkt->stream_index >= (unsigned)s->nb_streams){
 +            av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
 +            continue;
 +        }
 +
          st= s->streams[pkt->stream_index];
  
          switch(st->codec->codec_type){
              if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
              break;
          }
 +        /* TODO: audio: time filter; video: frame reordering (pts != dts) */
 +        if (s->use_wallclock_as_timestamps)
 +            pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
  
 -        if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
 -                     !st->probe_packets))
 +        if(!pktl && st->request_probe <= 0)
              return ret;
  
          add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
@@@ -800,17 -724,6 +800,17 @@@ int av_read_packet(AVFormatContext *s, 
  
  /**********************************************************/
  
 +static int determinable_frame_size(AVCodecContext *avctx)
 +{
 +    if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
 +        avctx->codec_id == AV_CODEC_ID_MP1 ||
 +        avctx->codec_id == AV_CODEC_ID_MP2 ||
 +        avctx->codec_id == AV_CODEC_ID_MP3/* ||
 +        avctx->codec_id == AV_CODEC_ID_CELT*/)
 +        return 1;
 +    return 0;
 +}
 +
  /**
   * Get the number of samples of an audio frame. Return -1 on error.
   */
@@@ -845,9 -758,9 +845,9 @@@ static void compute_frame_duration(int 
      *pden = 0;
      switch(st->codec->codec_type) {
      case AVMEDIA_TYPE_VIDEO:
 -        if (st->avg_frame_rate.num) {
 -            *pnum = st->avg_frame_rate.den;
 -            *pden = st->avg_frame_rate.num;
 +        if (st->r_frame_rate.num && !pc) {
 +            *pnum = st->r_frame_rate.den;
 +            *pden = st->r_frame_rate.num;
          } else if(st->time_base.num*1000LL > st->time_base.den) {
              *pnum = st->time_base.num;
              *pden = st->time_base.den;
      }
  }
  
 -static int is_intra_only(enum AVCodecID id)
 +static int is_intra_only(AVCodecContext *enc){
 +    AVCodecDescriptor *desc;
 +
 +    if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
 +        return 1;
 +
 +    desc = av_codec_get_codec_descriptor(enc);
 +    if (!desc) {
 +        desc = avcodec_descriptor_get(enc->codec_id);
 +        av_codec_set_codec_descriptor(enc, desc);
 +    }
 +    if (desc)
 +        return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
 +    return 0;
 +}
 +
 +static int has_decode_delay_been_guessed(AVStream *st)
  {
 -    const AVCodecDescriptor *d = avcodec_descriptor_get(id);
 -    if (!d)
 -        return 0;
 -    if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
 -        return 0;
 -    return 1;
 +    if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
 +#if CONFIG_H264_DECODER
 +    if(st->codec->has_b_frames &&
 +       avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
 +        return 1;
 +#endif
 +    if(st->codec->has_b_frames<3)
 +        return st->nb_decoded_frames >= 7;
 +    else if(st->codec->has_b_frames<4)
 +        return st->nb_decoded_frames >= 18;
 +    else
 +        return st->nb_decoded_frames >= 20;
 +}
 +
 +static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
 +{
 +    if (pktl->next)
 +        return pktl->next;
 +    if (pktl == s->parse_queue_end)
 +        return s->packet_buffer;
 +    return NULL;
  }
  
  static void update_initial_timestamps(AVFormatContext *s, int stream_index,
                                        int64_t dts, int64_t pts)
  {
      AVStream *st= s->streams[stream_index];
 -    AVPacketList *pktl= s->packet_buffer;
 +    AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
  
 -    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 +    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
          return;
  
 -    st->first_dts= dts - st->cur_dts;
 +    st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
      st->cur_dts= dts;
  
 -    for(; pktl; pktl= pktl->next){
 +    if (is_relative(pts))
 +        pts += st->first_dts - RELATIVE_TS_BASE;
 +
 +    for(; pktl; pktl= get_next_pkt(s, st, pktl)){
          if(pktl->pkt.stream_index != stream_index)
              continue;
 -        //FIXME think more about this check
 -        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 -            pktl->pkt.pts += st->first_dts;
 +        if(is_relative(pktl->pkt.pts))
 +            pktl->pkt.pts += st->first_dts - RELATIVE_TS_BASE;
  
 -        if(pktl->pkt.dts != AV_NOPTS_VALUE)
 -            pktl->pkt.dts += st->first_dts;
 +        if(is_relative(pktl->pkt.dts))
 +            pktl->pkt.dts += st->first_dts - RELATIVE_TS_BASE;
  
          if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
              st->start_time= pktl->pkt.pts;
  static void update_initial_durations(AVFormatContext *s, AVStream *st,
                                       int stream_index, int duration)
  {
 -    AVPacketList *pktl= s->packet_buffer;
 -    int64_t cur_dts= 0;
 +    AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
 +    int64_t cur_dts= RELATIVE_TS_BASE;
  
      if(st->first_dts != AV_NOPTS_VALUE){
          cur_dts= st->first_dts;
 -        for(; pktl; pktl= pktl->next){
 +        for(; pktl; pktl= get_next_pkt(s, st, pktl)){
              if(pktl->pkt.stream_index == stream_index){
                  if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
                      break;
                  cur_dts -= duration;
              }
          }
 -        pktl= s->packet_buffer;
 +        if(pktl && pktl->pkt.dts != st->first_dts) {
 +            av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in que\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
 +            return;
 +        }
 +        if(!pktl) {
 +            av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in ques\n", av_ts2str(st->first_dts));
 +            return;
 +        }
 +        pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
          st->first_dts = cur_dts;
 -    }else if(st->cur_dts)
 +    }else if(st->cur_dts != RELATIVE_TS_BASE)
          return;
  
 -    for(; pktl; pktl= pktl->next){
 +    for(; pktl; pktl= get_next_pkt(s, st, pktl)){
          if(pktl->pkt.stream_index != stream_index)
              continue;
 -        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 +        if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
             && !pktl->pkt.duration){
              pktl->pkt.dts= cur_dts;
              if(!st->codec->has_b_frames)
                  pktl->pkt.pts= cur_dts;
 -            cur_dts += duration;
 -            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
 +//            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
                  pktl->pkt.duration = duration;
          }else
              break;
 +        cur_dts = pktl->pkt.dts + pktl->pkt.duration;
      }
 -    if(st->first_dts == AV_NOPTS_VALUE)
 +    if(!pktl)
          st->cur_dts= cur_dts;
  }
  
@@@ -1006,10 -878,6 +1006,10 @@@ static void compute_pkt_fields(AVFormat
      if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
          pkt->dts= AV_NOPTS_VALUE;
  
 +    if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
 +        //FIXME Set low_delay = 0 when has_b_frames = 1
 +        st->codec->has_b_frames = 1;
 +
      /* do we have a video B-frame ? */
      delay= st->codec->has_b_frames;
      presentation_delayed = 0;
          pc && pc->pict_type != AV_PICTURE_TYPE_B)
          presentation_delayed = 1;
  
 -    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 -       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 +    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
          pkt->dts -= 1LL<<st->pts_wrap_bits;
      }
  
      // we take the conservative approach and discard both
      // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
      if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 -        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
 -        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 +        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
 +        if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
 +            pkt->dts= AV_NOPTS_VALUE;
      }
  
 -    if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
 +    if (pkt->duration == 0) {
          compute_frame_duration(&num, &den, st, pc, pkt);
          if (den && num) {
              pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
 -
 -            if(pkt->duration != 0 && s->packet_buffer)
 -                update_initial_durations(s, st, pkt->stream_index, pkt->duration);
          }
      }
 +    if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
 +        update_initial_durations(s, st, pkt->stream_index, pkt->duration);
  
      /* correct timestamps with byte offset if demuxers only have timestamps
         on packet boundaries */
      if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
          presentation_delayed = 1;
  
 -//    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);
 +//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
 +//           presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
      /* interpolate PTS and DTS if they are not present */
      //We skip H264 currently because delay and has_b_frames are not reliably set
      if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
              by knowing the future */
          } else if (pkt->pts != AV_NOPTS_VALUE ||
                     pkt->dts != AV_NOPTS_VALUE ||
 -                   pkt->duration              ||
 -                   st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 +                   pkt->duration                ) {
              int duration = pkt->duration;
 -            if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 -                compute_frame_duration(&num, &den, st, pc, pkt);
 -                if (den && num) {
 -                    duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
 -                                                 den * (int64_t)st->time_base.num,
 -                                                 AV_ROUND_DOWN);
 -                    if (duration != 0 && s->packet_buffer) {
 -                        update_initial_durations(s, st, pkt->stream_index,
 -                                                 duration);
 -                    }
 +
 +            if(pkt->pts != AV_NOPTS_VALUE && duration){
 +                int64_t old_diff= FFABS(st->cur_dts - duration - pkt->pts);
 +                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
 +                if(   old_diff < new_diff && old_diff < (duration>>3)
 +                   && st->codec->codec_type == AVMEDIA_TYPE_VIDEO
 +                   && (!strcmp(s->iformat->name, "mpeg") ||
 +                       !strcmp(s->iformat->name, "mpegts"))){
 +                    pkt->pts += duration;
 +                    av_log(s, AV_LOG_WARNING, "Adjusting PTS forward\n");
 +//                    av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%s size:%d\n",
 +//                           pkt->stream_index, old_diff, new_diff, pkt->duration, av_ts2str(st->cur_dts), pkt->size);
                  }
              }
  
 -            if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
 -                duration) {
 -                /* presentation is not delayed : PTS and DTS are the same */
 -                if (pkt->pts == AV_NOPTS_VALUE)
 -                    pkt->pts = pkt->dts;
 -                update_initial_timestamps(s, pkt->stream_index, pkt->pts,
 -                                          pkt->pts);
 -                if (pkt->pts == AV_NOPTS_VALUE)
 -                    pkt->pts = st->cur_dts;
 -                pkt->dts = pkt->pts;
 -                if (pkt->pts != AV_NOPTS_VALUE)
 -                    st->cur_dts = pkt->pts + duration;
 -            }
 +            /* presentation is not delayed : PTS and DTS are the same */
 +            if (pkt->pts == AV_NOPTS_VALUE)
 +                pkt->pts = pkt->dts;
 +            update_initial_timestamps(s, pkt->stream_index, pkt->pts,
 +                                      pkt->pts);
 +            if (pkt->pts == AV_NOPTS_VALUE)
 +                pkt->pts = st->cur_dts;
 +            pkt->dts = pkt->pts;
 +            if (pkt->pts != AV_NOPTS_VALUE)
 +                st->cur_dts = pkt->pts + duration;
          }
      }
  
 -    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
 +    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
          st->pts_buffer[0]= pkt->pts;
          for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
              FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
              st->cur_dts = pkt->dts;
      }
  
 -//    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);
 +//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
 +//           presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
  
      /* update flags */
 -    if (is_intra_only(st->codec->codec_id))
 +    if (is_intra_only(st->codec))
          pkt->flags |= AV_PKT_FLAG_KEY;
      if (pc)
          pkt->convergence_duration = pc->convergence_duration;
@@@ -1183,9 -1052,6 +1183,9 @@@ static int parse_packet(AVFormatContex
          av_init_packet(&flush_pkt);
          pkt = &flush_pkt;
          got_output = 1;
 +    } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
 +        // preserve 0-size sync packets
 +        compute_pkt_fields(s, st, st->parser, pkt);
      }
  
      while (size > 0 || (pkt == &flush_pkt && got_output)) {
                                 pkt->pts, pkt->dts, pkt->pos);
  
          pkt->pts = pkt->dts = AV_NOPTS_VALUE;
 +        pkt->pos = -1;
          /* increment read pointer */
          data += len;
          size -= len;
          out_pkt.dts = st->parser->dts;
          out_pkt.pos = st->parser->pos;
  
 +        if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
 +            out_pkt.pos = st->parser->frame_offset;
 +
          if (st->parser->key_frame == 1 ||
              (st->parser->key_frame == -1 &&
               st->parser->pict_type == AV_PICTURE_TYPE_I))
              out_pkt.flags |= AV_PKT_FLAG_KEY;
  
 -        compute_pkt_fields(s, st, st->parser, &out_pkt);
 +        if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
 +            out_pkt.flags |= AV_PKT_FLAG_KEY;
  
 -        if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
 -            out_pkt.flags & AV_PKT_FLAG_KEY) {
 -            ff_reduce_index(s, st->index);
 -            av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
 -                               0, 0, AVINDEX_KEYFRAME);
 -        }
 +        compute_pkt_fields(s, st, st->parser, &out_pkt);
  
          if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
              out_pkt.destruct = pkt->destruct;
@@@ -1314,17 -1180,17 +1314,17 @@@ static int read_frame_internal(AVFormat
          if (cur_pkt.pts != AV_NOPTS_VALUE &&
              cur_pkt.dts != AV_NOPTS_VALUE &&
              cur_pkt.pts < cur_pkt.dts) {
 -            av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
 +            av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
                     cur_pkt.stream_index,
 -                   cur_pkt.pts,
 -                   cur_pkt.dts,
 +                   av_ts2str(cur_pkt.pts),
 +                   av_ts2str(cur_pkt.dts),
                     cur_pkt.size);
          }
          if (s->debug & FF_FDEBUG_TS)
 -            av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
 +            av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
                     cur_pkt.stream_index,
 -                   cur_pkt.pts,
 -                   cur_pkt.dts,
 +                   av_ts2str(cur_pkt.pts),
 +                   av_ts2str(cur_pkt.dts),
                     cur_pkt.size,
                     cur_pkt.duration,
                     cur_pkt.flags);
          if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
              st->parser = av_parser_init(st->codec->codec_id);
              if (!st->parser) {
 +                av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
 +                       "%s, packets or times may be invalid.\n",
 +                       avcodec_get_name(st->codec->codec_id));
                  /* no parser available: just output the raw packets */
                  st->need_parsing = AVSTREAM_PARSE_NONE;
              } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
                  st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
              } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
                  st->parser->flags |= PARSER_FLAG_ONCE;
 +            } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
 +                st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
              }
          }
  
              /* free packet */
              av_free_packet(&cur_pkt);
          }
 +        if (pkt->flags & AV_PKT_FLAG_KEY)
 +            st->skip_to_keyframe = 0;
 +        if (st->skip_to_keyframe) {
 +            av_free_packet(&cur_pkt);
 +            got_packet = 0;
 +        }
      }
  
      if (!got_packet && s->parse_queue)
          ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
  
      if(s->debug & FF_FDEBUG_TS)
 -        av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
 +        av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
              pkt->stream_index,
 -            pkt->pts,
 -            pkt->dts,
 +            av_ts2str(pkt->pts),
 +            av_ts2str(pkt->dts),
              pkt->size,
              pkt->duration,
              pkt->flags);
@@@ -1390,18 -1245,15 +1390,18 @@@ int av_read_frame(AVFormatContext *s, A
  {
      const int genpts = s->flags & AVFMT_FLAG_GENPTS;
      int          eof = 0;
 +    int ret;
 +    AVStream *st;
  
 -    if (!genpts)
 -        return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
 +    if (!genpts) {
 +        ret = s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
                                                            &s->packet_buffer_end,
                                                            pkt) :
                                    read_frame_internal(s, pkt);
 +        goto return_packet;
 +    }
  
      for (;;) {
 -        int ret;
          AVPacketList *pktl = s->packet_buffer;
  
          if (pktl) {
  
              if (next_pkt->dts != AV_NOPTS_VALUE) {
                  int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
 +                // last dts seen for this stream. if any of packets following
 +                // current one had no dts, we will set this to AV_NOPTS_VALUE.
 +                int64_t last_dts = next_pkt->dts;
                  while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
                      if (pktl->pkt.stream_index == next_pkt->stream_index &&
 -                        (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
 -                         av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
 -                        next_pkt->pts = pktl->pkt.dts;
 +                        (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
 +                        if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
 +                            next_pkt->pts = pktl->pkt.dts;
 +                        }
 +                        if (last_dts != AV_NOPTS_VALUE) {
 +                            // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
 +                            last_dts = pktl->pkt.dts;
 +                        }
                      }
                      pktl = pktl->next;
                  }
 +                if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
 +                    // Fixing the last reference frame had none pts issue (For MXF etc).
 +                    // We only do this when
 +                    // 1. eof.
 +                    // 2. we are not able to resolve a pts value for current packet.
 +                    // 3. the packets for this stream at the end of the files had valid dts.
 +                    next_pkt->pts = last_dts + next_pkt->duration;
 +                }
                  pktl = s->packet_buffer;
              }
  
              /* read packet from packet buffer, if there is data */
              if (!(next_pkt->pts == AV_NOPTS_VALUE &&
 -                  next_pkt->dts != AV_NOPTS_VALUE && !eof))
 -                return read_from_packet_buffer(&s->packet_buffer,
 +                  next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
 +                ret = read_from_packet_buffer(&s->packet_buffer,
                                                 &s->packet_buffer_end, pkt);
 +                goto return_packet;
 +            }
          }
  
          ret = read_frame_internal(s, pkt);
                            &s->packet_buffer_end)) < 0)
              return AVERROR(ENOMEM);
      }
 +
 +return_packet:
 +
 +    st = s->streams[pkt->stream_index];
 +    if (st->skip_samples) {
 +        uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
 +        AV_WL32(p, st->skip_samples);
 +        av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
 +        st->skip_samples = 0;
 +    }
 +
 +    if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
 +        ff_reduce_index(s, st->index);
 +        av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
 +    }
 +
 +    if (is_relative(pkt->dts))
 +        pkt->dts -= RELATIVE_TS_BASE;
 +    if (is_relative(pkt->pts))
 +        pkt->pts -= RELATIVE_TS_BASE;
 +
 +    return ret;
  }
  
  /* XXX: suppress the packet queue */
@@@ -1534,8 -1346,7 +1534,8 @@@ void ff_read_frame_flush(AVFormatContex
              st->parser = NULL;
          }
          st->last_IP_pts = AV_NOPTS_VALUE;
 -        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
 +        if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
 +        else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
          st->reference_dts = AV_NOPTS_VALUE;
  
          st->probe_packets = MAX_PROBE_PACKETS;
@@@ -1582,12 -1393,6 +1582,12 @@@ int ff_add_index_entry(AVIndexEntry **i
      if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
          return -1;
  
 +    if(timestamp == AV_NOPTS_VALUE)
 +        return AVERROR(EINVAL);
 +
 +    if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
 +        timestamp -= RELATIVE_TS_BASE;
 +
      entries = av_fast_realloc(*index_entries,
                                index_entries_allocated_size,
                                (*nb_index_entries + 1) *
@@@ -1684,7 -1489,7 +1684,7 @@@ int ff_seek_frame_binary(AVFormatContex
      if (stream_index < 0)
          return -1;
  
 -    av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
 +    av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
  
      ts_max=
      ts_min= AV_NOPTS_VALUE;
          if(e->timestamp <= target_ts || e->pos == e->min_distance){
              pos_min= e->pos;
              ts_min= e->timestamp;
 -            av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
 -                    pos_min,ts_min);
 +            av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
 +                    pos_min, av_ts2str(ts_min));
          }else{
              assert(index==0);
          }
              pos_max= e->pos;
              ts_max= e->timestamp;
              pos_limit= pos_max - e->min_distance;
 -            av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
 -                    pos_max,pos_limit, ts_max);
 +            av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
 +                    pos_max, pos_limit, av_ts2str(ts_max));
          }
      }
  
      if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
          return ret;
  
 +    ff_read_frame_flush(s);
      ff_update_cur_dts(s, st, ts);
  
      return 0;
@@@ -1743,7 -1547,7 +1743,7 @@@ int64_t ff_gen_search(AVFormatContext *
      int64_t start_pos, filesize;
      int no_change;
  
 -    av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
 +    av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
  
      if(ts_min == AV_NOPTS_VALUE){
          pos_min = s->data_offset;
              return -1;
      }
  
 +    if(ts_min >= target_ts){
 +        *ts_ret= ts_min;
 +        return pos_min;
 +    }
 +
      if(ts_max == AV_NOPTS_VALUE){
          int step= 1024;
          filesize = avio_size(s->pb);
          pos_limit= pos_max;
      }
  
 +    if(ts_max <= target_ts){
 +        *ts_ret= ts_max;
 +        return pos_max;
 +    }
 +
      if(ts_min > ts_max){
          return -1;
      }else if(ts_min == ts_max){
  
      no_change=0;
      while (pos_min < pos_limit) {
 -        av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
 -                pos_min, pos_max, ts_min, ts_max);
 +        av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
 +                pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
          assert(pos_limit <= pos_max);
  
          if(no_change==0){
              no_change++;
          else
              no_change=0;
 -        av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
 -                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
 +        av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
 +                pos_min, pos, pos_max,
 +                av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
                  pos_limit, start_pos, no_change);
          if(ts == AV_NOPTS_VALUE){
              av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
  
      pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
      ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
 +#if 0
      pos_min = pos;
      ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
      pos_min++;
      ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
 -    av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
 -            pos, ts_min, target_ts, ts_max);
 +    av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
 +            pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
 +#endif
      *ts_ret= ts;
      return pos;
  }
@@@ -1888,7 -1679,6 +1888,7 @@@ static int seek_frame_generic(AVFormatC
  
      if(index < 0 || index==st->nb_index_entries-1){
          AVPacket pkt;
 +        int nonkey=0;
  
          if(st->nb_index_entries){
              assert(st->index_entries);
              if (read_status < 0)
                  break;
              av_free_packet(&pkt);
 -            if(stream_index == pkt.stream_index){
 -                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
 +            if(stream_index == pkt.stream_index && pkt.dts > timestamp){
 +                if(pkt.flags & AV_PKT_FLAG_KEY)
 +                    break;
 +                if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
 +                    av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
                      break;
 +                }
              }
          }
          index = av_index_search_timestamp(st, timestamp, flags);
          return -1;
  
      ff_read_frame_flush(s);
 +    AV_NOWARN_DEPRECATED(
      if (s->iformat->read_seek){
          if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
              return 0;
      }
 +    )
      ie = &st->index_entries[index];
      if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
          return ret;
@@@ -1961,13 -1745,11 +1961,13 @@@ static int seek_frame_internal(AVFormat
      }
  
      /* first, we try the format specific seek */
 +    AV_NOWARN_DEPRECATED(
      if (s->iformat->read_seek) {
          ff_read_frame_flush(s);
          ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
      } else
          ret = -1;
 +    )
      if (ret >= 0) {
          return 0;
      }
@@@ -1988,7 -1770,7 +1988,7 @@@ int av_seek_frame(AVFormatContext *s, i
      int ret = seek_frame_internal(s, stream_index, timestamp, flags);
  
      if (ret >= 0)
 -        queue_attached_pictures(s);
 +        avformat_queue_attached_pictures(s);
  
      return ret;
  }
@@@ -2004,7 -1786,7 +2004,7 @@@ int avformat_seek_file(AVFormatContext 
          ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
  
          if (ret >= 0)
 -            queue_attached_pictures(s);
 +            avformat_queue_attached_pictures(s);
          return ret;
      }
  
  
      //Fallback to old API if new is not implemented but old is
      //Note the old has somewat different sematics
 -    if(s->iformat->read_seek || 1)
 -        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
 +    AV_NOWARN_DEPRECATED(
 +    if (s->iformat->read_seek || 1) {
 +        int dir = (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0);
 +        int ret = av_seek_frame(s, stream_index, ts, flags | dir);
 +        if (ret<0 && ts != min_ts && max_ts != ts) {
 +            ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
 +            if (ret >= 0)
 +                ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
 +        }
 +        return ret;
 +    }
 +    )
  
      // try some generic seek like seek_frame_generic() but with new ts semantics
  }
@@@ -2059,24 -1831,19 +2059,24 @@@ static int has_duration(AVFormatContex
   */
  static void update_stream_timings(AVFormatContext *ic)
  {
 -    int64_t start_time, start_time1, end_time, end_time1;
 +    int64_t start_time, start_time1, start_time_text, end_time, end_time1;
      int64_t duration, duration1, filesize;
      int i;
      AVStream *st;
  
      start_time = INT64_MAX;
 +    start_time_text = INT64_MAX;
      end_time = INT64_MIN;
      duration = INT64_MIN;
      for(i = 0;i < ic->nb_streams; i++) {
          st = ic->streams[i];
          if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
              start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
 -            start_time = FFMIN(start_time, start_time1);
 +            if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
 +                if (start_time1 < start_time_text)
 +                    start_time_text = start_time1;
 +            } else
 +                start_time = FFMIN(start_time, start_time1);
              if (st->duration != AV_NOPTS_VALUE) {
                  end_time1 = start_time1
                            + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
              duration = FFMAX(duration, duration1);
          }
      }
 +    if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
 +        start_time = start_time_text;
 +    else if(start_time > start_time_text)
 +        av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
 +
      if (start_time != INT64_MAX) {
          ic->start_time = start_time;
          if (end_time != INT64_MIN)
              duration = FFMAX(duration, end_time - start_time);
      }
 -    if (duration != INT64_MIN) {
 +    if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
          ic->duration = duration;
 -        if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
 +    }
 +        if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
              /* compute the bitrate */
              ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
                  (double)ic->duration;
          }
 -    }
  }
  
  static void fill_all_stream_timings(AVFormatContext *ic)
@@@ -2255,17 -2017,14 +2255,17 @@@ static void estimate_timings(AVFormatCo
          file_size && ic->pb->seekable) {
          /* get accurate estimate from the PTSes */
          estimate_timings_from_pts(ic, old_offset);
 +        ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
      } else if (has_duration(ic)) {
          /* at least one component has timings - we use them for all
             the components */
          fill_all_stream_timings(ic);
 +        ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
      } else {
          av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
          /* less precise: use bitrate info */
          estimate_timings_from_bit_rate(ic);
 +        ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
      }
      update_stream_timings(ic);
  
      }
  }
  
 -static int has_codec_parameters(AVStream *st)
 +static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
  {
      AVCodecContext *avctx = st->codec;
 -    int val;
 +
 +#define FAIL(errmsg) do {                                         \
 +        if (errmsg_ptr)                                           \
 +            *errmsg_ptr = errmsg;                                 \
 +        return 0;                                                 \
 +    } while (0)
 +
      switch (avctx->codec_type) {
      case AVMEDIA_TYPE_AUDIO:
 -        val = avctx->sample_rate && avctx->channels;
 +        if (!avctx->frame_size && determinable_frame_size(avctx))
 +            FAIL("unspecified sample size");
          if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
 -            return 0;
 +            FAIL("unspecified sample format");
 +        if (!avctx->sample_rate)
 +            FAIL("unspecified sample rate");
 +        if (!avctx->channels)
 +            FAIL("unspecified number of channels");
          break;
      case AVMEDIA_TYPE_VIDEO:
 -        val = avctx->width;
 +        if (!avctx->width)
 +            FAIL("unspecified size");
          if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
 -            return 0;
 +            FAIL("unspecified pixel format");
          break;
 -    default:
 -        val = 1;
 +    case AVMEDIA_TYPE_SUBTITLE:
 +        if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
 +            FAIL("unspecified size");
          break;
 +    case AVMEDIA_TYPE_DATA:
 +        if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
      }
 -    return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
 -}
  
 -static int has_decode_delay_been_guessed(AVStream *st)
 -{
 -    return st->codec->codec_id != AV_CODEC_ID_H264 ||
 -        st->info->nb_decoded_frames >= 6;
 +    if (avctx->codec_id == AV_CODEC_ID_NONE)
 +        FAIL("unknown codec");
 +    return 1;
  }
  
  /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
  static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
  {
-     AVCodec *codec;
+     const AVCodec *codec;
      int got_picture = 1, ret = 0;
      AVFrame picture;
 +    AVSubtitle subtitle;
      AVPacket pkt = *avpkt;
  
      if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
  
      while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
             ret >= 0 &&
 -           (!has_codec_parameters(st)         ||
 +           (!has_codec_parameters(st, NULL)   ||
             !has_decode_delay_been_guessed(st) ||
             (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
          got_picture = 0;
          case AVMEDIA_TYPE_AUDIO:
              ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
              break;
 +        case AVMEDIA_TYPE_SUBTITLE:
 +            ret = avcodec_decode_subtitle2(st->codec, &subtitle,
 +                                           &got_picture, &pkt);
 +            ret = pkt.size;
 +            break;
          default:
              break;
          }
          if (ret >= 0) {
              if (got_picture)
 -                st->info->nb_decoded_frames++;
 +                st->nb_decoded_frames++;
              pkt.data += ret;
              pkt.size -= ret;
              ret       = got_picture;
          }
      }
 +    if(!pkt.data && !got_picture)
 +        return -1;
      return ret;
  }
  
@@@ -2464,8 -2203,8 +2464,8 @@@ static void compute_chapters_end(AVForm
  }
  
  static int get_std_framerate(int i){
 -    if(i<60*12) return i*1001;
 -    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
 +    if(i<60*12) return (i+1)*1001;
 +    else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
  }
  
  /*
@@@ -2488,13 -2227,6 +2488,13 @@@ static int tb_unreliable(AVCodecContex
      return 0;
  }
  
 +#if FF_API_FORMAT_PARAMETERS
 +int av_find_stream_info(AVFormatContext *ic)
 +{
 +    return avformat_find_stream_info(ic, NULL);
 +}
 +#endif
 +
  int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
  {
      int i, count, ret, read_size, j;
      AVPacket pkt1, *pkt;
      int64_t old_offset = avio_tell(ic->pb);
      int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
 +    int flush_codecs = ic->probesize > 0;
 +
 +    if(ic->pb)
 +        av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
  
      for(i=0;i<ic->nb_streams;i++) {
-         AVCodec *codec;
+         const AVCodec *codec;
          AVDictionary *thread_opt = NULL;
          st = ic->streams[i];
  
 +        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
 +            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 +/*            if(!st->time_base.num)
 +                st->time_base= */
 +            if(!st->codec->time_base.num)
 +                st->codec->time_base= st->time_base;
 +        }
          //only for the split stuff
          if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
              st->parser = av_parser_init(st->codec->codec_id);
 -            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
 -                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
 +            if(st->parser){
 +                if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
 +                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
 +                } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
 +                    st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
 +                }
 +            } else if (st->need_parsing) {
 +                av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
 +                       "%s, packets or times may be invalid.\n",
 +                       avcodec_get_name(st->codec->codec_id));
              }
          }
          codec = st->codec->codec ? st->codec->codec :
                                : &thread_opt);
  
          //try to just open decoders, in case this is enough to get parameters
 -        if (!has_codec_parameters(st)) {
 +        if (!has_codec_parameters(st, NULL)) {
              if (codec && !st->codec->codec)
                  avcodec_open2(st->codec, codec, options ? &options[i]
                                : &thread_opt);
              int fps_analyze_framecount = 20;
  
              st = ic->streams[i];
 -            if (!has_codec_parameters(st))
 +            if (!has_codec_parameters(st, NULL))
                  break;
              /* if the timebase is coarse (like the usual millisecond precision
                 of mkv), we need to analyze more frames to reliably arrive at
              if (ic->fps_probe_size >= 0)
                  fps_analyze_framecount = ic->fps_probe_size;
              /* variable fps and no guess at the real fps */
 -            if(   tb_unreliable(st->codec) && !st->avg_frame_rate.num
 -               && st->codec_info_nb_frames < fps_analyze_framecount
 +            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
 +               && st->info->duration_count < fps_analyze_framecount
                 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
                  break;
              if(st->parser && st->parser->parser->split && !st->codec->extradata)
                  /* if we found the info for all the codecs, we can stop */
                  ret = count;
                  av_log(ic, AV_LOG_DEBUG, "All info found\n");
 +                flush_codecs = 0;
                  break;
              }
          }
          if (read_size >= ic->probesize) {
              ret = count;
              av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
 +            for (i = 0; i < ic->nb_streams; i++)
 +                if (!ic->streams[i]->r_frame_rate.num &&
 +                    ic->streams[i]->info->duration_count <= 1)
 +                    av_log(ic, AV_LOG_WARNING,
 +                           "Stream #%d: not enough frames to estimate rate; "
 +                           "consider increasing probesize\n", i);
              break;
          }
  
  
          if (ret < 0) {
              /* EOF or error*/
 -            AVPacket empty_pkt = { 0 };
 -            int err = 0;
 -            av_init_packet(&empty_pkt);
 -
 -            ret = -1; /* we could not have all the codec parameters before EOF */
 -            for(i=0;i<ic->nb_streams;i++) {
 -                st = ic->streams[i];
 -
 -                /* flush the decoders */
 -                if (st->info->found_decoder == 1) {
 -                    do {
 -                        err = try_decode_frame(st, &empty_pkt,
 -                                               (options && i < orig_nb_streams) ?
 -                                               &options[i] : NULL);
 -                    } while (err > 0 && !has_codec_parameters(st));
 -                }
 -
 -                if (err < 0) {
 -                    av_log(ic, AV_LOG_WARNING,
 -                           "decoding for stream %d failed\n", st->index);
 -                } else if (!has_codec_parameters(st)) {
 -                    char buf[256];
 -                    avcodec_string(buf, sizeof(buf), st->codec, 0);
 -                    av_log(ic, AV_LOG_WARNING,
 -                           "Could not find codec parameters (%s)\n", buf);
 -                } else {
 -                    ret = 0;
 -                }
 -            }
              break;
          }
  
              /* check for non-increasing dts */
              if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
                  st->info->fps_last_dts >= pkt->dts) {
 -                av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
 +                av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
                         "packet %d with DTS %"PRId64", packet %d with DTS "
                         "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
                         st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
              }
              st->info->fps_last_dts = pkt->dts;
              st->info->fps_last_dts_idx = st->codec_info_nb_frames;
 -
 -            /* check max_analyze_duration */
 -            if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
 -                             AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
 -                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
 +        }
 +        if (st->codec_info_nb_frames>1) {
 +            int64_t t=0;
 +            if (st->time_base.den > 0)
 +                t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
 +            if (st->avg_frame_rate.num > 0)
 +                t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
 +
 +            if (t >= ic->max_analyze_duration) {
 +                av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
                  break;
              }
 +            st->info->codec_info_duration += pkt->duration;
          }
  #if FF_API_R_FRAME_RATE
          {
              int64_t last = st->info->last_dts;
  
              if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
 +                double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
                  int64_t duration= pkt->dts - last;
 -                double dur= duration * av_q2d(st->time_base);
  
 -                if (st->info->duration_count < 2)
 -                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
 -                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
 +//                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 +//                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
 +                for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
                      int framerate= get_std_framerate(i);
 -                    int ticks= lrintf(dur*framerate/(1001*12));
 -                    double error = dur - (double)ticks*1001*12 / framerate;
 -                    st->info->duration_error[i] += error*error;
 +                    double sdts= dts*framerate/(1001*12);
 +                    for(j=0; j<2; j++){
 +                        int ticks= lrintf(sdts+j*0.5);
 +                        double error= sdts - ticks + j*0.5;
 +                        st->info->duration_error[j][0][i] += error;
 +                        st->info->duration_error[j][1][i] += error*error;
 +                    }
                  }
                  st->info->duration_count++;
                  // ignore the first 4 values, they might have some random jitter
          count++;
      }
  
 +    if (flush_codecs) {
 +        AVPacket empty_pkt = { 0 };
 +        int err = 0;
 +        av_init_packet(&empty_pkt);
 +
 +        ret = -1; /* we could not have all the codec parameters before EOF */
 +        for(i=0;i<ic->nb_streams;i++) {
 +            const char *errmsg;
 +
 +            st = ic->streams[i];
 +
 +            /* flush the decoders */
 +            if (st->info->found_decoder == 1) {
 +                do {
 +                    err = try_decode_frame(st, &empty_pkt,
 +                                            (options && i < orig_nb_streams) ?
 +                                            &options[i] : NULL);
 +                } while (err > 0 && !has_codec_parameters(st, NULL));
 +
 +                if (err < 0) {
 +                    av_log(ic, AV_LOG_INFO,
 +                        "decoding for stream %d failed\n", st->index);
 +                }
 +            }
 +
 +            if (!has_codec_parameters(st, &errmsg)) {
 +                char buf[256];
 +                avcodec_string(buf, sizeof(buf), st->codec, 0);
 +                av_log(ic, AV_LOG_WARNING,
 +                       "Could not find codec parameters for stream %d (%s): %s\n"
 +                       "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
 +                       i, buf, errmsg);
 +            } else {
 +                ret = 0;
 +            }
 +        }
 +    }
 +
      // close codecs which were opened in try_decode_frame()
      for(i=0;i<ic->nb_streams;i++) {
          st = ic->streams[i];
      for(i=0;i<ic->nb_streams;i++) {
          st = ic->streams[i];
          if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 +            if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
 +                uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
 +                if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
 +                    st->codec->codec_tag= tag;
 +            }
 +
              /* estimate average framerate if not set by demuxer */
 -            if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
 -                int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
 -                int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
 +            if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration) {
                  int      best_fps = 0;
                  double best_error = 0.01;
  
                  av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
 -                          delta_packets*(int64_t)st->time_base.den,
 -                          delta_dts*(int64_t)st->time_base.num, 60000);
 +                          (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
 +                          st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
  
                  /* round guessed framerate to a "standard" framerate if it's
                   * within 1% of the original estimate*/
                                best_fps, 12*1001, INT_MAX);
                  }
              }
 -#if FF_API_R_FRAME_RATE
              // the check for tb_unreliable() is not completely correct, since this is not about handling
              // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
              // ipmovie.c produces.
 -            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
 +            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
                  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);
              if (st->info->duration_count && !st->r_frame_rate.num
                  && tb_unreliable(st->codec)) {
                  int num = 0;
 -                double best_error= 2*av_q2d(st->time_base);
 -                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
 -
 -                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
 -                    double error = st->info->duration_error[j] * get_std_framerate(j);
 -                    if(error < best_error){
 -                        best_error= error;
 -                        num = get_std_framerate(j);
 +                double best_error= 0.01;
 +
 +                for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
 +                    int k;
 +
 +                    if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
 +                        continue;
 +                    if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
 +                        continue;
 +                    for(k=0; k<2; k++){
 +                        int n= st->info->duration_count;
 +                        double a= st->info->duration_error[k][0][j] / n;
 +                        double error= st->info->duration_error[k][1][j]/n - a*a;
 +
 +                        if(error < best_error && best_error> 0.000000001){
 +                            best_error= error;
 +                            num = get_std_framerate(j);
 +                        }
 +                        if(error < 0.02)
 +                            av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
                      }
                  }
                  // do not increase frame rate by more than 1 % in order to match a standard rate.
                  if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
                      av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
              }
 -#endif
 +
 +            if (!st->r_frame_rate.num){
 +                if(    st->codec->time_base.den * (int64_t)st->time_base.num
 +                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
 +                    st->r_frame_rate.num = st->codec->time_base.den;
 +                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
 +                }else{
 +                    st->r_frame_rate.num = st->time_base.den;
 +                    st->r_frame_rate.den = st->time_base.num;
 +                }
 +            }
          }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
              if(!st->codec->bits_per_coded_sample)
                  st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
          }
      }
  
 +    if(ic->probesize)
      estimate_timings(ic, old_offset);
  
      compute_chapters_end(ic);
              ic->streams[i]->codec->thread_count = 0;
          av_freep(&ic->streams[i]->info);
      }
 +    if(ic->pb)
 +        av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
      return ret;
  }
  
 -static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
 +AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
  {
      int i, j;
  
 -    for (i = 0; i < ic->nb_programs; i++)
 -        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
 -            if (ic->programs[i]->stream_index[j] == s)
 -                return ic->programs[i];
 +    for (i = 0; i < ic->nb_programs; i++) {
 +        if (ic->programs[i] == last) {
 +            last = NULL;
 +        } else {
 +            if (!last)
 +                for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
 +                    if (ic->programs[i]->stream_index[j] == s)
 +                        return ic->programs[i];
 +        }
 +    }
      return NULL;
  }
  
@@@ -2936,7 -2589,7 +2936,7 @@@ int av_find_best_stream(AVFormatContex
      AVCodec *decoder = NULL, *best_decoder = NULL;
  
      if (related_stream >= 0 && wanted_stream_nb < 0) {
 -        AVProgram *p = find_program_from_stream(ic, related_stream);
 +        AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
          if (p) {
              program = p->stream_index;
              nb_streams = p->nb_stream_indexes;
@@@ -3014,13 -2667,13 +3014,13 @@@ void avformat_free_context(AVFormatCont
          if (st->attached_pic.data)
              av_free_packet(&st->attached_pic);
          av_dict_free(&st->metadata);
 -        av_free(st->index_entries);
 -        av_free(st->codec->extradata);
 -        av_free(st->codec->subtitle_header);
 -        av_free(st->codec);
 -        av_free(st->priv_data);
 -        av_free(st->info);
 -        av_free(st);
 +        av_freep(&st->index_entries);
 +        av_freep(&st->codec->extradata);
 +        av_freep(&st->codec->subtitle_header);
 +        av_freep(&st->codec);
 +        av_freep(&st->priv_data);
 +        av_freep(&st->info);
 +        av_freep(&st);
      }
      for(i=s->nb_programs-1; i>=0; i--) {
          av_dict_free(&s->programs[i]->metadata);
      av_freep(&s->priv_data);
      while(s->nb_chapters--) {
          av_dict_free(&s->chapters[s->nb_chapters]->metadata);
 -        av_free(s->chapters[s->nb_chapters]);
 +        av_freep(&s->chapters[s->nb_chapters]);
      }
      av_freep(&s->chapters);
      av_dict_free(&s->metadata);
@@@ -3049,10 -2702,10 +3049,10 @@@ void av_close_input_file(AVFormatContex
  void avformat_close_input(AVFormatContext **ps)
  {
      AVFormatContext *s = *ps;
 -    AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
 +    AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
                         NULL : s->pb;
      flush_packet_queue(s);
 -    if (s->iformat->read_close)
 +    if (s->iformat && (s->iformat->read_close))
          s->iformat->read_close(s);
      avformat_free_context(s);
      *ps = NULL;
          avio_close(pb);
  }
  
 +#if FF_API_NEW_STREAM
 +AVStream *av_new_stream(AVFormatContext *s, int id)
 +{
 +    AVStream *st = avformat_new_stream(s, NULL);
 +    if (st)
 +        st->id = id;
 +    return st;
 +}
 +#endif
 +
  AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
  {
      AVStream *st;
          av_free(st);
          return NULL;
      }
 +    st->info->last_dts = AV_NOPTS_VALUE;
  
      st->codec = avcodec_alloc_context3(c);
      if (s->iformat) {
             but durations get some timestamps, formats with some unknown
             timestamps have their first few packets buffered and the
             timestamps corrected before they are returned to the user */
 -    st->cur_dts = 0;
 +    st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
      st->first_dts = AV_NOPTS_VALUE;
      st->probe_packets = MAX_PROBE_PACKETS;
  
@@@ -3177,69 -2819,6 +3177,69 @@@ AVChapter *avpriv_new_chapter(AVFormatC
  /************************************************************/
  /* output media file */
  
 +int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
 +                                   const char *format, const char *filename)
 +{
 +    AVFormatContext *s = avformat_alloc_context();
 +    int ret = 0;
 +
 +    *avctx = NULL;
 +    if (!s)
 +        goto nomem;
 +
 +    if (!oformat) {
 +        if (format) {
 +            oformat = av_guess_format(format, NULL, NULL);
 +            if (!oformat) {
 +                av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
 +                ret = AVERROR(EINVAL);
 +                goto error;
 +            }
 +        } else {
 +            oformat = av_guess_format(NULL, filename, NULL);
 +            if (!oformat) {
 +                ret = AVERROR(EINVAL);
 +                av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
 +                       filename);
 +                goto error;
 +            }
 +        }
 +    }
 +
 +    s->oformat = oformat;
 +    if (s->oformat->priv_data_size > 0) {
 +        s->priv_data = av_mallocz(s->oformat->priv_data_size);
 +        if (!s->priv_data)
 +            goto nomem;
 +        if (s->oformat->priv_class) {
 +            *(const AVClass**)s->priv_data= s->oformat->priv_class;
 +            av_opt_set_defaults(s->priv_data);
 +        }
 +    } else
 +        s->priv_data = NULL;
 +
 +    if (filename)
 +        av_strlcpy(s->filename, filename, sizeof(s->filename));
 +    *avctx = s;
 +    return 0;
 +nomem:
 +    av_log(s, AV_LOG_ERROR, "Out of memory\n");
 +    ret = AVERROR(ENOMEM);
 +error:
 +    avformat_free_context(s);
 +    return ret;
 +}
 +
 +#if FF_API_ALLOC_OUTPUT_CONTEXT
 +AVFormatContext *avformat_alloc_output_context(const char *format,
 +                                               AVOutputFormat *oformat, const char *filename)
 +{
 +    AVFormatContext *avctx;
 +    int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
 +    return ret < 0 ? NULL : avctx;
 +}
 +#endif
 +
  static int validate_codec_tag(AVFormatContext *s, AVStream *st)
  {
      const AVCodecTag *avctag;
@@@ -3283,9 -2862,6 +3283,9 @@@ int avformat_write_header(AVFormatConte
          av_dict_copy(&tmp, *options, 0);
      if ((ret = av_opt_set_dict(s, &tmp)) < 0)
          goto fail;
 +    if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
 +        (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 +        goto fail;
  
      // some sanity checks
      if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
                  ret = AVERROR(EINVAL);
                  goto fail;
              }
 -            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
 +            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
 +               && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
 +            ){
                  av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
                         "(%d/%d) and encoder layer (%d/%d)\n",
                         st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
          }
  
          if(s->oformat->codec_tag){
 -            if(st->codec->codec_tag && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
 -                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
 +            if(   st->codec->codec_tag
 +               && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO
 +               && (av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 || av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) ==MKTAG('r', 'a', 'w', ' '))
 +               && !validate_codec_tag(s, st)){
 +                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi/mov, we override it here
                  st->codec->codec_tag= 0;
              }
              if(st->codec->codec_tag){
                  if (!validate_codec_tag(s, st)) {
 -                    char tagbuf[32];
 +                    char tagbuf[32], cortag[32];
                      av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
 +                    av_get_codec_tag_string(cortag, sizeof(cortag), av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id));
                      av_log(s, AV_LOG_ERROR,
 -                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
 -                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
 +                           "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
 +                           tagbuf, st->codec->codec_tag, st->codec->codec_id, cortag);
                      ret = AVERROR_INVALIDDATA;
                      goto fail;
                  }
  
      if(s->oformat->write_header){
          ret = s->oformat->write_header(s);
 +        if (ret >= 0 && s->pb && s->pb->error < 0)
 +            ret = s->pb->error;
          if (ret < 0)
              goto fail;
      }
@@@ -3427,8 -2995,11 +3427,8 @@@ static int compute_pkt_fields2(AVFormat
      int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
      int num, den, frame_size, i;
  
 -    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
 -            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
 -
 -/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
 -        return AVERROR(EINVAL);*/
 +    av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
 +            av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
  
      /* duration field */
      if (pkt->duration == 0) {
  
      //XXX/FIXME this is a temporary hack until all encoders output pts
      if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
 +        static int warned;
 +        if (!warned) {
 +            av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
 +            warned = 1;
 +        }
          pkt->dts=
  //        pkt->pts= st->cur_dts;
          pkt->pts= st->pts.val;
          ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
            st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
          av_log(s, AV_LOG_ERROR,
 -               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
 -               st->index, st->cur_dts, pkt->dts);
 +               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
 +               st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
          return AVERROR(EINVAL);
      }
      if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
 -        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
 +        av_log(s, AV_LOG_ERROR, "pts (%s) < dts (%s) in stream %d\n",
 +               av_ts2str(pkt->pts), av_ts2str(pkt->dts), st->index);
          return AVERROR(EINVAL);
      }
  
 -//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
 +//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n", av_ts2str(pkt->pts), av_ts2str(pkt->dts));
      st->cur_dts= pkt->dts;
      st->pts.val= pkt->dts;
  
@@@ -3508,12 -3073,8 +3508,12 @@@ int av_write_frame(AVFormatContext *s, 
      int ret;
  
      if (!pkt) {
 -        if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
 -            return s->oformat->write_packet(s, pkt);
 +        if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
 +            ret = s->oformat->write_packet(s, pkt);
 +            if (ret >= 0 && s->pb && s->pb->error < 0)
 +                ret = s->pb->error;
 +            return ret;
 +        }
          return 1;
      }
  
          return ret;
  
      ret= s->oformat->write_packet(s, pkt);
 +    if (ret >= 0 && s->pb && s->pb->error < 0)
 +        ret = s->pb->error;
  
      if (ret >= 0)
          s->streams[pkt->stream_index]->nb_frames++;
      return ret;
  }
  
 -void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
 +#define CHUNK_START 0x1000
 +
 +int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
                                int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
  {
      AVPacketList **next_point, *this_pktl;
 +    AVStream *st= s->streams[pkt->stream_index];
 +    int chunked= s->max_chunk_size || s->max_chunk_duration;
  
      this_pktl = av_mallocz(sizeof(AVPacketList));
 +    if (!this_pktl)
 +        return AVERROR(ENOMEM);
      this_pktl->pkt= *pkt;
      pkt->destruct= NULL;             // do not free original but only the copy
      av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
  
      if(s->streams[pkt->stream_index]->last_in_packet_buffer){
 -        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
 -    }else
 +        next_point = &(st->last_in_packet_buffer->next);
 +    }else{
          next_point = &s->packet_buffer;
 +    }
  
      if(*next_point){
 +        if(chunked){
 +            uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
 +            if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
 +               && st->interleaver_chunk_duration + pkt->duration <= max-1U){
 +                st->interleaver_chunk_size     += pkt->size;
 +                st->interleaver_chunk_duration += pkt->duration;
 +                goto next_non_null;
 +            }else{
 +                st->interleaver_chunk_size     =
 +                st->interleaver_chunk_duration = 0;
 +                this_pktl->pkt.flags |= CHUNK_START;
 +            }
 +        }
 +
          if(compare(s, &s->packet_buffer_end->pkt, pkt)){
 -            while(!compare(s, &(*next_point)->pkt, pkt)){
 +            while(   *next_point
 +                  && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
 +                      || !compare(s, &(*next_point)->pkt, pkt))){
                  next_point= &(*next_point)->next;
              }
 -            goto next_non_null;
 +            if(*next_point)
 +                goto next_non_null;
          }else{
              next_point = &(s->packet_buffer_end->next);
          }
@@@ -3589,7 -3124,6 +3589,7 @@@ next_non_null
  
      s->streams[pkt->stream_index]->last_in_packet_buffer=
      *next_point= this_pktl;
 +    return 0;
  }
  
  static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
      AVStream *st2= s->streams[ next->stream_index];
      int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
                               st->time_base);
 +    if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
 +        int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO);
 +        int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO);
 +        if(ts == ts2){
 +            ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
 +               -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
 +            ts2=0;
 +        }
 +        comp= (ts>ts2) - (ts<ts2);
 +    }
  
      if (comp == 0)
          return pkt->stream_index < next->stream_index;
@@@ -3618,46 -3142,17 +3618,46 @@@ int ff_interleave_packet_per_dts(AVForm
                                   AVPacket *pkt, int flush)
  {
      AVPacketList *pktl;
 -    int stream_count=0;
 -    int i;
 +    int stream_count=0, noninterleaved_count=0;
 +    int64_t delta_dts_max = 0;
 +    int i, ret;
  
      if(pkt){
 -        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
 +        ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
 +        if (ret < 0)
 +            return ret;
      }
  
 -    for(i=0; i < s->nb_streams; i++)
 -        stream_count+= !!s->streams[i]->last_in_packet_buffer;
 +    for(i=0; i < s->nb_streams; i++) {
 +        if (s->streams[i]->last_in_packet_buffer) {
 +            ++stream_count;
 +        } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 +            ++noninterleaved_count;
 +        }
 +    }
  
 -    if(stream_count && (s->nb_streams == stream_count || flush)){
 +    if (s->nb_streams == stream_count) {
 +        flush = 1;
 +    } else if (!flush){
 +        for(i=0; i < s->nb_streams; i++) {
 +            if (s->streams[i]->last_in_packet_buffer) {
 +                int64_t delta_dts =
 +                    av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
 +                                s->streams[i]->time_base,
 +                                AV_TIME_BASE_Q) -
 +                    av_rescale_q(s->packet_buffer->pkt.dts,
 +                                s->streams[s->packet_buffer->pkt.stream_index]->time_base,
 +                                AV_TIME_BASE_Q);
 +                delta_dts_max= FFMAX(delta_dts_max, delta_dts);
 +            }
 +        }
 +        if(s->nb_streams == stream_count+noninterleaved_count &&
 +           delta_dts_max > 20*AV_TIME_BASE) {
 +            av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
 +            flush = 1;
 +        }
 +    }
 +    if(stream_count && flush){
          pktl= s->packet_buffer;
          *out= pktl->pkt;
  
@@@ -3712,8 -3207,8 +3712,8 @@@ int av_interleaved_write_frame(AVFormat
          if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
              return 0;
  
 -        av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
 -                pkt->size, pkt->dts, pkt->pts);
 +        av_dlog(s, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
 +                pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
          if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
              return ret;
  
  
          if(ret<0)
              return ret;
 +        if(s->pb && s->pb->error)
 +            return s->pb->error;
      }
  }
  
@@@ -3764,17 -3257,11 +3764,17 @@@ int av_write_trailer(AVFormatContext *s
  
          if(ret<0)
              goto fail;
 +        if(s->pb && s->pb->error)
 +            goto fail;
      }
  
      if(s->oformat->write_trailer)
          ret = s->oformat->write_trailer(s);
  fail:
 +    if (s->pb)
 +       avio_flush(s->pb);
 +    if(ret == 0)
 +       ret = s->pb ? s->pb->error : 0;
      for(i=0;i<s->nb_streams;i++) {
          av_freep(&s->streams[i]->priv_data);
          av_freep(&s->streams[i]->index_entries);
      return ret;
  }
  
 +int av_get_output_timestamp(struct AVFormatContext *s, int stream,
 +                            int64_t *dts, int64_t *wall)
 +{
 +    if (!s->oformat || !s->oformat->get_output_timestamp)
 +        return AVERROR(ENOSYS);
 +    s->oformat->get_output_timestamp(s, stream, dts, wall);
 +    return 0;
 +}
 +
  void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
  {
      int i, j;
@@@ -3836,21 -3314,8 +3836,21 @@@ static void dump_metadata(void *ctx, AV
  
          av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
          while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 -            if(strcmp("language", tag->key))
 -                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
 +            if(strcmp("language", tag->key)){
 +                const char *p = tag->value;
 +                av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
 +                while(*p) {
 +                    char tmp[256];
 +                    size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
 +                    av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
 +                    av_log(ctx, AV_LOG_INFO, "%s", tmp);
 +                    p += len;
 +                    if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
 +                    if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
 +                    if (*p) p++;
 +                }
 +                av_log(ctx, AV_LOG_INFO, "\n");
 +            }
          }
      }
  }
@@@ -3864,7 -3329,7 +3864,7 @@@ static void dump_stream_format(AVFormat
      int g = av_gcd(st->time_base.num, st->time_base.den);
      AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
      avcodec_string(buf, sizeof(buf), st->codec, is_output);
 -    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
 +    av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
      /* the pid is an important information, so we display it */
      /* XXX: add a generic system */
      if (flags & AVFMT_SHOW_IDS)
                    st->codec->width*st->sample_aspect_ratio.num,
                    st->codec->height*st->sample_aspect_ratio.den,
                    1024*1024);
 -        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
 +        av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
                   st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
                   display_aspect_ratio.num, display_aspect_ratio.den);
      }
@@@ -4131,27 -3596,11 +4131,27 @@@ static void pkt_dump_internal(void *avc
          av_hex_dump(f, pkt->data, pkt->size);
  }
  
 +#if FF_API_PKT_DUMP
 +void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
 +{
 +    AVRational tb = { 1, AV_TIME_BASE };
 +    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
 +}
 +#endif
 +
  void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
  {
      pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
  }
  
 +#if FF_API_PKT_DUMP
 +void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
 +{
 +    AVRational tb = { 1, AV_TIME_BASE };
 +    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
 +}
 +#endif
 +
  void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
                        AVStream *st)
  {
@@@ -4165,7 -3614,7 +4165,7 @@@ void av_url_split(char *proto, int prot
                    char *path, int path_size,
                    const char *url)
  {
 -    const char *p, *ls, *at, *col, *brk;
 +    const char *p, *ls, *ls2, *at, *col, *brk;
  
      if (port_ptr)               *port_ptr = -1;
      if (proto_size > 0)         proto[0] = 0;
  
      /* separate path from hostname */
      ls = strchr(p, '/');
 +    ls2 = strchr(p, '?');
      if(!ls)
 -        ls = strchr(p, '?');
 +        ls = ls2;
 +    else if (ls && ls2)
 +        ls = FFMIN(ls, ls2);
      if(ls)
          av_strlcpy(path, ls, path_size);
      else
@@@ -4271,14 -3717,6 +4271,14 @@@ int ff_hex_to_data(uint8_t *data, cons
      return len;
  }
  
 +#if FF_API_SET_PTS_INFO
 +void av_set_pts_info(AVStream *s, int pts_wrap_bits,
 +                     unsigned int pts_num, unsigned int pts_den)
 +{
 +    avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
 +}
 +#endif
 +
  void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
                           unsigned int pts_num, unsigned int pts_den)
  {
          av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
  
      if(new_tb.num <= 0 || new_tb.den <= 0) {
 -        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
 +        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
          return;
      }
      s->time_base = new_tb;
 +    av_codec_set_pkt_timebase(s->codec, new_tb);
      s->pts_wrap_bits = pts_wrap_bits;
  }
  
@@@ -4578,87 -4015,3 +4578,87 @@@ const struct AVCodecTag *avformat_get_r
  {
      return ff_codec_wav_tags;
  }
 +
 +AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
 +{
 +    AVRational undef = {0, 1};
 +    AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
 +    AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
 +    AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
 +
 +    av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
 +               stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
 +    if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
 +        stream_sample_aspect_ratio = undef;
 +
 +    av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
 +               frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
 +    if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
 +        frame_sample_aspect_ratio = undef;
 +
 +    if (stream_sample_aspect_ratio.num)
 +        return stream_sample_aspect_ratio;
 +    else
 +        return frame_sample_aspect_ratio;
 +}
 +
 +int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
 +                                    const char *spec)
 +{
 +    if (*spec <= '9' && *spec >= '0') /* opt:index */
 +        return strtol(spec, NULL, 0) == st->index;
 +    else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
 +             *spec == 't') { /* opt:[vasdt] */
 +        enum AVMediaType type;
 +
 +        switch (*spec++) {
 +        case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
 +        case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
 +        case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
 +        case 'd': type = AVMEDIA_TYPE_DATA;       break;
 +        case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
 +        default:  av_assert0(0);
 +        }
 +        if (type != st->codec->codec_type)
 +            return 0;
 +        if (*spec++ == ':') { /* possibly followed by :index */
 +            int i, index = strtol(spec, NULL, 0);
 +            for (i = 0; i < s->nb_streams; i++)
 +                if (s->streams[i]->codec->codec_type == type && index-- == 0)
 +                   return i == st->index;
 +            return 0;
 +        }
 +        return 1;
 +    } else if (*spec == 'p' && *(spec + 1) == ':') {
 +        int prog_id, i, j;
 +        char *endptr;
 +        spec += 2;
 +        prog_id = strtol(spec, &endptr, 0);
 +        for (i = 0; i < s->nb_programs; i++) {
 +            if (s->programs[i]->id != prog_id)
 +                continue;
 +
 +            if (*endptr++ == ':') {
 +                int stream_idx = strtol(endptr, NULL, 0);
 +                return stream_idx >= 0 &&
 +                    stream_idx < s->programs[i]->nb_stream_indexes &&
 +                    st->index == s->programs[i]->stream_index[stream_idx];
 +            }
 +
 +            for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
 +                if (st->index == s->programs[i]->stream_index[j])
 +                    return 1;
 +        }
 +        return 0;
 +    } else if (*spec == '#') {
 +        int sid;
 +        char *endptr;
 +        sid = strtol(spec + 1, &endptr, 0);
 +        if (!*endptr)
 +            return st->id == sid;
 +    } else if (!*spec) /* empty specifier, matches everything */
 +        return 1;
 +
 +    av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
 +    return AVERROR(EINVAL);
 +}