[libav.git] / libavformat / ffmdec.c

/*
 * FFM (ffserver live feed) demuxer
 * Copyright (c) 2001 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
 */

#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "ffm.h"
#if CONFIG_FFSERVER
#include <unistd.h>

int64_t ffm_read_write_index(int fd)
{
    uint8_t buf[8];

    lseek(fd, 8, SEEK_SET);
    if (read(fd, buf, 8) != 8)
        return AVERROR(EIO);
    return AV_RB64(buf);
}

int ffm_write_write_index(int fd, int64_t pos)
{
    uint8_t buf[8];
    int i;

    for(i=0;i<8;i++)
        buf[i] = (pos >> (56 - i * 8)) & 0xff;
    lseek(fd, 8, SEEK_SET);
    if (write(fd, buf, 8) != 8)
        return AVERROR(EIO);
    return 8;
}

void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size)
{
    FFMContext *ffm = s->priv_data;
    ffm->write_index = pos;
    ffm->file_size = file_size;
}
#endif // CONFIG_FFSERVER

static int ffm_is_avail_data(AVFormatContext *s, int size)
{
    FFMContext *ffm = s->priv_data;
    int64_t pos, avail_size;
    int len;

    len = ffm->packet_end - ffm->packet_ptr;
    if (size <= len)
        return 1;
    pos = url_ftell(s->pb);
    if (!ffm->write_index) {
        if (pos == ffm->file_size)
            return AVERROR_EOF;
        avail_size = ffm->file_size - pos;
    } else {
    if (pos == ffm->write_index) {
        /* exactly at the end of stream */
        return AVERROR(EAGAIN);
    } else if (pos < ffm->write_index) {
        avail_size = ffm->write_index - pos;
    } else {
        avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);
    }
    }
    avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;
    if (size <= avail_size)
        return 1;
    else
        return AVERROR(EAGAIN);
}

static int ffm_resync(AVFormatContext *s, int state)
{
    av_log(s, AV_LOG_ERROR, "resyncing\n");
    while (state != PACKET_ID) {
        if (url_feof(s->pb)) {
            av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");
            return -1;
        }
        state = (state << 8) | get_byte(s->pb);
    }
    return 0;
}

/* first is true if we read the frame header */
static int ffm_read_data(AVFormatContext *s,
                         uint8_t *buf, int size, int header)
{
    FFMContext *ffm = s->priv_data;
    ByteIOContext *pb = s->pb;
    int len, fill_size, size1, frame_offset, id;

    size1 = size;
    while (size > 0) {
    redo:
        len = ffm->packet_end - ffm->packet_ptr;
        if (len < 0)
            return -1;
        if (len > size)
            len = size;
        if (len == 0) {
            if (url_ftell(pb) == ffm->file_size)
                url_fseek(pb, ffm->packet_size, SEEK_SET);
    retry_read:
            id = get_be16(pb); /* PACKET_ID */
            if (id != PACKET_ID)
                if (ffm_resync(s, id) < 0)
                    return -1;
            fill_size = get_be16(pb);
            ffm->dts = get_be64(pb);
            frame_offset = get_be16(pb);
            get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
            ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
            if (ffm->packet_end < ffm->packet || frame_offset < 0)
                return -1;
            /* if first packet or resynchronization packet, we must
               handle it specifically */
            if (ffm->first_packet || (frame_offset & 0x8000)) {
                if (!frame_offset) {
                    /* This packet has no frame headers in it */
                    if (url_ftell(pb) >= ffm->packet_size * 3) {
                        url_fseek(pb, -ffm->packet_size * 2, SEEK_CUR);
                        goto retry_read;
                    }
                    /* This is bad, we cannot find a valid frame header */
                    return 0;
                }
                ffm->first_packet = 0;
                if ((frame_offset & 0x7fff) < FFM_HEADER_SIZE)
                    return -1;
                ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;
                if (!header)
                    break;
            } else {
                ffm->packet_ptr = ffm->packet;
            }
            goto redo;
        }
        memcpy(buf, ffm->packet_ptr, len);
        buf += len;
        ffm->packet_ptr += len;
        size -= len;
        header = 0;
    }
    return size1 - size;
}

//#define DEBUG_SEEK

/* ensure that acutal seeking happens between FFM_PACKET_SIZE
   and file_size - FFM_PACKET_SIZE */
static void ffm_seek1(AVFormatContext *s, int64_t pos1)
{
    FFMContext *ffm = s->priv_data;
    ByteIOContext *pb = s->pb;
    int64_t pos;

    pos = FFMIN(pos1, ffm->file_size - FFM_PACKET_SIZE);
    pos = FFMAX(pos, FFM_PACKET_SIZE);
#ifdef DEBUG_SEEK
    av_log(s, AV_LOG_DEBUG, "seek to %"PRIx64" -> %"PRIx64"\n", pos1, pos);
#endif
    url_fseek(pb, pos, SEEK_SET);
}

static int64_t get_dts(AVFormatContext *s, int64_t pos)
{
    ByteIOContext *pb = s->pb;
    int64_t dts;

    ffm_seek1(s, pos);
    url_fskip(pb, 4);
    dts = get_be64(pb);
#ifdef DEBUG_SEEK
    av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0);
