static int raw_stop(TCModuleInstance *self)
{
RawPrivateData *pd = NULL;
int verr, aerr;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
if (pd->fd_vid != -1) {
verr = close(pd->fd_vid);
if (verr) {
tc_log_error(MOD_NAME, "closing video file: %s",
strerror(errno));
return TC_ERROR;
}
pd->fd_vid = -1;
}
if (pd->fd_aud != -1) {
aerr = close(pd->fd_aud);
if (aerr) {
tc_log_error(MOD_NAME, "closing audio file: %s",
strerror(errno));
return TC_ERROR;
}
pd->fd_aud = -1;
}
return TC_OK;
}
static int raw_multiplex(TCModuleInstance *self,
vframe_list_t *vframe, aframe_list_t *aframe)
{
ssize_t w_aud = 0, w_vid = 0;
RawPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "multiplex");
pd = self->userdata;
if (vframe != NULL && vframe->video_len > 0) {
w_vid = tc_pwrite(pd->fd_vid, vframe->video_buf, vframe->video_len);
if(w_vid < 0) {
return TC_ERROR;
}
}
if (aframe != NULL && aframe->audio_len > 0) {
w_aud = tc_pwrite(pd->fd_aud, aframe->audio_buf, aframe->audio_len);
if (w_aud < 0) {
return TC_ERROR;
}
}
return (int)(w_vid + w_aud);
}
static int deshake_init(TCModuleInstance *self, uint32_t features)
{
DeshakeData* sd = NULL;
TC_MODULE_SELF_CHECK(self, "init");
TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features);
sd = tc_zalloc(sizeof(DeshakeData)); // allocation with zero values
if (!sd) {
if (verbose > TC_INFO)
tc_log_error(MOD_NAME, "init: out of memory!");
return TC_ERROR;
}
sd->vob = tc_get_vob();
if (!sd->vob)
return TC_ERROR;
/**** Initialise private data structure */
self->userdata = sd;
if (verbose & TC_INFO){
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
}
return TC_OK;
}
static int sdlview_init(TCModuleInstance *self, uint32_t features)
{
int err = 0;
SDLPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "init");
TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features);
err = SDL_Init(SDL_INIT_VIDEO);
if (err) {
tc_log_error(MOD_NAME, "SDL initialization failed: %s", SDL_GetError());
return TC_ERROR;
}
pd = tc_malloc(sizeof(SDLPrivateData));
if (pd == NULL) {
tc_log_error(MOD_NAME, "init: out of memory!");
return TC_ERROR;
}
pd->surface = NULL;
pd->overlay = NULL;
pd->w = 0;
pd->h = 0;
self->userdata = pd;
if (verbose) {
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
}
return TC_OK;
}
static int yw_stop(TCModuleInstance *self)
{
YWPrivateData *pd = NULL;
int verr, aerr;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
if (pd->fd_vid != -1) {
verr = close(pd->fd_vid);
if (verr) {
tc_log_error(MOD_NAME, "closing video file: %s",
strerror(errno));
return TC_ERROR;
}
y4m_fini_frame_info(&pd->frameinfo);
y4m_fini_stream_info(&(pd->streaminfo));
pd->fd_vid = -1;
}
if (pd->wav != NULL) {
aerr = wav_close(pd->wav);
if (aerr != 0) {
tc_log_error(MOD_NAME, "closing audio file: %s",
wav_strerror(wav_last_error(pd->wav)));
return TC_ERROR;
}
pd->wav = NULL;
}
return TC_OK;
}
static int tc_y4m_multiplex(TCModuleInstance *self,
vframe_list_t *vframe, aframe_list_t *aframe)
{
ssize_t w_vid = 0;
Y4MPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "multiplex");
pd = self->userdata;
if (vframe != NULL && vframe->video_len > 0) {
uint8_t *planes[3] = { NULL, NULL, NULL };
int ret = 0;
y4m_init_frame_info(&pd->frameinfo);
YUV_INIT_PLANES(planes, vframe->video_buf, IMG_YUV420P,
pd->width, pd->height);
ret = y4m_write_frame(pd->fd_vid, &(pd->streaminfo),
&pd->frameinfo, planes);
if (ret != Y4M_OK) {
tc_log_warn(MOD_NAME, "error while writing video frame: %s",
y4m_strerr(ret));
return TC_ERROR;
}
w_vid = vframe->video_len;
}
if (aframe != NULL && aframe->audio_len > 0) {
return TC_OK;
}
return (int)w_vid;
}
static int logo_inspect(TCModuleInstance *self,
const char *param, const char **value)
{
LogoPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "inspect");
TC_MODULE_SELF_CHECK(param, "inspect");
pd = self->userdata;
if (optstr_lookup(param, "help")) {
*value = logo_help;
}
return TC_OK;
}
static int null_configure(TCModuleInstance *self,
const char *options, vob_t *vob)
{
TC_MODULE_SELF_CHECK(self, "configure");
return TC_OK;
}
static int faac_init(TCModuleInstance *self, uint32_t features)
{
PrivateData *pd;
TC_MODULE_SELF_CHECK(self, "init");
TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features);
self->userdata = pd = tc_malloc(sizeof(PrivateData));
if (!pd) {
tc_log_error(MOD_NAME, "init: out of memory!");
return TC_ERROR;
}
pd->handle = 0;
pd->audiobuf = NULL;
pd->need_flush = TC_FALSE;
/* FIXME: shouldn't this test a specific flag? */
if (verbose) {
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
if (verbose >= TC_INFO) {
char *id, *copyright;
faacEncGetVersion(&id, ©right);
tc_log_info(MOD_NAME, "Using FAAC %s", id);
}
}
return TC_OK;
}
static int tc_y4m_init(TCModuleInstance *self, uint32_t features)
{
Y4MPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "init");
TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features);
pd = tc_malloc(sizeof(Y4MPrivateData));
if (pd == NULL) {
return TC_ERROR;
}
pd->width = 0;
pd->height = 0;
pd->fd_vid = -1;
y4m_init_stream_info(&(pd->streaminfo));
/* frameinfo will be initialized at each multiplex call */
if (verbose) {
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
}
self->userdata = pd;
return TC_OK;
}
static int null_encode_video(TCModuleInstance *self,
vframe_list_t *inframe, vframe_list_t *outframe)
{
TC_MODULE_SELF_CHECK(self, "encode_video");
outframe->video_len = 0;
return TC_OK;
}
static int vag_fini(TCModuleInstance *self)
{
TC_MODULE_SELF_CHECK(self, "fini");
tc_free(self->userdata);
self->userdata = NULL;
return TC_OK;
}
static int sdlview_process(TCModuleInstance *self, frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
if (frame->tag & TC_PREVIEW && frame->tag & TC_VIDEO) {
return sdlview_filter_video(self, (vframe_list_t *)frame);
}
return TC_OK;
}
/**
* transform_fini: Clean up after this instance of the module. See
* tcmodule-data.h for function details.
*/
static int transform_fini(TCModuleInstance *self)
{
FilterData *fd = NULL;
TC_MODULE_SELF_CHECK(self, "fini");
fd = self->userdata;
tc_free(fd);
self->userdata = NULL;
return TC_OK;
}
static int template_process(TCModuleInstance *self,
frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
/* choose what to do by frame->tag */
return TC_OK;
}
static int template_inspect(TCModuleInstance *self,
const char *param, const char **value)
{
PrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "inspect");
TC_MODULE_SELF_CHECK(param, "inspect");
TC_MODULE_SELF_CHECK(value, "inspect");
pd = self->userdata;
if (optstr_lookup(param, "help")) {
*value = help_string;
}
/* put back configurable options */
return TC_OK;
}
static int null_configure(TCModuleInstance *self,
const char *options,
TCJob *vob,
TCModuleExtraData *xdata[])
{
TC_MODULE_SELF_CHECK(self, "configure");
return TC_OK;
}
static int faac_inspect(TCModuleInstance *self,
const char *param, const char **value)
{
static char buf[TC_BUF_MAX];
TC_MODULE_SELF_CHECK(self, "inspect");
TC_MODULE_SELF_CHECK(param, "inspect");
if (optstr_lookup(param, "help")) {
tc_snprintf(buf, sizeof(buf),
"Overview:\n"
" Encodes audio to AAC using the FAAC library.\n"
"Options:\n"
" quality: set encoder quality [0-100]\n");
*value = buf;
}
return TC_OK;
}
static int tc_x11_configure(TCModuleInstance *self,
const char *options, vob_t *vob)
{
TCX11PrivateData *priv = NULL;
int ret = 0, skew_lim = SKEW_LIM_DEFAULT;
TC_MODULE_SELF_CHECK(self, "configure");
priv = self->userdata;
if (options != NULL) {
optstr_get(options, "skew_limit", "%i", &skew_lim);
if (skew_lim < SKEW_LIM_MIN || skew_lim > SKEW_LIM_MAX) {
tc_log_warn(MOD_NAME, "skew limit value out of range,"
" reset to defaults [%i]",
SKEW_LIM_DEFAULT);
}
}
priv->skew = 0;
priv->reftime = 0;
priv->expired = 0;
priv->frame_delay = (uint64_t)(1000000.0 / vob->fps); /* microseconds */
priv->skew_limit = priv->frame_delay / frame_delay_divs[skew_lim];
if (verbose >= TC_DEBUG) {
tc_log_info(MOD_NAME, "frame delay: %lu ms",
(unsigned long)priv->frame_delay);
tc_log_info(MOD_NAME, "skew limit: %li ms",
(long)priv->skew_limit);
}
ret = tc_timer_init_soft(&priv->timer, 0);
if (ret != 0) {
tc_log_error(MOD_NAME, "configure: can't initialize timer");
return TC_ERROR;
}
/* nothing to do here, yet */
ret = tc_x11source_is_display_name(vob->video_in_file);
if (ret == TC_FALSE) {
tc_log_error(MOD_NAME, "configure: given source doesn't look like"
" a DISPLAY specifier");
return TC_ERROR;
}
ret = tc_x11source_open(&priv->src, vob->video_in_file,
TC_X11_MODE_BEST, vob->im_v_codec);
if (ret != 0) {
tc_log_error(MOD_NAME, "configure: failed to open X11 connection"
" to '%s'", vob->video_in_file);
return TC_ERROR;
}
return TC_OK;
}
static int transform_process(TCModuleInstance *self, frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
if (frame->tag & TC_PRE_S_PROCESS && frame->tag & TC_VIDEO) {
return transform_filter_video(self, (vframe_list_t *)frame);
}
return TC_OK;
}
static int lowpass_process(TCModuleInstance *self, frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
if (frame->tag & TC_PRE_S_PROCESS && frame->tag & TC_AUDIO) {
return lowpass_filter_audio(self, (aframe_list_t*)frame);
}
return TC_OK;
}
static int transform_get_config(TCModuleInstance *self, char *options)
{
TC_MODULE_SELF_CHECK(self, "get_config");
optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION,
MOD_AUTHOR, "VRY4", "1");
return TC_OK;
}
METHOD int pvn_fini(TCModuleInstance *self)
{
TC_MODULE_SELF_CHECK(self, "fini");
pvn_stop(self);
tc_free(self->userdata);
self->userdata = NULL;
return TC_OK;
}
static int doublefps_stop(TCModuleInstance *self)
{
DfpsPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
pd->have_first_frame = pd->saved_width = pd->saved_height = 0;
return TC_OK;
}
/*
* deshake_fini: Clean up after this instance of the module. See
* tcmodule-data.h for function details.
*/
static int deshake_fini(TCModuleInstance *self)
{
DeshakeData *sd = NULL;
TC_MODULE_SELF_CHECK(self, "fini");
sd = self->userdata;
tc_free(sd);
self->userdata = NULL;
return TC_OK;
}
static int deshake_filter_video(TCModuleInstance *self,
vframe_list_t *frame)
{
DeshakeData *sd = NULL;
TC_MODULE_SELF_CHECK(self, "filter_video");
TC_MODULE_SELF_CHECK(frame, "filter_video");
sd = self->userdata;
MotionDetect* md = &(sd->md);
TransformData* td = &(sd->td);
LocalMotions localmotions;
Transform motion;
VSFrame vsFrame;
fillFrameFromBuffer(&vsFrame,frame->video_buf, &td->fiSrc);
if(motionDetection(md, &localmotions, &vsFrame)!= VS_OK){
tc_log_error(MOD_NAME, "motion detection failed");
return TC_ERROR;
}
if(writeToFile(md, sd->f, &localmotions) != VS_OK)
motion = simpleMotionsToTransform(td, &localmotions);
vs_vector_del(&localmotions);
transformPrepare(td, &vsFrame, &vsFrame);
Transform t = lowPassTransforms(td, &sd->avg, &motion);
/* tc_log_error(MOD_NAME, "Trans: det: %f %f %f \n\t\t act: %f %f %f %f", */
/* motion.x, motion.y, motion.alpha, */
/* t.x, t.y, t.alpha, t.zoom); */
if (sd->vob->im_v_codec == CODEC_RGB) {
transformRGB(td, t);
} else if (sd->vob->im_v_codec == CODEC_YUV) {
transformYUV(td, t);
} else {
tc_log_error(MOD_NAME, "unsupported Codec: %i\n", sd->vob->im_v_codec);
return TC_ERROR;
}
transformFinish(td);
return TC_OK;
}
static int tc_im_stop(TCModuleInstance *self)
{
TCIMPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
return tc_magick_fini(&pd->magick);
}
static int deshake_process(TCModuleInstance *self, frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
// if (frame->tag & TC_PRE_S_PROCESS && frame->tag & TC_VIDEO) {
if (frame->tag & TC_POST_S_PROCESS && frame->tag & TC_VIDEO) {
return deshake_filter_video(self, (vframe_list_t *)frame);
}
return TC_OK;
}
static int astat_process(TCModuleInstance *self, frame_list_t *frame)
{
TC_MODULE_SELF_CHECK(self, "process");
if (frame->tag & TC_PRE_S_PROCESS && frame->tag & TC_AUDIO
&& !(frame->attributes & TC_FRAME_IS_SKIPPED)) {
return astat_filter_audio(self, (aframe_list_t*)frame);
}
return TC_OK;
}
/**
* transform_stop: Reset this instance of the module. See tcmodule-data.h
* for function details.
*/
static int transform_stop(TCModuleInstance *self)
{
FilterData *fd = NULL;
TC_MODULE_SELF_CHECK(self, "stop");
fd = self->userdata;
vsTransformDataCleanup(&fd->td);
vsTransformationsCleanup(&fd->trans);
return TC_OK;
}
