PeerStreamer

/*

 * various utility functions for use within FFmpeg

 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard

 *

 * 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

 */

/* #define DEBUG */

#include "avformat.h"

#include "avio_internal.h"

#include "internal.h"

#include "libavcodec/internal.h"

#include "libavutil/opt.h"

#include "metadata.h"

#include "id3v2.h"

#include "libavutil/avstring.h"

#include "riff.h"

#include "audiointerleave.h"

#include <sys/time.h>

#include <time.h>

#include <strings.h>

#include <stdarg.h>

#if CONFIG_NETWORK

#include "network.h"

#endif

#undef NDEBUG

#include <assert.h>

/**

 * @file

 * various utility functions for use within FFmpeg

 */

unsigned avformat_version(void)

{

    return LIBAVFORMAT_VERSION_INT;

}

const char *avformat_configuration(void)

{

    return FFMPEG_CONFIGURATION;

}

const char *avformat_license(void)

{

#define LICENSE_PREFIX "libavformat license: "

    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;

}

/* fraction handling */

/**

 * f = val + (num / den) + 0.5.

 *

 * 'num' is normalized so that it is such as 0 <= num < den.

 *

 * @param f fractional number

 * @param val integer value

 * @param num must be >= 0

 * @param den must be >= 1

 */

static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)

{

    num += (den >> 1);

    if (num >= den) {

        val += num / den;

        num = num % den;

    }

    f->val = val;

    f->num = num;

    f->den = den;

}

/**

 * Fractional addition to f: f = f + (incr / f->den).

 *

 * @param f fractional number

 * @param incr increment, can be positive or negative

 */

static void av_frac_add(AVFrac *f, int64_t incr)

{

    int64_t num, den;

    num = f->num + incr;

    den = f->den;

    if (num < 0) {

        f->val += num / den;

        num = num % den;

        if (num < 0) {

            num += den;

            f->val--;

        }

    } else if (num >= den) {

        f->val += num / den;

        num = num % den;

    }

    f->num = num;

}

/** head of registered input format linked list */

#if !FF_API_FIRST_FORMAT

static

#endif

AVInputFormat *first_iformat = NULL;

/** head of registered output format linked list */

#if !FF_API_FIRST_FORMAT

static

#endif

AVOutputFormat *first_oformat = NULL;

AVInputFormat  *av_iformat_next(AVInputFormat  *f)

{

    if(f) return f->next;

    else  return first_iformat;

}

AVOutputFormat *av_oformat_next(AVOutputFormat *f)

{

    if(f) return f->next;

    else  return first_oformat;

}

void av_register_input_format(AVInputFormat *format)

{

    AVInputFormat **p;

    p = &first_iformat;

    while (*p != NULL) p = &(*p)->next;

    *p = format;

    format->next = NULL;

}

void av_register_output_format(AVOutputFormat *format)

{

    AVOutputFormat **p;

    p = &first_oformat;

    while (*p != NULL) p = &(*p)->next;

    *p = format;

    format->next = NULL;

}

int av_match_ext(const char *filename, const char *extensions)

{

    const char *ext, *p;

    char ext1[32], *q;

    if(!filename)

        return 0;

    ext = strrchr(filename, '.');

    if (ext) {

        ext++;

        p = extensions;

        for(;;) {

            q = ext1;

            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)

                *q++ = *p++;

            *q = '\0';

            if (!strcasecmp(ext1, ext))

                return 1;

            if (*p == '\0')

                break;

            p++;

        }

    }

    return 0;

}

static int match_format(const char *name, const char *names)

{

    const char *p;

    int len, namelen;

    if (!name || !names)

        return 0;

    namelen = strlen(name);

    while ((p = strchr(names, ','))) {

        len = FFMAX(p - names, namelen);

        if (!strncasecmp(name, names, len))

            return 1;

        names = p+1;

    }

    return !strcasecmp(name, names);

}

#if FF_API_GUESS_FORMAT

AVOutputFormat *guess_format(const char *short_name, const char *filename,

                             const char *mime_type)

{

    return av_guess_format(short_name, filename, mime_type);

}

#endif