#endif
    return dts;
}

static void adjust_write_index(AVFormatContext *s)
{
    FFMContext *ffm = s->priv_data;
    ByteIOContext *pb = s->pb;
    int64_t pts;
    //int64_t orig_write_index = ffm->write_index;
    int64_t pos_min, pos_max;
    int64_t pts_start;
    int64_t ptr = url_ftell(pb);


    pos_min = 0;
    pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;

    pts_start = get_dts(s, pos_min);

    pts = get_dts(s, pos_max);

    if (pts - 100000 > pts_start)
        goto end;

    ffm->write_index = FFM_PACKET_SIZE;

    pts_start = get_dts(s, pos_min);

    pts = get_dts(s, pos_max);

    if (pts - 100000 <= pts_start) {
        while (1) {
            int64_t newpos;
            int64_t newpts;

            newpos = ((pos_max + pos_min) / (2 * FFM_PACKET_SIZE)) * FFM_PACKET_SIZE;

            if (newpos == pos_min)
                break;

            newpts = get_dts(s, newpos);

            if (newpts - 100000 <= pts) {
                pos_max = newpos;
                pts = newpts;
            } else {
                pos_min = newpos;
            }
        }
        ffm->write_index += pos_max;
    }

    //printf("Adjusted write index from %"PRId64" to %"PRId64": pts=%0.6f\n", orig_write_index, ffm->write_index, pts / 1000000.);
    //printf("pts range %0.6f - %0.6f\n", get_dts(s, 0) / 1000000. , get_dts(s, ffm->file_size - 2 * FFM_PACKET_SIZE) / 1000000. );

 end:
    url_fseek(pb, ptr, SEEK_SET);
}


static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
    FFMContext *ffm = s->priv_data;
    AVStream *st;
    ByteIOContext *pb = s->pb;
    AVCodecContext *codec;
    int i, nb_streams;
    uint32_t tag;

    /* header */
    tag = get_le32(pb);
    if (tag != MKTAG('F', 'F', 'M', '1'))
        goto fail;
    ffm->packet_size = get_be32(pb);
    if (ffm->packet_size != FFM_PACKET_SIZE)
        goto fail;
    ffm->write_index = get_be64(pb);
    /* get also filesize */
    if (!url_is_streamed(pb)) {
        ffm->file_size = url_fsize(pb);
        if (ffm->write_index)
            adjust_write_index(s);
    } else {
        ffm->file_size = (UINT64_C(1) << 63) - 1;
    }

    nb_streams = get_be32(pb);
    get_be32(pb); /* total bitrate */
    /* read each stream */
    for(i=0;i<nb_streams;i++) {
        char rc_eq_buf[128];

        st = av_new_stream(s, 0);
        if (!st)
            goto fail;

        av_set_pts_info(st, 64, 1, 1000000);

        codec = st->codec;
        /* generic info */
        codec->codec_id = get_be32(pb);
        codec->codec_type = get_byte(pb); /* codec_type */
        codec->bit_rate = get_be32(pb);
        st->quality = get_be32(pb);
        codec->flags = get_be32(pb);
        codec->flags2 = get_be32(pb);
        codec->debug = get_be32(pb);
        /* specific info */
        switch(codec->codec_type) {
        case CODEC_TYPE_VIDEO:
            codec->time_base.num = get_be32(pb);
            codec->time_base.den = get_be32(pb);
            codec->width = get_be16(pb);
            codec->height = get_be16(pb);
            codec->gop_size = get_be16(pb);
            codec->pix_fmt = get_be32(pb);
            codec->qmin = get_byte(pb);
            codec->qmax = get_byte(pb);
            codec->max_qdiff = get_byte(pb);
            codec->qcompress = get_be16(pb) / 10000.0;
            codec->qblur = get_be16(pb) / 10000.0;
            codec->bit_rate_tolerance = get_be32(pb);
            codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));
            codec->rc_max_rate = get_be32(pb);
            codec->rc_min_rate = get_be32(pb);
            codec->rc_buffer_size = get_be32(pb);
            codec->i_quant_factor = av_int2dbl(get_be64(pb));
            codec->b_quant_factor = av_int2dbl(get_be64(pb));
            codec->i_quant_offset = av_int2dbl(get_be64(pb));
            codec->b_quant_offset = av_int2dbl(get_be64(pb));
            codec->dct_algo = get_be32(pb);
            codec->strict_std_compliance = get_be32(pb);
            codec->max_b_frames = get_be32(pb);
            codec->luma_elim_threshold = get_be32(pb);
            codec->chroma_elim_threshold = get_be32(pb);
            codec->mpeg_quant = get_be32(pb);
            codec->intra_dc_precision = get_be32(pb);
            codec->me_method = get_be32(pb);
            codec->mb_decision = get_be32(pb);
            codec->nsse_weight = get_be32(pb);
            codec->frame_skip_cmp = get_be32(pb);
            codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb));
            codec->codec_tag = get_be32(pb);
            codec->thread_count = get_byte(pb);
            codec->coder_type = get_be32(pb);
            codec->me_cmp = get_be32(pb);
            codec->partitions = get_be32(pb);
            codec->me_subpel_quality = get_be32(pb);
            codec->me_range = get_be32(pb);
            codec->keyint_min = get_be32(pb);
            codec->scenechange_threshold = get_be32(pb);
            codec->b_frame_strategy = get_be32(pb);
            codec->qcompress = av_int2dbl(get_be64(pb));
            codec->qblur = av_int2dbl(get_be64(pb));
            codec->max_qdiff = get_be32(pb);
            codec->refs = get_be32(pb);
            codec->directpred = get_be32(pb);
            break;
        case CODEC_TYPE_AUDIO:
            codec->sample_rate = get_be32(pb);
            codec->channels = get_le16(pb);
            codec->frame_size = get_le16(pb);
            codec->sample_fmt = get_le16(pb);
            break;
        default:
            goto fail;
        }
        if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
            codec->extradata_size = get_be32(pb);
            codec->extradata = av_malloc(codec->extradata_size);
            if (!codec->extradata)
                return AVERROR(ENOMEM);
            get_buffer(pb, codec->extradata, codec->extradata_size);
        }
    }

    /* get until end of block reached */
    while ((url_ftell(pb) % ffm->packet_size) != 0)
        get_byte(pb);

    /* init packet demux */
    ffm->packet_ptr = ffm->packet;
    ffm->packet_end = ffm->packet;
    ffm->frame_offset = 0;
    ffm->dts = 0;
    ffm->read_state = READ_HEADER;
    ffm->first_packet = 1;
    return 0;
 fail:
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
        if (st) {
            av_free(st);
        }
    }
    return -1;
}

