static int test_autoloop_from_ratio(int dom, TCPair pair) { int ret = 0, code; TCPair mypair; ret = tc_code_from_ratio(dom, &code, pair.a, pair.b); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "from_ratio: failed conversion_from for " "ratio=%i/%i (dom=%i)", pair.a, pair.b, dom); return 2; } ret = tc_code_to_ratio(dom, code, &mypair.a, &mypair.b); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "from_ratio: failed conversion_to for " "ratio=%i/%i (dom=%i)", pair.a, pair.b, dom); return 1; } if (pair.a == mypair.a && pair.b == mypair.b) { tc_log_msg(PACKAGE, "from_ratio: test for ratio=%i/%i (dom=%i)" " -> OK", pair.a, pair.b, dom); } else { tc_log_warn(PACKAGE, "from_ratio: test for ratio=%i/%i (dom=%i)" " -> FAILED (%i/%i)", pair.a, pair.b, dom, mypair.a, mypair.b); ret = -1; } return ret; }
static int test_autoloop_to_ratio(int dom, int code) { int ret = 0, mycode; TCPair pair; ret = tc_code_to_ratio(dom, code, &pair.a, &pair.b); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "to_ratio: failed conversion_to for " "code=%i (dom=%i)", code, dom); return 1; } ret = tc_code_from_ratio(dom, &mycode, pair.a, pair.b); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "to_ratio: failed conversion_from for " "code=%i (dom=%i)", code, dom); return 2; } if (code == mycode) { tc_log_msg(PACKAGE, "to_ratio: test for code=%i (dom=%i) -> OK", code, dom); } else { tc_log_warn(PACKAGE, "to_ratio: test for code=%i (dom=%i) -> FAILED" " (%i)", code, dom, mycode); ret = -1; } return ret; }
static int modrequest_load(TCFactory factory, ModRequest *modr, const char *str) { size_t pieces = 0; if (factory == NULL || modr == NULL || str == NULL) { tc_log_warn(EXE, "wrong parameters for modrequest_load"); return TC_ERROR; } modr->rawdata = tc_strsplit(str, ':', &pieces); if (modr->rawdata == NULL || pieces != 2) { tc_log_warn(EXE, "malformed module string: %s", str); return TC_ERROR; } modr->type = modr->rawdata[0]; modr->name = modr->rawdata[1]; modr->module = tc_new_module(factory, modr->type, modr->name, TC_NONE); if (modr->module == NULL) { tc_log_warn(EXE, "failed creation of module: %s", str); return TC_ERROR; } return TC_OK; }
static int test_autoloop_to_fps(int frc) { int ret = 0, myfrc; double fps; ret = tc_frc_code_to_value(frc, &fps); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "to_fps: failed conversion_to for frc=%i", frc); return 1; } ret = tc_frc_code_from_value(&myfrc, fps); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "to_fps: failed conversion_from for frc=%i", frc); return 2; } if (frc == myfrc) { tc_log_msg(PACKAGE, "to_fps: test for frc=%i -> OK", frc); } else { tc_log_warn(PACKAGE, "to_fps: test for frc=%i -> FAILED (%i)", frc, myfrc); ret = -1; } return ret; }
static int test_autoloop_from_fps(double fps) { int ret = 0, frc; double myfps; ret = tc_frc_code_from_value(&frc, fps); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "from_fps: failed conversion_from for fps=%f", fps); return 1; } ret = tc_frc_code_to_value(frc, &myfps); if (ret == TC_NULL_MATCH) { tc_log_warn(PACKAGE, "from_fps: failed conversion_to for fps=%f", fps); return 2; } if (myfps - DELTA < fps && fps < myfps + DELTA) { tc_log_msg(PACKAGE, "from_fps: test for fps=%f -> OK", fps); } else { tc_log_warn(PACKAGE, "from_fps: test for fps=%f -> FAILED (%f)", fps, myfps); ret = -1; } return ret; }
int probe_source(const char *vid_file, const char *aud_file, int range, int flags, vob_t *vob) { ProbeInfo vinfo, ainfo; // video and audio info structures /* Probe the video file, if present */ if (vid_file) { if (!do_probe(vid_file, vob->nav_seek_file, vob->dvd_title, range, (flags & TC_PROBE_NO_BUILTIN), (verbose >= TC_DEBUG) ? verbose : 0, &vinfo) ) { if (verbose & TC_DEBUG) { tc_log_warn(PACKAGE, "(%s) failed to probe video source", __FILE__); } return 0; } } else { vob->has_video = 0; } /* Probe the audio file, if present */ if (aud_file) { if (!do_probe(aud_file, vob->nav_seek_file, vob->dvd_title, range, (flags & TC_PROBE_NO_BUILTIN), (verbose >= TC_DEBUG) ? verbose : 0, &ainfo) ) { if (verbose & TC_DEBUG) { tc_log_warn(PACKAGE, "(%s) failed to probe audio source", __FILE__); } return 0; } } /* else it might be contained in the video file */ /* Set global parameters based on probed data */ probe_to_vob(vid_file ? &vinfo : NULL, aud_file ? &ainfo : NULL, flags, vob); if (verbose & TC_DEBUG) { tc_log_info(PACKAGE, "(%s) V format=0x%lx, A format=0x%lx," " V codec=0x%lx, A codec=0x%lx", __FILE__, vob->v_format_flag, vob->a_format_flag, vob->v_codec_flag, vob->a_codec_flag); tc_log_info(PACKAGE, "(%s) V format=%s, A format=%s, V codec=%s," " A codec=%s", __FILE__, tc_format_to_comment(vob->v_format_flag), tc_format_to_comment(vob->a_format_flag), tc_codec_to_comment(vob->v_codec_flag), tc_codec_to_comment(vob->a_codec_flag)); } /* All done, return success */ return 1; }
static int divx5_init(const char *path) { const char *error; int *quiet_encore; tc_snprintf(module, sizeof(module), "%s/%s", path, MODULE); // try transcode's module directory handle = dlopen(module, RTLD_NOW); if (!handle) { //try the default: handle = dlopen(MODULE, RTLD_GLOBAL| RTLD_LAZY); if (!handle) { tc_log_warn(MOD_NAME, "%s", dlerror()); return(-1); } else { if(verbose_flag & TC_DEBUG) tc_log_info(MOD_NAME, "Loading external codec module %s", MODULE); } } else { if(verbose_flag & TC_DEBUG) tc_log_info(MOD_NAME, "Loading external codec module %s", module); } divx5_encore = dlsym(handle, "encore"); if ((error = dlerror()) != NULL) { tc_log_warn(MOD_NAME, "%s", error); return(-1); } quiet_encore=dlsym(handle, "quiet_encore"); if ((error = dlerror()) != NULL) { tc_log_warn(MOD_NAME, "%s", error); return(-1); } *quiet_encore=1; // debug if(verbose_flag & TC_STATS) *quiet_encore=0; return(0); }
static int parse_stream_header(FILE* stream, int width){ char cursor = 0; int aart_width = 0; /* Purge the first line of the header */ while (cursor!='\n') cursor = fgetc(stream); /* Purge additionnal commentary lines */ while (cursor == '#') while ((cursor = fgetc(stream)) != '\n'); cursor = fgetc(stream); /* Purge dimensions line */ while (cursor!=' '){ /* We have to check the width in case of re-size */ aart_width = 10*aart_width + ((int) cursor - 48); cursor = fgetc(stream); } if ((aart_width != width) && (verbose & TC_DEBUG)) tc_log_warn(MOD_NAME, "Picture has been re-sized by `aart`."); /* Purge the rest of the line */ while (cursor!='\n') cursor = fgetc(stream); cursor = fgetc(stream); /* Purge dynamic line */ while (cursor!='\n') cursor = fgetc(stream); return aart_width; }
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 tc_v4l2_video_get_frame(V4L2Source *vs, uint8_t *data, size_t size) { int ret; int buffers_filled = tc_v4l2_video_count_buffers(vs); if (buffers_filled == -1) { tc_log_warn(MOD_NAME, "unable to get the capture buffers count," " assuming OK"); buffers_filled = 0; } if (buffers_filled > (vs->buffers_count * 3 / 4)) { tc_log_error(MOD_NAME, "running out of capture buffers (%d left from %d total), " "stopping capture", vs->buffers_count - buffers_filled, vs->buffers_count); ret = tc_v4l2_capture_stop(vs); } else { ret = tc_v4l2_video_grab_frame(vs, data, size); vs->video_sequence++; } return ret; }
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; }
/* FIXME: explain why don't use funcpointers in here */ static void tc_x11source_acquire_cursor_plain(TCX11Source *handle, uint8_t *data, int maxdata) { static int warn = 0; if (!warn) { tc_log_warn(__FILE__, "cursor grabbing not supported!"); warn = 1; } }
int bktr_grab(size_t size, char *dest) { /* wait for a "buffer full" signal, but longer than 1 second */ alarm(1); sigsuspend(&sa_mask); alarm(0); if (bktr_frame_waiting) { bktr_frame_waiting = 0; if (dest) { if (verbose_flag & TC_DEBUG) { tc_log_info(MOD_NAME, "copying %lu bytes, buffer size is %lu", (unsigned long)size, (unsigned long)bktr_buffer_size); } switch (bktr_convert) { case BKTR2RGB: copy_buf_rgb(dest, size); break; case BKTR2YUV422: copy_buf_yuv422(dest, size); break; case BKTR2YUV: copy_buf_yuv(dest, size); break; default: tc_log_warn(MOD_NAME, "unrecognized video conversion request"); return(1); break; } } else { tc_log_warn(MOD_NAME, "no destination buffer to copy frames to"); return(1); } } else { /* bktr_frame_waiting */ tc_log_warn(MOD_NAME, "sigalrm"); } return(0); }
static int fields_configure(TCModuleInstance *self, const char *options, TCJob *vob, TCModuleExtraData *xdata[]) { FieldsPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "configure"); pd = self->userdata; // Some of the data in buffer may get used for half of the first frame (when // shifting) so make sure it's blank to start with. pd->buffer = tc_zalloc(SIZE_RGB_FRAME); if (!pd->buffer) { tc_log_error(MOD_NAME, "Unable to allocate memory. Aborting."); return TC_ERROR; } if (options != NULL) { if (optstr_lookup(options, "flip")) pd->field_ops |= FIELD_OP_FLIP; if (optstr_lookup(options, "shift")) pd->field_ops |= FIELD_OP_SHIFT; if (optstr_lookup(options, "flip_first")) pd->field_ops |= FIELD_OP_REVERSE; } // FIELD_OP_REVERSE (aka flip_first) only makes sense if we're doing // both operations. If we're not, unset it. if (pd->field_ops != FIELD_OP_FLIPSHIFT) pd->field_ops &= ~FIELD_OP_REVERSE; if (verbose) { if (pd->field_ops & FIELD_OP_SHIFT) tc_log_info(MOD_NAME, "Adjusting frame positions (shift)"); if (pd->field_ops & FIELD_OP_FLIP) tc_log_info(MOD_NAME, "Transposing input fields (flip)"); if (pd->field_ops & FIELD_OP_REVERSE) tc_log_info(MOD_NAME, "Flipping will occur before shifting (flip_first)"); } if (!pd->field_ops) { tc_log_warn(MOD_NAME, "No operations specified to perform."); return TC_ERROR; } if (vob->im_v_codec == TC_CODEC_RGB24); pd->rgb_mode = TC_TRUE; if (verbose) tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); return TC_OK; }
static int doublefps_configure(TCModuleInstance *self, const char *options, vob_t *vob) { DfpsPrivateData *pd; int new_topfirst = -1; TC_MODULE_SELF_CHECK(self, "configure"); pd = self->userdata; if (options) { if (optstr_get(options, "shiftEven", "%d", &pd->topfirst) == 1) { tc_log_warn(MOD_NAME, "The \"shiftEven\" option name is obsolete;" " please use \"topfirst\" instead."); } optstr_get(options, "topfirst", "%d", &new_topfirst); optstr_get(options, "fullheight", "%d", &pd->fullheight); } if (new_topfirst == -1) { if (pd->topfirst == -1) pd->topfirst = (vob->im_v_height == 480 ? 0 : 1); } else { pd->topfirst = new_topfirst; } if (!pd->fullheight) { if (vob->encode_fields == TC_ENCODE_FIELDS_TOP_FIRST || vob->encode_fields == TC_ENCODE_FIELDS_BOTTOM_FIRST ) { pd->topfirst = (vob->encode_fields == TC_ENCODE_FIELDS_TOP_FIRST); if (vob->export_attributes & TC_EXPORT_ATTRIBUTE_FIELDS) { tc_log_warn(MOD_NAME, "Use \"-J doublefps=topfirst=%d\"," " not \"--encode_fields %c\"", pd->topfirst, pd->topfirst ? 't' : 'b'); } } vob->encode_fields = TC_ENCODE_FIELDS_PROGRESSIVE; vob->export_attributes |= TC_EXPORT_ATTRIBUTE_FIELDS; } return TC_OK; }
static void enable_levels_filter(void) { int handle = 0, id = tc_filter_find("levels"); if (id == 0) { tc_log_info(MOD_NAME, "input is mjpeg, reducing range from YUVJ420P to YUV420P"); handle = tc_filter_add("levels", "output=16-240:pre=1"); if (!handle) { tc_log_warn(MOD_NAME, "cannot load levels filter"); } } }
static void copy_buf_yuv422(char *dest, size_t size) { uint8_t *planes; if (bktr_buffer_size != size) { tc_log_warn(MOD_NAME, "buffer sizes do not match (input %lu != output %lu)", (unsigned long)bktr_buffer_size, (unsigned long)size); } tcv_convert(bktr_tcvhandle, bktr_buffer, dest, size/2, 1, IMG_UYVY, IMG_YUV422P); }
static int yw_decode_audio(YWPrivateData *pd, transfer_t *param) { ssize_t r = wav_read_data(pd->wav, param->buffer, param->size); if (r <= 0 || (int)r < param->size) { if (verbose & TC_DEBUG) { tc_log_warn(MOD_NAME, "WAV audio read failed"); } return(TC_IMPORT_ERROR); } return(TC_IMPORT_OK); }
static int modrequest_fill(TCFactory factory, ModRequest *mods, size_t maxmods, size_t *modnum, glob_t *globbuf) { char modstr[TC_BUF_MIN]; int i = 0, count = 0, lim = 0; if (!factory || !mods || !globbuf) { return TC_ERROR; } if (maxmods < globbuf->gl_pathc) { tc_log_warn(EXE, "found %u candidate modules, but " "only %u allowed (dropping remaining)", (unsigned)globbuf->gl_pathc, (unsigned)maxmods); } lim = TC_MIN(maxmods, globbuf->gl_pathc); for (i = 0; i < lim; i++) { int ret; ret = parse_path(globbuf->gl_pathv[i], modstr, TC_BUF_MIN); if (ret != 0) { tc_log_warn(EXE, "error while parsing '%s', skipping", globbuf->gl_pathv[i]); continue; } ret = modrequest_load(factory, &mods[i], modstr); if (ret != 0) { tc_log_warn(EXE, "error while loading '%s', skipping", modstr); continue; } count++; } if (modnum != NULL) { *modnum += count; } return TC_OK; }
static void tc_x11source_acquire_cursor_fixes(TCX11Source *handle, uint8_t *data, int maxdata) { XFixesCursorImage *cursor = XFixesGetCursorImage(handle->dpy); if (cursor == NULL) { /* this MUST be noisy! */ tc_log_warn(__FILE__, "failed to get cursor image"); } else { /* FIXME: this has to be rewritten and need significant * internal refactoring :( */ } }
/** * probe_stream_data: Probe a single source file and store the stream * informations in data structure. * * Parameters: * file: File name to probe. * range: Amount of input file to probe, in MB. * info: Structure to be filled in with probed data. * Return value: * Nonzero on success, zero on error. * Preconditions: * info != NULL, range > 0 */ int probe_stream_data(const char *file, int range, ProbeInfo *info) { if (!info || range <= 0) { tc_log_error(PACKAGE, "wrong probing parameters"); return 0; } if (!file) { tc_log_warn(PACKAGE, "missing source to probe"); memset(info, 0, sizeof(ProbeInfo)); } else { if (!do_probe(file, NULL, 0, range, 0, (verbose >= TC_DEBUG) ? verbose : 0, info) ) { if (verbose & TC_DEBUG) { tc_log_warn(PACKAGE, "(%s) failed to probe stream '%s'", __FILE__, file); } return 0; } } return 1; }
static int modrequest_unload(TCFactory factory, ModRequest *modr) { if (factory == NULL || modr == NULL) { tc_log_warn(EXE, "wrong parameters for modrequest_load"); return TC_ERROR; } tc_del_module(factory, modr->module); tc_strfreev(modr->rawdata); /* re-blank fields */ modrequest_init(modr); return TC_OK; }
static int sendall(int sock, const void *buf, size_t count) { int total_sent = 0; if (sock < 0 || !buf || count < 0) { tc_log_warn(__FILE__, "sendall(): invalid parameters!"); errno = EINVAL; return -1; } while (count > 0) { int retval = send(sock, buf, count, 0); if (retval <= 0) { tc_log_warn(__FILE__, "sendall(): socket write failed (%s)", retval<0 ? strerror(errno) : "Connection closed"); if (total_sent == 0) return -1; /* Nothing sent yet, abort with error return */ break; } total_sent += retval; buf = (int8_t *)buf + retval; count -= retval; } return total_sent; }
static void copy_buf_rgb(char *dest, size_t size) { int i; /* 24 bit RGB packed into 32 bits (NULL, R, G, B) */ if ((bktr_buffer_size * 3 / 4) != size) tc_log_warn(MOD_NAME, "buffer sizes do not match (input %lu != output %lu)", (unsigned long)bktr_buffer_size * 3 / 4, (unsigned long)size); /* bktr_buffer_size was set to width * height * 4 (32 bits) */ /* so width * height = bktr_buffer_size / 4 */ tcv_convert(bktr_buffer, dest, bktr_buffer_size/4, 1, IMG_ARGB32, IMG_RGB24); }
static int yw_decode_video(YWPrivateData *pd, transfer_t *param) { int errnum = 0; YUV_INIT_PLANES(pd->planes, param->buffer, pd->dstfmt, pd->width, pd->height); errnum = y4m_read_frame(pd->fd_vid, &pd->streaminfo, &pd->frameinfo, pd->planes); if (errnum != Y4M_OK) { if (verbose & TC_DEBUG) { tc_log_warn(MOD_NAME, "YUV4MPEG2 video read failed: %s", y4m_strerr(errnum)); } return(TC_IMPORT_ERROR); } return(TC_IMPORT_OK); }
static void copy_buf_yuv(char *dest, size_t size) { int y_size = bktr_buffer_size * 4 / 6; int u_size = bktr_buffer_size * 1 / 6; int y_offset = 0; int u1_offset = y_size + 0; int u2_offset = y_size + u_size; if (bktr_buffer_size != size) tc_log_warn(MOD_NAME, "buffer sizes do not match (input %lu != output %lu)", (unsigned long)bktr_buffer_size, (unsigned long)size); ac_memcpy(dest + y_offset, bktr_buffer + y_offset, y_size); ac_memcpy(dest + u1_offset, bktr_buffer + u1_offset, u_size); ac_memcpy(dest + u2_offset, bktr_buffer + u2_offset, u_size); }
static int astat_stop(TCModuleInstance *self) { int ret = TC_OK; /* optimistism... */ AStatPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "stop"); pd = self->userdata; /* stats summary */ if (pd->min >= pd->silence_limit && pd->max <= pd->silence_limit) { tc_log_info(MOD_NAME, "audio track seems only silence"); } else if (pd->min == 0 || pd->max == 0) { tc_log_warn(MOD_NAME, "bad minimum/maximum value," " unable to find scale value"); ret = TC_ERROR; } else { double fmin = -((double) pd->min)/TCA_S16LE_MAX; double fmax = ((double) pd->max)/TCA_S16LE_MAX; /* FIXME: constantize in libtcaudio */ double vol = (fmin < fmax) ? 1./fmax : 1./fmin; if (pd->filepath == NULL) { tc_log_info(MOD_NAME, "(min=%.3f/max=%.3f), " "normalize volume with \"-s %.3f\"", -fmin, fmax, vol); } else { FILE *fh = fopen(pd->filepath, "w"); if (fh == NULL) { tc_log_perror(MOD_NAME, "unable to open scale value file"); ret = TC_ERROR; } else { fprintf(fh, "%.3f\n", vol); fclose(fh); // XXX if (verbose) { tc_log_info(MOD_NAME, "wrote audio scale value to '%s'", pd->filepath); } } tc_free(pd->filepath); pd->filepath = NULL; } } return TC_OK; }
static int tc_v4l2_video_setup_stream_parameters(V4L2Source *vs, int fps) { struct v4l2_streamparm streamparm; int err = 0; memset(&streamparm, 0, sizeof(streamparm)); streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; streamparm.parm.capture.capturemode = 0; streamparm.parm.capture.timeperframe.numerator = 1e7; streamparm.parm.capture.timeperframe.denominator = fps; err = v4l2_ioctl(vs->video_fd, VIDIOC_S_PARM, &streamparm); if (err < 0) { tc_log_warn(MOD_NAME, "driver does not support setting parameters" " (ioctl(VIDIOC_S_PARM) returns \"%s\")", errno <= sys_nerr ? sys_errlist[errno] : "unknown"); } return TC_OK; }
static int tc_import_video_close(TCImportData *imdata) { int ret; transfer_t import_para; memset(&import_para, 0, sizeof(transfer_t)); import_para.flag = TC_VIDEO; import_para.fd = imdata->fd; ret = tcv_import(TC_IMPORT_CLOSE, &import_para, NULL); if (ret == TC_IMPORT_ERROR) { tc_log_warn(PACKAGE, "video import module error: CLOSE failed"); return TC_ERROR; } imdata->fd = NULL; return TC_OK; }
int tc_mangle_cmdline(int *argc, char ***argv, const char *opt, const char **optval) { int i = 0, skew = (optval == NULL) ?1 :2, err = -1; if (argc == NULL || argv == NULL || opt == NULL) { return err; } err = 1; /* first we looking for our option (and it's value) */ for (i = 1; i < *argc; i++) { if ((*argv)[i] && strcmp((*argv)[i], opt) == 0) { if (optval == NULL) { err = 0; /* we're set */ } else { /* don't peek after the end... */ if (i + 1 >= *argc || (*argv)[i + 1][0] == '-') { tc_log_warn(__FILE__, "wrong usage for option '%s'", opt); err = 1; /* no option and/or value found */ } else { *optval = (*argv)[i + 1]; err = 0; } } break; } } /* * if we've found our option, now we must shift back all * the other options after the ours and we must also update argc. */ if (!err) { for (; i < (*argc - skew); i++) { (*argv)[i] = (*argv)[i + skew]; } (*argc) -= skew; } return err; }