AVOutputFormat *av_guess_format(const char *short_name, const char *filename,

                                const char *mime_type)

{

    AVOutputFormat *fmt = NULL, *fmt_found;

    int score_max, score;

    /* specific test for image sequences */

#if CONFIG_IMAGE2_MUXER

    if (!short_name && filename &&

        av_filename_number_test(filename) &&

        av_guess_image2_codec(filename) != CODEC_ID_NONE) {

        return av_guess_format("image2", NULL, NULL);

    }

#endif

    /* Find the proper file type. */

    fmt_found = NULL;

    score_max = 0;

    while ((fmt = av_oformat_next(fmt))) {

        score = 0;

        if (fmt->name && short_name && !strcmp(fmt->name, short_name))

            score += 100;

        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))

            score += 10;

        if (filename && fmt->extensions &&

            av_match_ext(filename, fmt->extensions)) {

            score += 5;

        }

        if (score > score_max) {

            score_max = score;

            fmt_found = fmt;

        }

    }

    return fmt_found;

}

#if FF_API_GUESS_FORMAT

AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,

                             const char *mime_type)

{

    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);

    if (fmt) {

        AVOutputFormat *stream_fmt;

        char stream_format_name[64];

        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);

        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);

        if (stream_fmt)

            fmt = stream_fmt;

    }

    return fmt;

}

#endif

enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,

                            const char *filename, const char *mime_type, enum AVMediaType type){

    if(type == AVMEDIA_TYPE_VIDEO){

        enum CodecID codec_id= CODEC_ID_NONE;

#if CONFIG_IMAGE2_MUXER

        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){

            codec_id= av_guess_image2_codec(filename);

        }

#endif

        if(codec_id == CODEC_ID_NONE)

            codec_id= fmt->video_codec;

        return codec_id;

    }else if(type == AVMEDIA_TYPE_AUDIO)

        return fmt->audio_codec;

    else if (type == AVMEDIA_TYPE_SUBTITLE)

        return fmt->subtitle_codec;

    else

        return CODEC_ID_NONE;

}

AVInputFormat *av_find_input_format(const char *short_name)

{

    AVInputFormat *fmt = NULL;

    while ((fmt = av_iformat_next(fmt))) {

        if (match_format(short_name, fmt->name))

            return fmt;

    }

    return NULL;

}

#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER

FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")

{

    av_destruct_packet_nofree(pkt);

}

FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")

{

    av_destruct_packet(pkt);

}

FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")

{

    return av_new_packet(pkt, size);

}

FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")

{

    return av_dup_packet(pkt);

}

FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")

{

    av_free_packet(pkt);

}

FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")

{

    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");

    av_init_packet(pkt);

}

#endif

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

{

    int ret= av_new_packet(pkt, size);

    if(ret<0)

        return ret;

    pkt->pos= avio_tell(s);

    ret= avio_read(s, pkt->data, size);

    if(ret<=0)

        av_free_packet(pkt);

    else

        av_shrink_packet(pkt, ret);

    return ret;

}

int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)

{

    int ret;

    int old_size;

    if (!pkt->size)

        return av_get_packet(s, pkt, size);

    old_size = pkt->size;

    ret = av_grow_packet(pkt, size);

    if (ret < 0)

        return ret;

    ret = avio_read(s, pkt->data + old_size, size);

    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));

    return ret;

}

int av_filename_number_test(const char *filename)

{

    char buf[1024];

    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);

}

AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)

{

    AVProbeData lpd = *pd;

    AVInputFormat *fmt1 = NULL, *fmt;

    int score, 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;

        }

    }

    fmt = NULL;

    while ((fmt1 = av_iformat_next(fmt1))) {

        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))

            continue;

        score = 0;

        if (fmt1->read_probe) {

            score = fmt1->read_probe(&lpd);

        } else if (fmt1->extensions) {

            if (av_match_ext(lpd.filename, fmt1->extensions)) {

                score = 50;

            }

        }

        if (score > score_max) {

            score_max = score;

            fmt = fmt1;

        }else if (score == score_max)

            fmt = NULL;

    }

    *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)