/* return < 0 if eof */
static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    int size;
    FFMContext *ffm = s->priv_data;
    int duration, ret;

    switch(ffm->read_state) {
    case READ_HEADER:
        if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
            return ret;

        dprintf(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
               url_ftell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);
        if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
            FRAME_HEADER_SIZE)
            return -1;
        if (ffm->header[1] & FLAG_DTS)
            if (ffm_read_data(s, ffm->header+16, 4, 1) != 4)
                return -1;
#if 0
        av_hexdump_log(s, AV_LOG_DEBUG, ffm->header, FRAME_HEADER_SIZE);
#endif
        ffm->read_state = READ_DATA;
        /* fall thru */
    case READ_DATA:
        size = AV_RB24(ffm->header + 2);
        if ((ret = ffm_is_avail_data(s, size)) < 0)
            return ret;

        duration = AV_RB24(ffm->header + 5);

        av_new_packet(pkt, size);
        pkt->stream_index = ffm->header[0];
        if ((unsigned)pkt->stream_index >= s->nb_streams) {
            av_log(s, AV_LOG_ERROR, "invalid stream index %d\n", pkt->stream_index);
            av_free_packet(pkt);
            ffm->read_state = READ_HEADER;
            return -1;
        }
        pkt->pos = url_ftell(s->pb);
        if (ffm->header[1] & FLAG_KEY_FRAME)
            pkt->flags |= PKT_FLAG_KEY;

        ffm->read_state = READ_HEADER;
        if (ffm_read_data(s, pkt->data, size, 0) != size) {
            /* bad case: desynchronized packet. we cancel all the packet loading */
            av_free_packet(pkt);
            return -1;
        }
        pkt->pts = AV_RB64(ffm->header+8);
        if (ffm->header[1] & FLAG_DTS)
            pkt->dts = pkt->pts - AV_RB32(ffm->header+16);
        else
            pkt->dts = pkt->pts;
        pkt->duration = duration;
        break;
    }
    return 0;
}

/* seek to a given time in the file. The file read pointer is
   positioned at or before pts. XXX: the following code is quite
   approximative */
static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags)
{
    FFMContext *ffm = s->priv_data;
    int64_t pos_min, pos_max, pos;
    int64_t pts_min, pts_max, pts;
    double pos1;

#ifdef DEBUG_SEEK
    av_log(s, AV_LOG_DEBUG, "wanted_pts=%0.6f\n", wanted_pts / 1000000.0);
#endif
    /* find the position using linear interpolation (better than
       dichotomy in typical cases) */
    pos_min = FFM_PACKET_SIZE;
    pos_max = ffm->file_size - FFM_PACKET_SIZE;
    while (pos_min <= pos_max) {
        pts_min = get_dts(s, pos_min);
        pts_max = get_dts(s, pos_max);
        /* linear interpolation */
        pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /
            (double)(pts_max - pts_min);
        pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
        if (pos <= pos_min)
            pos = pos_min;
        else if (pos >= pos_max)
            pos = pos_max;
        pts = get_dts(s, pos);
        /* check if we are lucky */
        if (pts == wanted_pts) {
            goto found;
        } else if (pts > wanted_pts) {
            pos_max = pos - FFM_PACKET_SIZE;
        } else {
            pos_min = pos + FFM_PACKET_SIZE;
        }
    }
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;

 found:
    ffm_seek1(s, pos);

    /* reset read state */
    ffm->read_state = READ_HEADER;
    ffm->packet_ptr = ffm->packet;
    ffm->packet_end = ffm->packet;
    ffm->first_packet = 1;

    return 0;
}

