~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

 

#define LIBAVFORMAT_BUILD       LIBAVFORMAT_VERSION_INT

 

#define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)

 

#include <time.h>

#include <stdio.h>  /* FILE */

 

#include "avio.h"

 

#define PKT_FLAG_KEY   0x0001

 

void av_destruct_packet_nofree(AVPacket *pkt);

void av_destruct_packet(AVPacket *pkt);

 

 

int av_new_packet(AVPacket *pkt, int size);

int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size);

int av_dup_packet(AVPacket *pkt);

 

/**

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

/* fractional numbers for exact pts handling */

 

typedef struct AVFrac {

    int64_t val, num, den;

} AVFrac attribute_deprecated;

 

struct AVFormatContext;

 

typedef struct AVProbeData {

    const char *filename;

    unsigned char *buf;

} AVProbeData;

 

#define AVPROBE_SCORE_MAX 100               ///< max score, half of that is used for file extension based detection

 

typedef struct AVFormatParameters {

    AVRational time_base;

    int width;

    int height;

    enum PixelFormat pix_fmt;

                                  stream packet (only meaningful if

                                  immediately (RTSP only) */

    int prealloced_context:1;

    enum CodecID video_codec_id;

    enum CodecID audio_codec_id;

} AVFormatParameters;

 

//! demuxer will use url_fopen, no opened file should be provided by the caller

#define AVFMT_NOFILE        0x0001

                                      raw picture data */

 

typedef struct AVOutputFormat {

    const char *name;

    const char *long_name;

    const char *mime_type;

    int priv_data_size;

    /* output support */

    int (*write_header)(struct AVFormatContext *);

    int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);

    int (*write_trailer)(struct AVFormatContext *);

    int flags;

    int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *);

    int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush);

 

     */

    const struct AVCodecTag **codec_tag;

 

    /* private fields */

    struct AVOutputFormat *next;

} AVOutputFormat;

typedef struct AVInputFormat {

    const char *name;

    const char *long_name;

    int priv_data_size;

    int (*read_probe)(AVProbeData *);

       structure. Return 0 if OK. 'ap' if non NULL contains

       now. 'av_new_stream' should be called to create new streams.  */

    int (*read_header)(struct AVFormatContext *,

                       AVFormatParameters *ap);

       set. 'av_new_stream' can be called only if the flag

       AVFMTCTX_NOHEADER is used. */

    int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);

       freed by this function */

    int (*read_close)(struct AVFormatContext *);

    /**

     * @param stream_index must not be -1

     * @param flags selects which direction should be preferred if no exact

     *              match is available

     */

    int (*read_seek)(struct AVFormatContext *,

                     int stream_index, int64_t timestamp, int flags);

    /**

     */

    int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,

                              int64_t *pos, int64_t pos_limit);

    int flags;

       usually not use extension format guessing because it is not

       reliable enough */

    const char *extensions;

    int value;

 

       (RTSP) */

    int (*read_play)(struct AVFormatContext *);

 

       (RTSP) */

    int (*read_pause)(struct AVFormatContext *);

 

    struct AVInputFormat *next;

} AVInputFormat;

 

typedef struct AVIndexEntry {

    int64_t pos;

    int64_t timestamp;

#define AVINDEX_KEYFRAME 0x0001

    int flags:2;

} AVIndexEntry;

 

typedef struct AVStream {

    /**

     */

    AVRational r_frame_rate;

    void *priv_data;

    /* internal data used in av_find_stream_info() */

 

    /**

     * identically 1.

     */

    AVRational time_base;

    /* ffmpeg.c private use */

    //FIXME move stuff to a flags field?

    float quality;

    int64_t start_time;

    int64_t duration;

 

 

    /* av_read_frame() support */

    struct AVCodecParserContext *parser;

 

    int64_t cur_dts;

    int last_IP_duration;

    int64_t last_IP_pts;

    /* av_seek_frame() support */

                                    support seeking natively */

    int nb_index_entries;

    unsigned int index_entries_allocated_size;

 

#define MAX_REORDER_DELAY 4

    int64_t pts_buffer[MAX_REORDER_DELAY+1];

} AVStream;

 

                                         (streams are added dynamically) */

 

#define MAX_STREAMS 20

 