{

    static const struct {

        const char *name; enum CodecID id; enum AVMediaType type;

    } fmt_id_type[] = {

        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },

        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },

        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },

        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },

        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },

        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },

        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },

        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },

        { 0 }

    };

    int score;

    AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);

    if (fmt) {

        int i;

        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",

               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);

        for (i = 0; fmt_id_type[i].name; i++) {

            if (!strcmp(fmt->name, fmt_id_type[i].name)) {

                st->codec->codec_id   = fmt_id_type[i].id;

                st->codec->codec_type = fmt_id_type[i].type;

                break;

            }

        }

    }

    return score;

}

/************************************************************/

/* input media file */

/**

 * Open a media file from an IO stream. 'fmt' must be specified.

 */

int av_open_input_stream(AVFormatContext **ic_ptr,

                         AVIOContext *pb, const char *filename,

                         AVInputFormat *fmt, AVFormatParameters *ap)

{

    int err;

    AVFormatContext *ic;

    AVFormatParameters default_ap;

    if(!ap){

        ap=&default_ap;

        memset(ap, 0, sizeof(default_ap));

    }

    if(!ap->prealloced_context)

        ic = avformat_alloc_context();

    else

        ic = *ic_ptr;

    if (!ic) {

        err = AVERROR(ENOMEM);

        goto fail;

    }

    ic->iformat = fmt;

    ic->pb = pb;

    ic->duration = AV_NOPTS_VALUE;

    ic->start_time = AV_NOPTS_VALUE;

    av_strlcpy(ic->filename, filename, sizeof(ic->filename));

    /* allocate private data */

    if (fmt->priv_data_size > 0) {

        ic->priv_data = av_mallocz(fmt->priv_data_size);

        if (!ic->priv_data) {

            err = AVERROR(ENOMEM);

            goto fail;

        }

    } else {

        ic->priv_data = NULL;

    }

    // e.g. AVFMT_NOFILE formats will not have a AVIOContext

    if (ic->pb)

        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);

    if (ic->iformat->read_header) {

        err = ic->iformat->read_header(ic, ap);

        if (err < 0)

            goto fail;

    }

    if (pb && !ic->data_offset)

        ic->data_offset = avio_tell(ic->pb);

#if FF_API_OLD_METADATA

    ff_metadata_demux_compat(ic);

#endif

    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

    *ic_ptr = ic;

    return 0;

 fail:

    if (ic) {

        int i;

        av_freep(&ic->priv_data);

        for(i=0;i<ic->nb_streams;i++) {

            AVStream *st = ic->streams[i];

            if (st) {

                av_free(st->priv_data);

                av_free(st->codec->extradata);

                av_free(st->codec);

                av_free(st->info);

            }

            av_free(st);

        }

    }

    av_free(ic);

    *ic_ptr = NULL;

    return err;

}

/** size of probe buffer, for guessing file type from file contents */

#define PROBE_BUF_MIN 2048

#define PROBE_BUF_MAX (1<<20)

int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,

                          const char *filename, void *logctx,

                          unsigned int offset, unsigned int max_probe_size)

{

    AVProbeData pd = { filename ? filename : "", NULL, -offset };

    unsigned char *buf = NULL;

    int ret = 0, probe_size;

    if (!max_probe_size) {

        max_probe_size = PROBE_BUF_MAX;

    } else if (max_probe_size > PROBE_BUF_MAX) {

        max_probe_size = PROBE_BUF_MAX;

    } else if (max_probe_size < PROBE_BUF_MIN) {

        return AVERROR(EINVAL);

    }

    if (offset >= max_probe_size) {

        return AVERROR(EINVAL);

    }

    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;

        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {

        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;

        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;

        if (probe_size < offset) {

            continue;

        }

        /* read probe data */

        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);

        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) {

                av_free(buf);

                return ret;

            }

            score = 0;

            ret = 0;            /* error was end of file, nothing read */

        }

        pd.buf_size += ret;

        pd.buf = &buf[offset];

        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);

        /* guess file format */

        *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);

            }else

                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);

        }

    }

    if (!*fmt) {

        av_free(buf);

        return AVERROR_INVALIDDATA;

    }

    /* rewind. reuse probe buffer to avoid seeking */

    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)

        av_free(buf);

    return ret;

}