static int ffm_probe(AVProbeData *p)
{
    if (
        p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&
        p->buf[3] == '1')
        return AVPROBE_SCORE_MAX + 1;
    return 0;
}

static int ffm_close(AVFormatContext *s)
{
    int i;

    for (i = 0; i < s->nb_streams; i++)
        av_freep(&s->streams[i]->codec->rc_eq);

    return 0;
}

AVInputFormat ffm_demuxer = {
    "ffm",
    NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
    sizeof(FFMContext),
    ffm_probe,
    ffm_read_header,
    ffm_read_packet,
    ffm_close,
    ffm_seek,
};
Commit	Line	Data
de6d9b64	1	/*
85a6b01d	2	* FFM (ffserver live feed) demuxer
406792e7	3	* Copyright (c) 2001 Fabrice Bellard
de6d9b64	4	*
b78e7197 DB	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
66d2ff2a FB	8	* modify it under the terms of the GNU Lesser General Public
66d2ff2a FB	9	* License as published by the Free Software Foundation; either
b78e7197	10	* version 2.1 of the License, or (at your option) any later version.
de6d9b64	11	*
b78e7197	12	* FFmpeg is distributed in the hope that it will be useful,
de6d9b64	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
66d2ff2a FB	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
66d2ff2a FB	15	* Lesser General Public License for more details.
de6d9b64	16	*
66d2ff2a	17	* You should have received a copy of the GNU Lesser General Public
b78e7197	18	* License along with FFmpeg; if not, write to the Free Software
5509bffa	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64	20	*/
85a6b01d	21
6a5d31ac	22	#include "libavutil/intreadwrite.h"
de6d9b64	23	#include "avformat.h"
85a6b01d	24	#include "ffm.h"
b250f9c6	25	#if CONFIG_FFSERVER
8be1c656	26	#include <unistd.h>
de6d9b64	27
bc5c918e	28	int64_t ffm_read_write_index(int fd)
278f987a BC	29	{
	30	uint8_t buf[8];
	31
	32	lseek(fd, 8, SEEK_SET);
2dc91884 BC	33	if (read(fd, buf, 8) != 8)
2dc91884 BC	34	return AVERROR(EIO);
278f987a BC	35	return AV_RB64(buf);
	36	}
	37
6fcce4f9	38	int ffm_write_write_index(int fd, int64_t pos)
278f987a BC	39	{
	40	uint8_t buf[8];
	41	int i;
	42
	43	for(i=0;i<8;i++)
	44	buf[i] = (pos >> (56 - i * 8)) & 0xff;
	45	lseek(fd, 8, SEEK_SET);
6fcce4f9 PK	46	if (write(fd, buf, 8) != 8)
	47	return AVERROR(EIO);
	48	return 8;
278f987a BC	49	}
278f987a BC	50
bc5c918e	51	void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size)
278f987a BC	52	{
	53	FFMContext *ffm = s->priv_data;
	54	ffm->write_index = pos;
	55	ffm->file_size = file_size;
	56	}
	57	#endif // CONFIG_FFSERVER
	58
de6d9b64 FB	59	static int ffm_is_avail_data(AVFormatContext *s, int size)
	60	{
	61	FFMContext *ffm = s->priv_data;
bc5c918e	62	int64_t pos, avail_size;
de6d9b64 FB	63	int len;
	64
	65	len = ffm->packet_end - ffm->packet_ptr;
ba26712b BC	66	if (size <= len)
ba26712b BC	67	return 1;
899681cd	68	pos = url_ftell(s->pb);
b9edbe99	69	if (!ffm->write_index) {
21c6438f	70	if (pos == ffm->file_size)
b9edbe99 BC	71	return AVERROR_EOF;
	72	avail_size = ffm->file_size - pos;
	73	} else {
de6d9b64 FB	74	if (pos == ffm->write_index) {
de6d9b64 FB	75	/* exactly at the end of stream */
b9edbe99	76	return AVERROR(EAGAIN);
de6d9b64 FB	77	} else if (pos < ffm->write_index) {
	78	avail_size = ffm->write_index - pos;
	79	} else {
	80	avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);
	81	}
b9edbe99	82	}
de6d9b64 FB	83	avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;
	84	if (size <= avail_size)
	85	return 1;
	86	else
b9edbe99	87	return AVERROR(EAGAIN);
de6d9b64 FB	88	}
de6d9b64 FB	89
7c45723a BC	90	static int ffm_resync(AVFormatContext *s, int state)
	91	{
	92	av_log(s, AV_LOG_ERROR, "resyncing\n");
	93	while (state != PACKET_ID) {
	94	if (url_feof(s->pb)) {
	95	av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");
	96	return -1;
	97	}
	98	state = (state << 8) \| get_byte(s->pb);
	99	}
	100	return 0;
	101	}
	102
