+/*
+ * CINELERRA
+ * Copyright (C) 2012-2014 Paolo Rampino
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
#ifndef FFMPEG_H
#define FFMPEG_H
#include "libavformat/avformat.h"
#include "libavformat/avio.h"
#include "libavcodec/avcodec.h"
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,18,100)
+#include "libavcodec/bsf.h"
+#endif
#include "libavfilter/avfilter.h"
#include "libavutil/avutil.h"
#include "libavfilter/buffersrc.h"
#include "libavutil/pixdesc.h"
#include "libswresample/swresample.h"
#include "libswscale/swscale.h"
+#include "libavutil/parseutils.h"
+#include "libavutil/timecode.h"
}
class FFPacket {
virtual int encode_activate();
virtual int decode_activate();
virtual AVHWDeviceType decode_hw_activate();
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ virtual int decode_hw_format(const AVCodec *decoder, AVHWDeviceType type);
+#else
virtual int decode_hw_format(AVCodec *decoder, AVHWDeviceType type);
+#endif
virtual int write_packet(FFPacket &pkt);
int read_packet();
int seek(int64_t no, double rate);
virtual int decode_frame(AVFrame *frame) = 0;
virtual int encode_frame(AVFrame *frame) = 0;
virtual int init_frame(AVFrame *frame) = 0;
- virtual int create_filter(const char *filter_spec, AVCodecParameters *avpar) = 0;
+ virtual int create_filter(const char *filter_spec) = 0;
virtual void load_markers() = 0;
virtual IndexMarks *get_markers() = 0;
- int create_filter(const char *filter_spec);
- int load_filter(AVFrame *frame);
+ int insert_filter(const char *name, const char *arg, const char *inst_name=0);
+ int config_filters(const char *filter_spec, AVFilterContext *fsrc);
+ virtual int load_filter(AVFrame *frame);
int read_filter(AVFrame *frame);
int read_frame(AVFrame *frame);
int open_stats_file();
AVFormatContext *fmt_ctx;
AVCodecContext *avctx;
- AVFilterContext *buffersink_ctx;
+ AVFilterContext *filt_ctx;
+ int filt_id;
AVFilterContext *buffersrc_ctx;
+ AVFilterContext *buffersink_ctx;
AVFilterGraph *filter_graph;
AVFrame *frame, *fframe;
+ AVFrame *probe_frame;
AVBSFContext *bsfc;
FFPacket ipkt;
int64_t seek_pos, curr_pos;
int fidx;
int reading, writing;
- int seeked, eof;
+ int seeking, seeked, eof;
int hw_pixfmt;
AVBufferRef *hw_device_ctx;
int load_history(uint8_t **data, int len);
int decode_frame(AVFrame *frame);
int encode_frame(AVFrame *frame);
- int create_filter(const char *filter_spec, AVCodecParameters *avpar);
+ int create_filter(const char *filter_spec);
void load_markers();
IndexMarks *get_markers();
int is_video() { return 1; }
int decode_frame(AVFrame *frame);
AVHWDeviceType decode_hw_activate();
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int decode_hw_format(const AVCodec *decoder, AVHWDeviceType type);
+#else
int decode_hw_format(AVCodec *decoder, AVHWDeviceType type);
+#endif
AVHWDeviceType encode_hw_activate(const char *hw_dev);
int encode_hw_write(FFrame *picture);
int encode_frame(AVFrame *frame);
- int create_filter(const char *filter_spec, AVCodecParameters *avpar);
+ int create_filter(const char *filter_spec);
void load_markers();
IndexMarks *get_markers();
int init_frame(AVFrame *picture);
int load(VFrame *vframe, int64_t pos);
+ int probe(int64_t pos);
int video_seek(int64_t pos);
int encode(VFrame *vframe);
int drain();
+ int convert_hw_frame(AVFrame *ifrm, AVFrame *ofrm);
+ int load_filter(AVFrame *frame);
+ double get_rotation_angle();
+ int flip(double theta);
int idx;
double frame_rate;
- int width, height;
+ int width, height, transpose;
int64_t length;
float aspect_ratio;
int interlaced;
int top_field_first;
+ int color_space, color_range;
+ struct SwsContext *fconvert_ctx;
};
class FFCodecRemap
public:
FFCodecRemaps() {}
int add(const char *val);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int update(AVCodecID &codec_id, const AVCodec *&decoder);
+#else
int update(AVCodecID &codec_id, AVCodec *&decoder);
+#endif
+};
+
+// for get_initial_timecode auto deletes
+class avFrame {
+ AVFrame *frm;
+public:
+ avFrame() { frm = av_frame_alloc(); }
+ ~avFrame() { av_frame_free(&frm); }
+ operator AVFrame *() { return frm; }
+ AVFrame *operator ->() { return frm; }
};
+class avPacket {
+ AVPacket pkt;
+public:
+ avPacket() {
+ av_init_packet(&pkt);
+ pkt.data = 0; pkt.size = 0;
+ }
+ ~avPacket() { av_packet_unref(&pkt); }
+ operator AVPacket *() { return &pkt; }
+ AVPacket *operator ->() { return &pkt; }
+};
+
+class avCodecContext {
+ AVCodecContext *avctx;
+public:
+ avCodecContext(AVCodecContext *ctx) { avctx = ctx; }
+ ~avCodecContext() { avcodec_free_context(&avctx); }
+ operator AVCodecContext *() { return avctx; }
+ AVCodecContext *operator ->() { return avctx; }
+};
+
+
class FFMPEG : public Thread {
public:
static Mutex fflock;
static void ff_lock(const char *cp=0) { fflock.lock(cp); }
static void ff_unlock() { fflock.unlock(); }
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59,16,100)
+ int check_sample_rate(const AVCodec *codec, int sample_rate);
+#else
int check_sample_rate(AVCodec *codec, int sample_rate);
- AVRational check_frame_rate(AVCodec *codec, double frame_rate);
+#endif
+ AVRational check_frame_rate(const AVRational *p, double frame_rate);
AVRational to_sample_aspect_ratio(Asset *asset);
AVRational to_time_base(int sample_rate);
static int get_fmt_score(AVSampleFormat dst_fmt, AVSampleFormat src_fmt);
static void load_audio_options(Asset *asset, EDL *edl);
static void scan_video_options(Asset *asset, EDL *edl);
static void load_video_options(Asset *asset, EDL *edl);
+ static void scan_format_options(Asset *asset, EDL *edl);
+ static void load_format_options(Asset *asset, EDL *edl);
static void set_asset_format(Asset *asset, EDL *edl, const char *text);
int get_file_format();
static int get_encoder(const char *options, char *format, char *codec, char *bsfilter);
static double to_secs(int64_t time, AVRational time_base);
int info(char *text, int len);
+ void put_cache_frame(VFrame *frame, int64_t position);
+ int get_use_cache();
+ void purge_cache();
+
int init_decoder(const char *filename);
int open_decoder();
int init_encoder(const char *filename);
int total_audio_channels();
int total_video_channels();
+ double get_initial_timecode(int data_type, int channel, double frame_rate);
int audio_seek(int ch, int64_t pos);
+ int video_probe(int64_t pos);
int video_seek(int layer, int64_t pos);
int decode(int chn, int64_t pos, double *samples, int len);
int decoding, encoding;
int has_audio, has_video;
+ int interlace_from_codec;
FFMPEG(FileBase *file_base=0);
~FFMPEG();
+ AVCodecContext *activate_decoder(AVStream *st);
int scan(IndexState *index_state, int64_t *scan_position, int *canceled);
int ff_audio_stream(int channel) { return astrm_index[channel].st_idx; }
int ff_coded_width(int stream);
int ff_coded_height(int stream);
float ff_aspect_ratio(int stream);
+ int ff_color_range(int stream);
+ int ff_color_space(int stream);
+ int ff_interlace(int stream);
double ff_frame_rate(int stream);
- const char *ff_video_format(int stream);
+ const char *ff_video_codec(int stream);
int64_t ff_video_frames(int stream);
int ff_video_pid(int stream);
int ff_video_mpeg_color_range(int stream);
+ double ff_get_timecode(char *str, AVRational rate, double pos);
+ static double get_timecode(const char *path, int data_type, int channel, double rate);
int ff_cpus();
const char *ff_hw_dev();
projects / goodguy / cinelerra.git / blobdiff