int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,

                       AVInputFormat *fmt,

                       int buf_size,

                       AVFormatParameters *ap)

{

    int err;

    AVProbeData probe_data, *pd = &probe_data;

    AVIOContext *pb = NULL;

    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;

    pd->filename = "";

    if (filename)

        pd->filename = filename;

    pd->buf = NULL;

    pd->buf_size = 0;

    if (!fmt) {

        /* guess format if no file can be opened */

        fmt = av_probe_input_format(pd, 0);

    }

    /* Do not open file if the format does not need it. XXX: specific

       hack needed to handle RTSP/TCP */

    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {

        /* if no file needed do not try to open one */

        if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {

            goto fail;

        }

        if (buf_size > 0) {

            ffio_set_buf_size(pb, buf_size);

        }

        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {

            goto fail;

        }

    }

    /* if still no format found, error */

    if (!fmt) {

        err = AVERROR_INVALIDDATA;

        goto fail;

    }

    /* check filename in case an image number is expected */

    if (fmt->flags & AVFMT_NEEDNUMBER) {

        if (!av_filename_number_test(filename)) {

            err = AVERROR_NUMEXPECTED;

            goto fail;

        }

    }

    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);

    if (err)

        goto fail;

    return 0;

 fail:

    av_freep(&pd->buf);

    if (pb)

        avio_close(pb);

    if (ap && ap->prealloced_context)

        av_free(*ic_ptr);

    *ic_ptr = NULL;

    return err;

}

/*******************************************************/

static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,

                               AVPacketList **plast_pktl){

    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));

    if (!pktl)

        return NULL;

    if (*packet_buffer)

        (*plast_pktl)->next = pktl;

    else

        *packet_buffer = pktl;

    /* add the packet in the buffered packet list */

    *plast_pktl = pktl;

    pktl->pkt= *pkt;

    return &pktl->pkt;

}

int av_read_packet(AVFormatContext *s, AVPacket *pkt)

{

    int ret, i;

    AVStream *st;

    for(;;){

        AVPacketList *pktl = s->raw_packet_buffer;

        if (pktl) {

            *pkt = pktl->pkt;

            if(s->streams[pkt->stream_index]->request_probe <= 0){

                s->raw_packet_buffer = pktl->next;

                s->raw_packet_buffer_remaining_size += pkt->size;

                av_free(pktl);

                return 0;

            }

        }

        av_init_packet(pkt);

        ret= s->iformat->read_packet(s, pkt);

        if (ret < 0) {

            if (!pktl || ret == AVERROR(EAGAIN))

                return ret;

            for (i = 0; i < s->nb_streams; i++)

                if(s->streams[i]->request_probe > 0)

                    s->streams[i]->request_probe = -1;

            continue;

        }

        st= s->streams[pkt->stream_index];

        switch(st->codec->codec_type){

        case AVMEDIA_TYPE_VIDEO:

            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;

            break;

        case AVMEDIA_TYPE_AUDIO:

            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;

            break;

        case AVMEDIA_TYPE_SUBTITLE:

            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;

            break;

        }

        if(!pktl && st->request_probe <= 0)

            return ret;

        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);

        s->raw_packet_buffer_remaining_size -= pkt->size;

        if(st->request_probe>0){

            AVProbeData *pd = &st->probe_data;

            int end;

            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);

            --st->probe_packets;

            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);

            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);

            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 != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)

                    || end){

                    pd->buf_size=0;

                    av_freep(&pd->buf);

                    st->request_probe= -1;

                    if(st->codec->codec_id != 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);

                }

            }

        }

    }

}

/**********************************************************/

/**

 * Get the number of samples of an audio frame. Return -1 on error.

 */

static int get_audio_frame_size(AVCodecContext *enc, int size)

{

    int frame_size;

    if(enc->codec_id == CODEC_ID_VORBIS)

        return -1;

    if (enc->frame_size <= 1) {

        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);

        if (bits_per_sample) {

            if (enc->channels == 0)

                return -1;

            frame_size = (size << 3) / (bits_per_sample * enc->channels);

        } else {

            /* used for example by ADPCM codecs */

            if (enc->bit_rate == 0)

                return -1;

            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;

        }

    } else {

        frame_size = enc->frame_size;

    }

    return frame_size;

}