de6d9b64	103	/* first is true if we read the frame header */
4606ac8d	104	static int ffm_read_data(AVFormatContext *s,
b30bb535	105	uint8_t *buf, int size, int header)
de6d9b64 FB	106	{
de6d9b64 FB	107	FFMContext *ffm = s->priv_data;
899681cd	108	ByteIOContext *pb = s->pb;
7c45723a	109	int len, fill_size, size1, frame_offset, id;
de6d9b64 FB	110
	111	size1 = size;
	112	while (size > 0) {
	113	redo:
	114	len = ffm->packet_end - ffm->packet_ptr;
e5ece183 BC	115	if (len < 0)
e5ece183 BC	116	return -1;
de6d9b64 FB	117	if (len > size)
	118	len = size;
	119	if (len == 0) {
	120	if (url_ftell(pb) == ffm->file_size)
	121	url_fseek(pb, ffm->packet_size, SEEK_SET);
5e57424d	122	retry_read:
7c45723a BC	123	id = get_be16(pb); /* PACKET_ID */
	124	if (id != PACKET_ID)
	125	if (ffm_resync(s, id) < 0)
	126	return -1;
de6d9b64	127	fill_size = get_be16(pb);
fabb990e	128	ffm->dts = get_be64(pb);
de6d9b64 FB	129	frame_offset = get_be16(pb);
	130	get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
	131	ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
eea2f032	132	if (ffm->packet_end < ffm->packet \|\| frame_offset < 0)
71c32f19	133	return -1;
de6d9b64 FB	134	/* if first packet or resynchronization packet, we must
	135	handle it specifically */
	136	if (ffm->first_packet \|\| (frame_offset & 0x8000)) {
5e57424d PG	137	if (!frame_offset) {
	138	/* This packet has no frame headers in it */
	139	if (url_ftell(pb) >= ffm->packet_size * 3) {
	140	url_fseek(pb, -ffm->packet_size * 2, SEEK_CUR);
	141	goto retry_read;
	142	}
	143	/* This is bad, we cannot find a valid frame header */
	144	return 0;
	145	}
de6d9b64	146	ffm->first_packet = 0;
a077f3bc	147	if ((frame_offset & 0x7fff) < FFM_HEADER_SIZE)
71c32f19	148	return -1;
de6d9b64	149	ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;
b30bb535	150	if (!header)
de6d9b64 FB	151	break;
	152	} else {
	153	ffm->packet_ptr = ffm->packet;
	154	}
	155	goto redo;
	156	}
	157	memcpy(buf, ffm->packet_ptr, len);
	158	buf += len;
	159	ffm->packet_ptr += len;
	160	size -= len;
b30bb535	161	header = 0;
de6d9b64 FB	162	}
	163	return size1 - size;
	164	}
	165
4adcbbbe BC	166	//#define DEBUG_SEEK
4adcbbbe BC	167
92a0f338 BC	168	/* ensure that acutal seeking happens between FFM_PACKET_SIZE
92a0f338 BC	169	and file_size - FFM_PACKET_SIZE */
bc5c918e	170	static void ffm_seek1(AVFormatContext *s, int64_t pos1)
a1e01307 BC	171	{
	172	FFMContext *ffm = s->priv_data;
	173	ByteIOContext *pb = s->pb;
bc5c918e	174	int64_t pos;
a1e01307	175
92a0f338 BC	176	pos = FFMIN(pos1, ffm->file_size - FFM_PACKET_SIZE);
92a0f338 BC	177	pos = FFMAX(pos, FFM_PACKET_SIZE);
a1e01307	178	#ifdef DEBUG_SEEK
8999c833	179	av_log(s, AV_LOG_DEBUG, "seek to %"PRIx64" -> %"PRIx64"\n", pos1, pos);
a1e01307 BC	180	#endif
	181	url_fseek(pb, pos, SEEK_SET);
	182	}
	183