typedef struct AVFormatContext {

    /* can only be iformat or oformat, not both at the same time */

    struct AVInputFormat *iformat;

    struct AVOutputFormat *oformat;

    void *priv_data;

    unsigned int nb_streams;

    AVStream *streams[MAX_STREAMS];

    /* stream info */

    int64_t timestamp;

    char title[512];

    char copyright[512];

    char comment[512];

    char album[512];

 

    /* private data for pts handling (do not modify directly) */

       not decoded, for example to get the codec parameters in mpeg

       streams */

    struct AVPacketList *packet_buffer;

 

       AV_TIME_BASE fractional seconds. NEVER set this value directly:

       it is deduced from the AVStream values.  */

    int64_t start_time;

       seconds. NEVER set this value directly: it is deduced from the

       AVStream values.  */

    int64_t duration;

    int64_t file_size;

       available. Never set it directly if the file_size and the

       duration are known as ffmpeg can compute it automatically. */

    int bit_rate;

    AVPacket cur_pkt;

 

    /* av_seek_frame() support */

    int index_built;

 

    int mux_rate;

 

#define AVFMT_NOOUTPUTLOOP -1

#define AVFMT_INFINITEOUTPUTLOOP 0

    int loop_output;

 

    int flags;

#define AVFMT_FLAG_GENPTS       0x0001 ///< generate pts if missing even if it requires parsing future frames

#define AVFMT_FLAG_IGNIDX       0x0002 ///< ignore index

 

    int loop_input;

    unsigned int probesize;

 

    /**

 

    const uint8_t *key;

    int keylen;

} AVFormatContext;

 

typedef struct AVPacketList {

    struct AVPacketList *next;

} AVPacketList;

 

extern AVInputFormat *first_iformat;

extern AVOutputFormat *first_oformat;

 

enum CodecID av_guess_image2_codec(const char *filename);

 

/* XXX: use automatic init with either ELF sections or C file parser */

/* modules */

 

/* utils.c */

void av_register_input_format(AVInputFormat *format);

void av_register_output_format(AVOutputFormat *format);

                                    const char *filename, const char *mime_type);

AVOutputFormat *guess_format(const char *short_name,

                             const char *filename, const char *mime_type);

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

                            const char *filename, const char *mime_type, enum CodecType type);

 

void av_hex_dump(FILE *f, uint8_t *buf, int size);

void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);

 

void av_register_all(void);

 

enum CodecID av_codec_get_id(const struct AVCodecTag **tags, unsigned int tag);

unsigned int av_codec_get_tag(const struct AVCodecTag **tags, enum CodecID id);

 

/* media file input */

AVInputFormat *av_find_input_format(const char *short_name);

AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);

int av_open_input_stream(AVFormatContext **ic_ptr,

                         ByteIOContext *pb, const char *filename,

                         AVInputFormat *fmt, AVFormatParameters *ap);

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

                       AVInputFormat *fmt,

                       int buf_size,

                       AVFormatParameters *ap);

AVFormatContext *av_alloc_format_context(void);

 

int av_find_stream_info(AVFormatContext *ic);

int av_read_packet(AVFormatContext *s, AVPacket *pkt);

int av_read_frame(AVFormatContext *s, AVPacket *pkt);

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);

int av_read_play(AVFormatContext *s);

int av_read_pause(AVFormatContext *s);

void av_close_input_file(AVFormatContext *s);

AVStream *av_new_stream(AVFormatContext *s, int id);

void av_set_pts_info(AVStream *s, int pts_wrap_bits,

                     int pts_num, int pts_den);

 

#define AVSEEK_FLAG_ANY      4 ///< seek to any frame, even non keyframes

 

int av_find_default_stream_index(AVFormatContext *s);

int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);

int av_add_index_entry(AVStream *st,

                       int64_t pos, int64_t timestamp, int size, int distance, int flags);

int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags);

void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);

int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));

 

int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);

int av_write_header(AVFormatContext *s);

int av_write_frame(AVFormatContext *s, AVPacket *pkt);

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);

int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush);

 

int av_write_trailer(AVFormatContext *s);

 

void dump_format(AVFormatContext *ic,

                 int index,

                 const char *url,

                 int is_output);

int64_t parse_date(const char *datestr, int duration);

 

int64_t av_gettime(void);