/**

 * Return the frame duration in seconds. Return 0 if not available.

 */

static void compute_frame_duration(int *pnum, int *pden, AVStream *st,

                                   AVCodecParserContext *pc, AVPacket *pkt)

{

    int frame_size;

    *pnum = 0;

    *pden = 0;

    switch(st->codec->codec_type) {

    case AVMEDIA_TYPE_VIDEO:

        if(st->time_base.num*1000LL > st->time_base.den){

            *pnum = st->time_base.num;

            *pden = st->time_base.den;

        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){

            *pnum = st->codec->time_base.num;

            *pden = st->codec->time_base.den;

            if (pc && pc->repeat_pict) {

                *pnum = (*pnum) * (1 + pc->repeat_pict);

            }

            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet

            //Thus if we have no parser in such case leave duration undefined.

            if(st->codec->ticks_per_frame>1 && !pc){

                *pnum = *pden = 0;

            }

        }

        break;

    case AVMEDIA_TYPE_AUDIO:

        frame_size = get_audio_frame_size(st->codec, pkt->size);

        if (frame_size <= 0 || st->codec->sample_rate <= 0)

            break;

        *pnum = frame_size;

        *pden = st->codec->sample_rate;

        break;

    default:

        break;

    }

}

static int is_intra_only(AVCodecContext *enc){

    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){

        return 1;

    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){

        switch(enc->codec_id){

        case CODEC_ID_MJPEG:

        case CODEC_ID_MJPEGB:

        case CODEC_ID_LJPEG:

        case CODEC_ID_RAWVIDEO:

        case CODEC_ID_DVVIDEO:

        case CODEC_ID_HUFFYUV:

        case CODEC_ID_FFVHUFF:

        case CODEC_ID_ASV1:

        case CODEC_ID_ASV2:

        case CODEC_ID_VCR1:

        case CODEC_ID_DNXHD:

        case CODEC_ID_JPEG2000:

            return 1;

        default: break;

        }

    }

    return 0;

}

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;

    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)

        return;

    st->first_dts= dts - st->cur_dts;

    st->cur_dts= dts;

    for(; pktl; pktl= pktl->next){

        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(pktl->pkt.dts != AV_NOPTS_VALUE)

            pktl->pkt.dts += st->first_dts;

        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)

            st->start_time= pktl->pkt.pts;

    }

    if (st->start_time == AV_NOPTS_VALUE)

        st->start_time = pts;

}

static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)

{

    AVPacketList *pktl= s->packet_buffer;

    int64_t cur_dts= 0;

    if(st->first_dts != AV_NOPTS_VALUE){

        cur_dts= st->first_dts;

        for(; pktl; pktl= pktl->next){

            if(pktl->pkt.stream_index == pkt->stream_index){

                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)

                    break;

                cur_dts -= pkt->duration;

            }

        }

        pktl= s->packet_buffer;

        st->first_dts = cur_dts;

    }else if(st->cur_dts)

        return;

    for(; pktl; pktl= pktl->next){

        if(pktl->pkt.stream_index != pkt->stream_index)

            continue;

        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE

           && !pktl->pkt.duration){

            pktl->pkt.dts= cur_dts;

            if(!st->codec->has_b_frames)

                pktl->pkt.pts= cur_dts;

            cur_dts += pkt->duration;

            pktl->pkt.duration= pkt->duration;

        }else

            break;

    }

    if(st->first_dts == AV_NOPTS_VALUE)

        st->cur_dts= cur_dts;

}

static void compute_pkt_fields(AVFormatContext *s, AVStream *st,

                               AVCodecParserContext *pc, AVPacket *pkt)

{

    int num, den, presentation_delayed, delay, i;

    int64_t offset;

    if (s->flags & AVFMT_FLAG_NOFILLIN)

        return;

    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)

        pkt->dts= AV_NOPTS_VALUE;

    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)

        //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;

    // ignore delay caused by frame threading so that the mpeg2-without-dts

    // warning will not trigger

    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)

        delay -= st->codec->thread_count-1;