bc5c918e	184	static int64_t get_dts(AVFormatContext *s, int64_t pos)
979b1a06 BC	185	{
979b1a06 BC	186	ByteIOContext *pb = s->pb;
fabb990e	187	int64_t dts;
979b1a06 BC	188
	189	ffm_seek1(s, pos);
	190	url_fskip(pb, 4);
fabb990e	191	dts = get_be64(pb);
979b1a06	192	#ifdef DEBUG_SEEK
be2a6e2f	193	av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0);
979b1a06	194	#endif
fabb990e	195	return dts;
979b1a06	196	}
de6d9b64	197
91628427 PG	198	static void adjust_write_index(AVFormatContext *s)
	199	{
	200	FFMContext *ffm = s->priv_data;
899681cd	201	ByteIOContext *pb = s->pb;
91628427	202	int64_t pts;
bc5c918e DB	203	//int64_t orig_write_index = ffm->write_index;
bc5c918e DB	204	int64_t pos_min, pos_max;
91628427	205	int64_t pts_start;
bc5c918e	206	int64_t ptr = url_ftell(pb);
91628427 PG	207
	208
	209	pos_min = 0;
	210	pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;
	211
fabb990e	212	pts_start = get_dts(s, pos_min);
91628427	213
fabb990e	214	pts = get_dts(s, pos_max);
91628427	215
115329f1	216	if (pts - 100000 > pts_start)
79292510	217	goto end;
91628427 PG	218
	219	ffm->write_index = FFM_PACKET_SIZE;
	220
fabb990e	221	pts_start = get_dts(s, pos_min);
91628427	222
fabb990e	223	pts = get_dts(s, pos_max);
91628427 PG	224
	225	if (pts - 100000 <= pts_start) {
	226	while (1) {
bc5c918e	227	int64_t newpos;
91628427 PG	228	int64_t newpts;
	229
	230	newpos = ((pos_max + pos_min) / (2 * FFM_PACKET_SIZE)) * FFM_PACKET_SIZE;
	231
	232	if (newpos == pos_min)
	233	break;
	234
fabb990e	235	newpts = get_dts(s, newpos);
91628427 PG	236
	237	if (newpts - 100000 <= pts) {
	238	pos_max = newpos;
	239	pts = newpts;
	240	} else {
	241	pos_min = newpos;
	242	}
	243	}
	244	ffm->write_index += pos_max;
	245	}
	246
949b1a13	247	//printf("Adjusted write index from %"PRId64" to %"PRId64": pts=%0.6f\n", orig_write_index, ffm->write_index, pts / 1000000.);
fabb990e	248	//printf("pts range %0.6f - %0.6f\n", get_dts(s, 0) / 1000000. , get_dts(s, ffm->file_size - 2 * FFM_PACKET_SIZE) / 1000000. );
91628427	249
79292510	250	end:
91628427 PG	251	url_fseek(pb, ptr, SEEK_SET);
	252	}
	253
	254
de6d9b64 FB	255	static int ffm_read_header(AVFormatContext s, AVFormatParameters ap)
de6d9b64 FB	256	{
c9a65ca8	257	FFMContext *ffm = s->priv_data;
de6d9b64	258	AVStream *st;
899681cd	259	ByteIOContext *pb = s->pb;
de6d9b64	260	AVCodecContext *codec;
fa26a29d	261	int i, nb_streams;
0c1a9eda	262	uint32_t tag;
de6d9b64	263
de6d9b64 FB	264	/* header */
	265	tag = get_le32(pb);
	266	if (tag != MKTAG('F', 'F', 'M', '1'))
	267	goto fail;
	268	ffm->packet_size = get_be32(pb);
	269	if (ffm->packet_size != FFM_PACKET_SIZE)
	270	goto fail;
	271	ffm->write_index = get_be64(pb);
	272	/* get also filesize */
	273	if (!url_is_streamed(pb)) {
a965c478	274	ffm->file_size = url_fsize(pb);
b9edbe99 BC	275	if (ffm->write_index)
b9edbe99 BC	276	adjust_write_index(s);
de6d9b64	277	} else {
8da9266c	278	ffm->file_size = (UINT64_C(1) << 63) - 1;
de6d9b64 FB	279	}
de6d9b64 FB	280
fa26a29d	281	nb_streams = get_be32(pb);
de6d9b64 FB	282	get_be32(pb); /* total bitrate */
de6d9b64 FB	283	/* read each stream */
fa26a29d	284	for(i=0;i<nb_streams;i++) {
75bdb984 PG	285	char rc_eq_buf[128];
75bdb984 PG	286
fa26a29d	287	st = av_new_stream(s, 0);
de6d9b64 FB	288	if (!st)
de6d9b64 FB	289	goto fail;
115329f1	290
e928649b	291	av_set_pts_info(st, 64, 1, 1000000);
115329f1	292
01f4895c	293	codec = st->codec;
de6d9b64	294	/* generic info */
26aa0f89 AB	295	codec->codec_id = get_be32(pb);
26aa0f89 AB	296	codec->codec_type = get_byte(pb); /* codec_type */
de6d9b64	297	codec->bit_rate = get_be32(pb);
26aa0f89	298	st->quality = get_be32(pb);
ccac2e27	299	codec->flags = get_be32(pb);
22332126 PG	300	codec->flags2 = get_be32(pb);
22332126 PG	301	codec->debug = get_be32(pb);
de6d9b64 FB	302	/* specific info */
	303	switch(codec->codec_type) {
	304	case CODEC_TYPE_VIDEO:
c0df9d75 MN	305	codec->time_base.num = get_be32(pb);
c0df9d75 MN	306	codec->time_base.den = get_be32(pb);
de6d9b64 FB	307	codec->width = get_be16(pb);
de6d9b64 FB	308	codec->height = get_be16(pb);
20f01548	309	codec->gop_size = get_be16(pb);
22332126	310	codec->pix_fmt = get_be32(pb);
20f01548 PG	311	codec->qmin = get_byte(pb);
	312	codec->qmax = get_byte(pb);
	313	codec->max_qdiff = get_byte(pb);
	314	codec->qcompress = get_be16(pb) / 10000.0;
	315	codec->qblur = get_be16(pb) / 10000.0;
3884a3c3	316	codec->bit_rate_tolerance = get_be32(pb);
e9a9e0c2	317	codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));
75bdb984 PG	318	codec->rc_max_rate = get_be32(pb);
	319	codec->rc_min_rate = get_be32(pb);
	320	codec->rc_buffer_size = get_be32(pb);
7cb8f314 MN	321	codec->i_quant_factor = av_int2dbl(get_be64(pb));
	322	codec->b_quant_factor = av_int2dbl(get_be64(pb));
	323	codec->i_quant_offset = av_int2dbl(get_be64(pb));
	324	codec->b_quant_offset = av_int2dbl(get_be64(pb));
75bdb984	325	codec->dct_algo = get_be32(pb);
22332126 PG	326	codec->strict_std_compliance = get_be32(pb);
	327	codec->max_b_frames = get_be32(pb);
	328	codec->luma_elim_threshold = get_be32(pb);
	329	codec->chroma_elim_threshold = get_be32(pb);
	330	codec->mpeg_quant = get_be32(pb);
	331	codec->intra_dc_precision = get_be32(pb);
	332	codec->me_method = get_be32(pb);
	333	codec->mb_decision = get_be32(pb);
	334	codec->nsse_weight = get_be32(pb);
	335	codec->frame_skip_cmp = get_be32(pb);
7cb8f314	336	codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb));
038a1243	337	codec->codec_tag = get_be32(pb);
dbedf2aa	338	codec->thread_count = get_byte(pb);
d2b34efe JGG	339	codec->coder_type = get_be32(pb);
	340	codec->me_cmp = get_be32(pb);
	341	codec->partitions = get_be32(pb);
	342	codec->me_subpel_quality = get_be32(pb);
	343	codec->me_range = get_be32(pb);
	344	codec->keyint_min = get_be32(pb);
	345	codec->scenechange_threshold = get_be32(pb);
	346	codec->b_frame_strategy = get_be32(pb);
	347	codec->qcompress = av_int2dbl(get_be64(pb));
	348	codec->qblur = av_int2dbl(get_be64(pb));
	349	codec->max_qdiff = get_be32(pb);
	350	codec->refs = get_be32(pb);
	351	codec->directpred = get_be32(pb);
