/* * FFM (ffserver live feed) encoder and decoder * Copyright (c) 2001 Fabrice Bellard. * * This library 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 of the License, or (at your option) any later version. * * This library 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 this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */#include "avformat.h"#include <unistd.h>/* The FFM file is made of blocks of fixed size */#define FFM_HEADER_SIZE 14#define PACKET_ID       0x666d/* each packet contains frames (which can span several packets */#define FRAME_HEADER_SIZE    8#define FLAG_KEY_FRAME       0x01typedef struct FFMStream {    int64_t pts;} FFMStream;enum {    READ_HEADER,    READ_DATA,};typedef struct FFMContext {    /* only reading mode */    offset_t write_index, file_size;    int read_state;    uint8_t header[FRAME_HEADER_SIZE];    /* read and write */    int first_packet; /* true if first packet, needed to set the discontinuity tag */    int packet_size;    int frame_offset;    int64_t pts;    uint8_t *packet_ptr, *packet_end;    uint8_t packet[FFM_PACKET_SIZE];} FFMContext;static int64_t get_pts(AVFormatContext *s, offset_t pos);/* disable pts hack for testing */int ffm_nopts = 0;#ifdef CONFIG_ENCODERSstatic void flush_packet(AVFormatContext *s){    FFMContext *ffm = s->priv_data;    int fill_size, h;    ByteIOContext *pb = &s->pb;    fill_size = ffm->packet_end - ffm->packet_ptr;    memset(ffm->packet_ptr, 0, fill_size);    if (url_ftell(pb) % ffm->packet_size)         av_abort();    /* put header */    put_be16(pb, PACKET_ID);    put_be16(pb, fill_size);    put_be64(pb, ffm->pts);    h = ffm->frame_offset;    if (ffm->first_packet)        h |= 0x8000;    put_be16(pb, h);    put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);    /* prepare next packet */    ffm->frame_offset = 0; /* no key frame */    ffm->pts = 0; /* no pts */    ffm->packet_ptr = ffm->packet;    ffm->first_packet = 0;}/* 'first' is true if first data of a frame */static void ffm_write_data(AVFormatContext *s,                           const uint8_t *buf, int size,                           int64_t pts, int first){    FFMContext *ffm = s->priv_data;    int len;    if (first && ffm->frame_offset == 0)        ffm->frame_offset = ffm->packet_ptr - ffm->packet + FFM_HEADER_SIZE;    if (first && ffm->pts == 0)        ffm->pts = pts;    /* write as many packets as needed */    while (size > 0) {        len = ffm->packet_end - ffm->packet_ptr;        if (len > size)            len = size;        memcpy(ffm->packet_ptr, buf, len);        ffm->packet_ptr += len;        buf += len;        size -= len;        if (ffm->packet_ptr >= ffm->packet_end) {            /* special case : no pts in packet : we leave the current one */            if (ffm->pts == 0)                ffm->pts = pts;            flush_packet(s);        }    }}static int ffm_write_header(AVFormatContext *s){    FFMContext *ffm = s->priv_data;    AVStream *st;    FFMStream *fst;    ByteIOContext *pb = &s->pb;    AVCodecContext *codec;    int bit_rate, i;    ffm->packet_size = FFM_PACKET_SIZE;    /* header */    put_tag(pb, "FFM1");    put_be32(pb, ffm->packet_size);    /* XXX: store write position in other file ? */    put_be64(pb, ffm->packet_size); /* current write position */    put_be32(pb, s->nb_streams);    bit_rate = 0;    for(i=0;i<s->nb_streams;i++) {        st = s->streams[i];        bit_rate += st->codec.bit_rate;    }    put_be32(pb, bit_rate);    /* list of streams */    for(i=0;i<s->nb_streams;i++) {        st = s->streams[i];        fst = av_mallocz(sizeof(FFMStream));        if (!fst)            goto fail;        st->priv_data = fst;        codec = &st->codec;        /* generic info */        put_be32(pb, codec->codec_id);        put_byte(pb, codec->codec_type);        put_be32(pb, codec->bit_rate);	put_be32(pb, st->quality);        put_be32(pb, codec->flags);        /* specific info */        switch(codec->codec_type) {        case CODEC_TYPE_VIDEO:            put_be32(pb, codec->frame_rate_base);            put_be32(pb, codec->frame_rate);            put_be16(pb, codec->width);            put_be16(pb, codec->height);            put_be16(pb, codec->gop_size);            put_byte(pb, codec->qmin);            put_byte(pb, codec->qmax);            put_byte(pb, codec->max_qdiff);            put_be16(pb, (int) (codec->qcompress * 10000.0));            put_be16(pb, (int) (codec->qblur * 10000.0));            put_be32(pb, codec->bit_rate_tolerance);            put_strz(pb, codec->rc_eq);            put_be32(pb, codec->rc_max_rate);            put_be32(pb, codec->rc_min_rate);            put_be32(pb, codec->rc_buffer_size);            put_be64_double(pb, codec->i_quant_factor);            put_be64_double(pb, codec->b_quant_factor);            put_be64_double(pb, codec->i_quant_offset);            put_be64_double(pb, codec->b_quant_offset);            put_be32(pb, codec->dct_algo);            break;        case CODEC_TYPE_AUDIO:            put_be32(pb, codec->sample_rate);            put_le16(pb, codec->channels);            put_le16(pb, codec->frame_size);            break;        default:            av_abort();        }        /* hack to have real time */        if (ffm_nopts)            fst->pts = 0;        else            fst->pts = av_gettime();    }    /* flush until end of block reached */    while ((url_ftell(pb) % ffm->packet_size) != 0)        put_byte(pb, 0);    put_flush_packet(pb);    /* init packet mux */    ffm->packet_ptr = ffm->packet;    ffm->packet_end = ffm->packet + ffm->packet_size - FFM_HEADER_SIZE;    if (ffm->packet_end < ffm->packet)        av_abort();    ffm->frame_offset = 0;    ffm->pts = 0;    ffm->first_packet = 1;    return 0; fail:    for(i=0;i<s->nb_streams;i++) {        st = s->streams[i];        av_freep(&st->priv_data);    }    return -1;}static int ffm_write_packet(AVFormatContext *s, int stream_index,                            const uint8_t *buf, int size, int64_t force_pts){    AVStream *st = s->streams[stream_index];    FFMStream *fst = st->priv_data;    int64_t pts;    uint8_t header[FRAME_HEADER_SIZE];    int duration;    if (st->codec.codec_type == CODEC_TYPE_AUDIO) {        duration = ((float)st->codec.frame_size / st->codec.sample_rate * 1000000.0);    } else {        duration = (1000000.0 * st->codec.frame_rate_base / (float)st->codec.frame_rate);    }    pts = fst->pts;    /* packet size & key_frame */    header[0] = stream_index;    header[1] = 0;    if (st->codec.coded_frame->key_frame) //if st->codec.coded_frame==NULL then there is a bug somewhere else        header[1] |= FLAG_KEY_FRAME;    header[2] = (size >> 16) & 0xff;    header[3] = (size >> 8) & 0xff;    header[4] = size & 0xff;    header[5] = (duration >> 16) & 0xff;    header[6] = (duration >> 8) & 0xff;    header[7] = duration & 0xff;    ffm_write_data(s, header, FRAME_HEADER_SIZE, pts, 1);    ffm_write_data(s, buf, size, pts, 0);    fst->pts += duration;    return 0;}static int ffm_write_trailer(AVFormatContext *s){    ByteIOContext *pb = &s->pb;    FFMContext *ffm = s->priv_data;    int i;    /* flush packets */    if (ffm->packet_ptr > ffm->packet)        flush_packet(s);    put_flush_packet(pb);    if (!url_is_streamed(pb)) {        int64_t size;        /* update the write offset */        size = url_ftell(pb);        url_fseek(pb, 8, SEEK_SET);        put_be64(pb, size);        put_flush_packet(pb);    }    for(i=0;i<s->nb_streams;i++)        av_freep(&s->streams[i]->priv_data);    return 0;}#endif //CONFIG_ENCODERS/* ffm demux */static int ffm_is_avail_data(AVFormatContext *s, int size){    FFMContext *ffm = s->priv_data;    offset_t pos, avail_size;    int len;    len = ffm->packet_end - ffm->packet_ptr;    if (!ffm_nopts) {        /* XXX: I don't understand this test, so I disabled it for testing */        if (size <= len)            return 1;    }    pos = url_ftell(&s->pb);    if (pos == ffm->write_index) {        /* exactly at the end of stream */        return 0;    } 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 0;}/* first is true if we read the frame header */static int ffm_read_data(AVFormatContext *s,                         uint8_t *buf, int size, int first){    FFMContext *ffm = s->priv_data;    ByteIOContext *pb = &s->pb;    int len, fill_size, size1, frame_offset;    size1 = size;    while (size > 0) {    redo:        len = ffm->packet_end - ffm->packet_ptr;        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:            get_be16(pb); /* PACKET_ID */            fill_size = get_be16(pb);            ffm->pts = 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)                av_abort();            /* 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 & 0x7ffff) < FFM_HEADER_SIZE)                    av_abort();                ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;                if (!first)                    break;            } else {                ffm->packet_ptr = ffm->packet;            }            goto redo;        }        memcpy(buf, ffm->packet_ptr, len);        buf += len;        ffm->packet_ptr += len;        size -= len;        first = 0;    }    return size1 - size;}static void adjust_write_index(AVFormatContext *s){    FFMContext *ffm = s->priv_data;    ByteIOContext *pb = &s->pb;    int64_t pts;    //offset_t orig_write_index = ffm->write_index;