Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

262 lines (249 sloc) 11.581 kB
#pragma once
/*
* Copyright (C) 2005-2011 Team XBMC
* http://www.xbmc.org
*
* 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, 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 XBMC; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#if (defined HAVE_CONFIG_H) && (!defined WIN32)
#include "config.h"
#endif
#include "DynamicDll.h"
#include "DllAvCodec.h"
#include "DllAvFormat.h"
#include "DllSwResample.h"
#include "utils/log.h"
extern "C" {
#ifndef HAVE_MMX
#define HAVE_MMX
#endif
#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#endif
#ifndef __GNUC__
#pragma warning(disable:4244)
#endif
#if (defined USE_EXTERNAL_FFMPEG)
#if (defined HAVE_LIBAVFILTER_AVFILTER_H)
#include <libavfilter/avfiltergraph.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/avcodec.h>
#elif (defined HAVE_FFMPEG_AVFILTER_H)
#include <ffmpeg/avfiltergraph.h>
#include <ffmpeg/buffersink.h>
#include <ffmpeg/avcodec.h>
#endif
#else
#include "libavfilter/avfiltergraph.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/avcodec.h"
#endif
}
#include "threads/SingleLock.h"
class DllAvFilterInterface
{
public:
virtual ~DllAvFilterInterface() {}
virtual int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)=0;
virtual void avfilter_free(AVFilterContext *filter)=0;
virtual void avfilter_graph_free(AVFilterGraph **graph)=0;
virtual int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)=0;
virtual AVFilter *avfilter_get_by_name(const char *name)=0;
virtual AVFilterGraph *avfilter_graph_alloc(void)=0;
virtual AVFilterInOut *avfilter_inout_alloc()=0;
virtual void avfilter_inout_free(AVFilterInOut **inout)=0;
virtual int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)=0;
virtual int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)=0;
virtual int avfilter_poll_frame(AVFilterLink *link)=0;
virtual int avfilter_request_frame(AVFilterLink *link)=0;
virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int flags)=0;
virtual AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)=0;
virtual void avfilter_unref_buffer(AVFilterBufferRef *ref)=0;
virtual int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)=0;
virtual int av_buffersink_get_buffer_ref(AVFilterContext *buffer_sink, AVFilterBufferRef **bufref, int flags)=0;
virtual AVBufferSinkParams *av_buffersink_params_alloc()=0;
virtual int av_buffersink_poll_frame(AVFilterContext *ctx)=0;
};
#if (defined USE_EXTERNAL_FFMPEG) || (defined TARGET_DARWIN)
// Use direct mapping
class DllAvFilter : public DllDynamic, DllAvFilterInterface
{
public:
virtual ~DllAvFilter() {}
virtual int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
{
CSingleLock lock(DllAvCodec::m_critSection);
return ::avfilter_open(filter_ctx, filter, inst_name);
}
virtual void avfilter_free(AVFilterContext *filter)
{
CSingleLock lock(DllAvCodec::m_critSection);
::avfilter_free(filter);
}
virtual void avfilter_graph_free(AVFilterGraph **graph)
{
CSingleLock lock(DllAvCodec::m_critSection);
::avfilter_graph_free(graph);
}
void avfilter_register_all()
{
CSingleLock lock(DllAvCodec::m_critSection);
::avfilter_register_all();
}
virtual int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx) { return ::avfilter_graph_create_filter(filt_ctx, filt, name, args, opaque, graph_ctx); }
virtual AVFilter *avfilter_get_by_name(const char *name) { return ::avfilter_get_by_name(name); }
virtual AVFilterGraph *avfilter_graph_alloc() { return ::avfilter_graph_alloc(); }
virtual AVFilterInOut *avfilter_inout_alloc()
{
CSingleLock lock(DllAvCodec::m_critSection);
return ::avfilter_inout_alloc();
}
virtual void avfilter_inout_free(AVFilterInOut **inout)
{
CSingleLock lock(DllAvCodec::m_critSection);
::avfilter_inout_free(inout);
}
virtual int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
{
CSingleLock lock(DllAvCodec::m_critSection);
return ::avfilter_graph_parse(graph, filters, inputs, outputs, log_ctx);
}
virtual int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
{
return ::avfilter_graph_config(graphctx, log_ctx);
}
virtual int avfilter_poll_frame(AVFilterLink *link) { return ::avfilter_poll_frame(link); }
virtual int avfilter_request_frame(AVFilterLink *link) { return ::avfilter_request_frame(link); }
virtual int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame, int flags) { return ::av_vsrc_buffer_add_frame(buffer_filter, frame, flags); }
virtual AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h) { return ::avfilter_get_video_buffer(link, perms, w, h); }
virtual void avfilter_unref_buffer(AVFilterBufferRef *ref) { ::avfilter_unref_buffer(ref); }
virtual int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad) { return ::avfilter_link(src, srcpad, dst, dstpad); }
virtual int av_buffersink_get_buffer_ref(AVFilterContext *buffer_sink, AVFilterBufferRef **bufref, int flags) { return ::av_buffersink_get_buffer_ref(buffer_sink, bufref, flags); }
virtual AVBufferSinkParams *av_buffersink_params_alloc() { return ::av_buffersink_params_alloc(); }
virtual int av_buffersink_poll_frame(AVFilterContext *ctx) { return ::av_buffersink_poll_frame(ctx); }
// DLL faking.
virtual bool ResolveExports() { return true; }
virtual bool Load() {
CLog::Log(LOGDEBUG, "DllAvFilter: Using libavfilter system library");
return true;
}
virtual void Unload() {}
};
#else
class DllAvFilter : public DllDynamic, DllAvFilterInterface
{
DECLARE_DLL_WRAPPER(DllAvFilter, DLL_PATH_LIBAVFILTER)
LOAD_SYMBOLS()
DEFINE_METHOD3(int, avfilter_open_dont_call, (AVFilterContext **p1, AVFilter *p2, const char *p3))
DEFINE_METHOD1(void, avfilter_free_dont_call, (AVFilterContext *p1))
DEFINE_METHOD1(void, avfilter_graph_free_dont_call, (AVFilterGraph **p1))
DEFINE_METHOD0(void, avfilter_register_all_dont_call)
DEFINE_METHOD6(int, avfilter_graph_create_filter, (AVFilterContext **p1, AVFilter *p2, const char *p3, const char *p4, void *p5, AVFilterGraph *p6))
DEFINE_METHOD1(AVFilter*, avfilter_get_by_name, (const char *p1))
DEFINE_METHOD0(AVFilterGraph*, avfilter_graph_alloc)
DEFINE_METHOD0(AVFilterInOut*, avfilter_inout_alloc_dont_call)
DEFINE_METHOD1(void, avfilter_inout_free_dont_call, (AVFilterInOut **p1))
DEFINE_FUNC_ALIGNED5(int, __cdecl, avfilter_graph_parse_dont_call, AVFilterGraph *, const char *, AVFilterInOut **, AVFilterInOut **, void *)
DEFINE_FUNC_ALIGNED2(int, __cdecl, avfilter_graph_config_dont_call, AVFilterGraph *, void *)
DEFINE_FUNC_ALIGNED1(int, __cdecl, avfilter_poll_frame, AVFilterLink *)
DEFINE_FUNC_ALIGNED1(int, __cdecl, avfilter_request_frame, AVFilterLink*)
DEFINE_METHOD3(int, av_vsrc_buffer_add_frame, (AVFilterContext *p1, AVFrame *p2, int p3))
DEFINE_METHOD4(AVFilterBufferRef*, avfilter_get_video_buffer, (AVFilterLink *p1, int p2, int p3, int p4))
DEFINE_METHOD1(void, avfilter_unref_buffer, (AVFilterBufferRef *p1))
DEFINE_METHOD4(int, avfilter_link, (AVFilterContext *p1, unsigned p2, AVFilterContext *p3, unsigned p4))
DEFINE_FUNC_ALIGNED3(int , __cdecl, av_buffersink_get_buffer_ref, AVFilterContext *, AVFilterBufferRef **, int);
DEFINE_FUNC_ALIGNED0(AVBufferSinkParams*, __cdecl, av_buffersink_params_alloc);
DEFINE_FUNC_ALIGNED1(int , __cdecl, av_buffersink_poll_frame, AVFilterContext *);
BEGIN_METHOD_RESOLVE()
RESOLVE_METHOD_RENAME(avfilter_open, avfilter_open_dont_call)
RESOLVE_METHOD_RENAME(avfilter_free, avfilter_free_dont_call)
RESOLVE_METHOD_RENAME(avfilter_graph_free, avfilter_graph_free_dont_call)
RESOLVE_METHOD_RENAME(avfilter_register_all, avfilter_register_all_dont_call)
RESOLVE_METHOD(avfilter_graph_create_filter)
RESOLVE_METHOD(avfilter_get_by_name)
RESOLVE_METHOD(avfilter_graph_alloc)
RESOLVE_METHOD_RENAME(avfilter_inout_alloc, avfilter_inout_alloc_dont_call)
RESOLVE_METHOD_RENAME(avfilter_inout_free, avfilter_inout_free_dont_call)
RESOLVE_METHOD_RENAME(avfilter_graph_parse, avfilter_graph_parse_dont_call)
RESOLVE_METHOD_RENAME(avfilter_graph_config, avfilter_graph_config_dont_call)
RESOLVE_METHOD(avfilter_poll_frame)
RESOLVE_METHOD(avfilter_request_frame)
RESOLVE_METHOD(av_vsrc_buffer_add_frame)
RESOLVE_METHOD(avfilter_get_video_buffer)
RESOLVE_METHOD(avfilter_unref_buffer)
RESOLVE_METHOD(avfilter_link)
RESOLVE_METHOD(av_buffersink_get_buffer_ref)
RESOLVE_METHOD(av_buffersink_params_alloc)
RESOLVE_METHOD(av_buffersink_poll_frame)
END_METHOD_RESOLVE()
/* dependencies of libavfilter */
DllAvUtil m_dllAvUtil;
DllSwResample m_dllSwResample;
DllAvFormat m_dllAvFormat;
public:
int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
{
CSingleLock lock(DllAvCodec::m_critSection);
return avfilter_open_dont_call(filter_ctx, filter, inst_name);
}
void avfilter_free(AVFilterContext *filter)
{
CSingleLock lock(DllAvCodec::m_critSection);
avfilter_free_dont_call(filter);
}
void avfilter_graph_free(AVFilterGraph **graph)
{
CSingleLock lock(DllAvCodec::m_critSection);
avfilter_graph_free_dont_call(graph);
}
void avfilter_register_all()
{
CSingleLock lock(DllAvCodec::m_critSection);
avfilter_register_all_dont_call();
}
AVFilterInOut* avfilter_inout_alloc()
{
CSingleLock lock(DllAvCodec::m_critSection);
return avfilter_inout_alloc_dont_call();
}
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs, void *log_ctx)
{
CSingleLock lock(DllAvCodec::m_critSection);
return avfilter_graph_parse_dont_call(graph, filters, inputs, outputs, log_ctx);
}
void avfilter_inout_free(AVFilterInOut **inout)
{
CSingleLock lock(DllAvCodec::m_critSection);
avfilter_inout_free_dont_call(inout);
}
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
{
CSingleLock lock(DllAvCodec::m_critSection);
return avfilter_graph_config_dont_call(graphctx, log_ctx);
}
virtual bool Load()
{
if (!m_dllAvUtil.Load())
return false;
if (!m_dllSwResample.Load())
return false;
if (!m_dllAvFormat.Load())
return false;
return DllDynamic::Load();
}
};
#endif
Jump to Line
Something went wrong with that request. Please try again.