de6d9b64 FB	352	break;
	353	case CODEC_TYPE_AUDIO:
	354	codec->sample_rate = get_be32(pb);
	355	codec->channels = get_le16(pb);
20f01548	356	codec->frame_size = get_le16(pb);
8c0c1122	357	codec->sample_fmt = get_le16(pb);
de6d9b64	358	break;
20f01548	359	default:
75bdb984	360	goto fail;
de6d9b64	361	}
7080cbe2 BC	362	if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
	363	codec->extradata_size = get_be32(pb);
	364	codec->extradata = av_malloc(codec->extradata_size);
	365	if (!codec->extradata)
	366	return AVERROR(ENOMEM);
	367	get_buffer(pb, codec->extradata, codec->extradata_size);
	368	}
de6d9b64 FB	369	}
	370
	371	/* get until end of block reached */
	372	while ((url_ftell(pb) % ffm->packet_size) != 0)
	373	get_byte(pb);
	374
	375	/* init packet demux */
	376	ffm->packet_ptr = ffm->packet;
	377	ffm->packet_end = ffm->packet;
	378	ffm->frame_offset = 0;
fabb990e	379	ffm->dts = 0;
de6d9b64 FB	380	ffm->read_state = READ_HEADER;
	381	ffm->first_packet = 1;
	382	return 0;
	383	fail:
	384	for(i=0;i<s->nb_streams;i++) {
	385	st = s->streams[i];
	386	if (st) {
1ea4f593	387	av_free(st);
de6d9b64 FB	388	}
de6d9b64 FB	389	}
de6d9b64 FB	390	return -1;
	391	}
	392
	393	/* return < 0 if eof */
	394	static int ffm_read_packet(AVFormatContext s, AVPacket pkt)
	395	{
	396	int size;
	397	FFMContext *ffm = s->priv_data;
b9edbe99	398	int duration, ret;
eee99eb3	399
de6d9b64 FB	400	switch(ffm->read_state) {
de6d9b64 FB	401	case READ_HEADER:
b9edbe99 BC	402	if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
	403	return ret;
	404
ff978de4	405	dprintf(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
e785efc4	406	url_ftell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);
115329f1	407	if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
66d2ff2a	408	FRAME_HEADER_SIZE)
b9edbe99	409	return -1;
3c6a9f66 BC	410	if (ffm->header[1] & FLAG_DTS)
3c6a9f66 BC	411	if (ffm_read_data(s, ffm->header+16, 4, 1) != 4)
b9edbe99	412	return -1;
de6d9b64	413	#if 0
a299832f	414	av_hexdump_log(s, AV_LOG_DEBUG, ffm->header, FRAME_HEADER_SIZE);
de6d9b64 FB	415	#endif
	416	ffm->read_state = READ_DATA;
	417	/* fall thru */
	418	case READ_DATA:
80fb8234	419	size = AV_RB24(ffm->header + 2);
b9edbe99 BC	420	if ((ret = ffm_is_avail_data(s, size)) < 0)
b9edbe99 BC	421	return ret;
de6d9b64	422
80fb8234	423	duration = AV_RB24(ffm->header + 5);
20f01548	424
de6d9b64 FB	425	av_new_packet(pkt, size);
de6d9b64 FB	426	pkt->stream_index = ffm->header[0];
2ea2340e BC	427	if ((unsigned)pkt->stream_index >= s->nb_streams) {
	428	av_log(s, AV_LOG_ERROR, "invalid stream index %d\n", pkt->stream_index);
	429	av_free_packet(pkt);
	430	ffm->read_state = READ_HEADER;
b9edbe99	431	return -1;
2ea2340e	432	}
899681cd	433	pkt->pos = url_ftell(s->pb);
de6d9b64 FB	434	if (ffm->header[1] & FLAG_KEY_FRAME)
de6d9b64 FB	435	pkt->flags \|= PKT_FLAG_KEY;
4606ac8d	436
de6d9b64 FB	437	ffm->read_state = READ_HEADER;
	438	if (ffm_read_data(s, pkt->data, size, 0) != size) {
	439	/* bad case: desynchronized packet. we cancel all the packet loading */
	440	av_free_packet(pkt);
b9edbe99	441	return -1;
de6d9b64	442	}
3c6a9f66 BC	443	pkt->pts = AV_RB64(ffm->header+8);
	444	if (ffm->header[1] & FLAG_DTS)
	445	pkt->dts = pkt->pts - AV_RB32(ffm->header+16);
	446	else
	447	pkt->dts = pkt->pts;
20f01548	448	pkt->duration = duration;
de6d9b64 FB	449	break;
	450	}
	451	return 0;
	452	}
	453
de6d9b64	454	/* seek to a given time in the file. The file read pointer is
aa6b38c2	455	positioned at or before pts. XXX: the following code is quite
de6d9b64	456	approximative */
7b3c1382	457	static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags)
de6d9b64 FB	458	{
de6d9b64 FB	459	FFMContext *ffm = s->priv_data;
bc5c918e	460	int64_t pos_min, pos_max, pos;
0c1a9eda	461	int64_t pts_min, pts_max, pts;
de6d9b64 FB	462	double pos1;
	463
	464	#ifdef DEBUG_SEEK
8999c833	465	av_log(s, AV_LOG_DEBUG, "wanted_pts=%0.6f\n", wanted_pts / 1000000.0);
de6d9b64 FB	466	#endif
	467	/* find the position using linear interpolation (better than
	468	dichotomy in typical cases) */
92a0f338 BC	469	pos_min = FFM_PACKET_SIZE;
92a0f338 BC	470	pos_max = ffm->file_size - FFM_PACKET_SIZE;
de6d9b64	471	while (pos_min <= pos_max) {
fabb990e BC	472	pts_min = get_dts(s, pos_min);
fabb990e BC	473	pts_max = get_dts(s, pos_max);
de6d9b64	474	/* linear interpolation */
4606ac8d	475	pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /
de6d9b64	476	(double)(pts_max - pts_min);
0c1a9eda	477	pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
de6d9b64 FB	478	if (pos <= pos_min)
	479	pos = pos_min;
	480	else if (pos >= pos_max)
	481	pos = pos_max;
fabb990e	482	pts = get_dts(s, pos);
de6d9b64 FB	483	/* check if we are lucky */
	484	if (pts == wanted_pts) {
	485	goto found;
	486	} else if (pts > wanted_pts) {
	487	pos_max = pos - FFM_PACKET_SIZE;
	488	} else {
	489	pos_min = pos + FFM_PACKET_SIZE;
	490	}
	491	}
7b3c1382	492	pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
92a0f338	493
de6d9b64 FB	494	found:
de6d9b64 FB	495	ffm_seek1(s, pos);
c07d64c8 BC	496
	497	/* reset read state */
	498	ffm->read_state = READ_HEADER;
	499	ffm->packet_ptr = ffm->packet;
	500	ffm->packet_end = ffm->packet;
	501	ffm->first_packet = 1;
	502
de6d9b64 FB	503	return 0;
	504	}
	505
07c4ed85 PG	506	static int ffm_probe(AVProbeData *p)
07c4ed85 PG	507	{
87e87886	508	if (
115329f1	509	p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&
66d2ff2a	510	p->buf[3] == '1')
07c4ed85	511	return AVPROBE_SCORE_MAX + 1;
07c4ed85 PG	512	return 0;
	513	}
	514
114a93c7	515	static int ffm_close(AVFormatContext *s)
2dc22a64 VS	516	{
	517	int i;
	518
	519	for (i = 0; i < s->nb_streams; i++)
	520	av_freep(&s->streams[i]->codec->rc_eq);
114a93c7 BF	521
114a93c7 BF	522	return 0;
2dc22a64 VS	523	}
2dc22a64 VS	524
ff70e601	525	AVInputFormat ffm_demuxer = {
c9a65ca8	526	"ffm",
af274fd1	527	NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
66d2ff2a	528	sizeof(FFMContext),
07c4ed85	529	ffm_probe,
c9a65ca8 FB	530	ffm_read_header,
c9a65ca8 FB	531	ffm_read_packet,
2dc22a64	532	ffm_close,
c9a65ca8	533	ffm_seek,
c9a65ca8	534	};