自学教程：C++ tc_log_error函数代码示例

static int probe_matches(const ProbeInfo *ref, const ProbeInfo *cand, int i){    if (ref->width  != cand->width || ref->height != cand->height     || ref->frc    != cand->frc   || ref->asr    != cand->asr     || ref->codec  != cand->codec) {        tc_log_error(__FILE__, "video parameters mismatch");        dump_probeinfo(ref,  -1, "old");        dump_probeinfo(cand, -1, "new");        return 0;    }    if (i > ref->num_tracks || i > cand->num_tracks) {        tc_log_error(__FILE__,                     "track parameters mismatch (i=%i|ref=%i|cand=%i)",                     i, ref->num_tracks, cand->num_tracks);        return 0;    }    if (ref->track[i].samplerate != cand->track[i].samplerate     || ref->track[i].chan       != cand->track[i].chan      ) {//     || ref->track[i].bits       != cand->track[i].bits      ) { //     || ref->track[i].format     != cand->track[i].format    ) { XXX XXX XXX        tc_log_error(__FILE__, "audio parameters mismatch");        dump_probeinfo(ref,  i, "old");        dump_probeinfo(cand, i, "new");        return 0;    }           return 1;}

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 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 tc_x11_stop(TCModuleInstance *self){    TCX11PrivateData *priv = NULL;    int ret = 0;    TC_MODULE_SELF_CHECK(self, "stop");    priv = self->userdata;    ret = tc_x11source_close(&priv->src);    if (ret != 0) {        tc_log_error(MOD_NAME, "stop: failed to close X11 connection");        return TC_ERROR;    }    ret = tc_timer_fini(&priv->timer);    if (ret != 0) {        tc_log_error(MOD_NAME, "stop: failed to stop timer");        return TC_ERROR;    }    if (verbose >= TC_DEBUG) {        tc_log_info(MOD_NAME, "expired frames count: %lu",                              (unsigned long)priv->expired);    }    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;}

void probe_ffmpeg(info_t *ipipe){    /* to be completed */    AVFormatContext *lavf_dmx_context = NULL;    int ret = 0;    close(ipipe->fd_in);    TC_INIT_LIBAVCODEC;    ret = av_open_input_file(&lavf_dmx_context, ipipe->name,                             NULL, 0, NULL);    if (ret != 0) {        tc_log_error(__FILE__, "unable to open '%s'"                               " (libavformat failure)",                     ipipe->name);        ipipe->error = 1;        return;    }    ret = av_find_stream_info(lavf_dmx_context);    if (ret < 0) {        tc_log_error(__FILE__, "unable to fetch informations from '%s'"                               " (libavformat failure)",                     ipipe->name);        ipipe->error = 1;        return;    }    translate_info(lavf_dmx_context, ipipe->probe_info);    av_close_input_file(lavf_dmx_context);    return;}

static int tc_v4l2_video_check_capabilities(V4L2Source *vs){    struct v4l2_capability caps;    int err = 0;    err = v4l2_ioctl(vs->video_fd, VIDIOC_QUERYCAP, &caps);    if (err < 0) {        tc_log_error(MOD_NAME, "driver does not support querying capabilities");        return TC_ERROR;    }    if (!(caps.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {        tc_log_error(MOD_NAME, "driver does not support video capture");        return TC_ERROR;    }    if (!(caps.capabilities & V4L2_CAP_STREAMING)) {        tc_log_error(MOD_NAME, "driver does not support streaming (mmap) video capture");        return TC_ERROR;    }    if (verbose_flag > TC_INFO) {        tc_log_info(MOD_NAME, "v4l2 video grabbing, driver = %s, device = %s",                    caps.driver, caps.card);    }    return TC_OK;}

static int write_tmpfile(char* header, char* content, int content_size, int slot_id){	FILE* 	tmp = NULL;	int 	i = 0;	char*	filename = NULL;	filename = tc_malloc(sizeof(char)*(strlen(TMP_FILE) + TMP_STRING_SIZE));	if (!filename){		tc_log_error(MOD_NAME, "Out of memory !!!");		return -1;	}	if (verbose & TC_DEBUG)		tc_log_info(MOD_NAME, "Temporary filename correctly allocated.");	tc_snprintf(filename, strlen(TMP_FILE) + TMP_STRING_SIZE, "%s-%d.tmp", TMP_FILE, slot_id);	tmp = fopen(filename, "w");	if (!tmp){		tc_log_error(MOD_NAME, "Cannot write temporary file !");		return -1;	}	for(i=0; i<strlen(header); i++)		fputc(header[i], tmp);	for(i=0; i< content_size; i++)		fputc(content[i], tmp);	fclose(tmp);	free(filename);	return 0;}

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 tc_x11source_init_shm(TCX11Source *handle){    Status ret;    ret = XMatchVisualInfo(handle->dpy, handle->screen, handle->depth,                           DirectColor, &handle->vis_info);    if (!ret) {        tc_log_error(__FILE__, "Can't match visual information");        goto xshm_failed;    }    handle->image = XShmCreateImage(handle->dpy, handle->vis_info.visual,                                    handle->depth, ZPixmap,                                    NULL, &handle->shm_info,                                    handle->width, handle->height);    if (handle->image == NULL) {        tc_log_error(__FILE__, "XShmCreateImage failed.");        goto xshm_failed_image;    }    handle->shm_info.shmid = shmget(IPC_PRIVATE,                                    handle->image->bytes_per_line * handle->image->height,                                    IPC_CREAT | 0777);    if (handle->shm_info.shmid < 0) {        tc_log_error(__FILE__, "failed to create shared memory segment");        goto xshm_failed_image;    }    handle->shm_info.shmaddr = shmat(handle->shm_info.shmid, NULL, 0);    if (handle->shm_info.shmaddr == (void*)-1) {        tc_log_error(__FILE__, "failed to attach shared memory segment");        goto xshm_failed_image;    }        shmctl(handle->shm_info.shmid, IPC_RMID, 0); /* XXX */    handle->image->data = handle->shm_info.shmaddr;    handle->shm_info.readOnly = False;    ret = XShmAttach(handle->dpy, &handle->shm_info);    if (!ret) {        tc_log_error(__FILE__, "failed to attach SHM to Xserver");        goto xshm_failed_image;    }    XSync(handle->dpy, False);    handle->mode = TC_X11_MODE_SHM;    handle->acquire_image = tc_x11source_acquire_image_shm;    handle->fini = tc_x11source_fini_shm;    return 0;xshm_failed_image:    XDestroyImage(handle->image);    handle->image = NULL;xshm_failed:    return -1;}

static int tc_im_configure(TCModuleInstance *self,                          const char *options,                          vob_t *vob,                          TCModuleExtraData *xdata[]){    TCCodecID id = TC_CODEC_ERROR;    TCIMPrivateData *pd = NULL;    int ret = 0;    TC_MODULE_SELF_CHECK(self, "configure");    pd = self->userdata;    pd->quality = DEFAULT_QUALITY;    pd->width   = vob->ex_v_width;    pd->height  = vob->ex_v_height;    pd->img_fmt[0] = '/0';    ret = optstr_get(options, "format", "%15s", pd->img_fmt);    if (ret != 1) {        /* missing option, let's use the default */        strlcpy(pd->img_fmt, DEFAULT_FORMAT, sizeof(pd->img_fmt));    } else {        /* the user gave us something */        id = tc_codec_from_string(pd->img_fmt);        if (id == TC_CODEC_ERROR) {            tc_log_error(MOD_NAME, "unknown format: `%s'", pd->img_fmt);            return TC_ERROR;        }        if (!is_supported(id)) {            tc_log_error(MOD_NAME, "unsupported format: `%s'", pd->img_fmt);            return TC_ERROR;        }    }        ret = optstr_get(options, "quality", "%lu", &pd->quality);    if (ret != 1) {        pd->quality = DEFAULT_QUALITY;    }    if (verbose >= TC_INFO) {        tc_log_info(MOD_NAME, "encoding %s with quality %lu",                    pd->img_fmt, pd->quality);    }    ret = tc_magick_init(&pd->magick, pd->quality);    if (ret != TC_OK) {        tc_log_error(MOD_NAME, "cannot create Magick context");        return ret;    }    return TC_OK;}

static int raw_configure(TCModuleInstance *self,                         const char *options, vob_t *vob){    char vid_name[PATH_MAX];    char aud_name[PATH_MAX];    RawPrivateData *pd = NULL;    TC_MODULE_SELF_CHECK(self, "configure");    pd = self->userdata;    // XXX    if (vob->audio_out_file == NULL      || !strcmp(vob->audio_out_file, "/dev/null")) {        /* use affine names */        tc_snprintf(vid_name, PATH_MAX, "%s.%s",                    vob->video_out_file, RAW_VID_EXT);        tc_snprintf(aud_name, PATH_MAX, "%s.%s",                    vob->video_out_file, RAW_AUD_EXT);    } else {        /* copy names verbatim */        strlcpy(vid_name, vob->video_out_file, PATH_MAX);        strlcpy(aud_name, vob->audio_out_file, PATH_MAX);    }        /* avoid fd loss in case of failed configuration */    if (pd->fd_vid == -1) {        pd->fd_vid = open(vid_name,                          O_RDWR|O_CREAT|O_TRUNC,                          S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);        if (pd->fd_vid == -1) {            tc_log_error(MOD_NAME, "failed to open video stream file");            return TC_ERROR;        }    }    /* avoid fd loss in case of failed configuration */    if (pd->fd_aud == -1) {        pd->fd_aud = open(aud_name,                          O_RDWR|O_CREAT|O_TRUNC,                          S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);        if (pd->fd_aud == -1) {            tc_log_error(MOD_NAME, "failed to open audio stream file");            return TC_ERROR;        }    }    if (vob->verbose >= TC_DEBUG) {        tc_log_info(MOD_NAME, "video output: %s (%s)",                    vid_name, (pd->fd_vid == -1) ?"FAILED" :"OK");        tc_log_info(MOD_NAME, "audio output: %s (%s)",                    aud_name, (pd->fd_aud == -1) ?"FAILED" :"OK");    }    return TC_OK;}

static int tc_v4l2_video_setup_image_format(V4L2Source *vs, int width, int height){    int err = 0;    vs->width  = width;    vs->height = height;    vs->v4l_convert = v4lconvert_create(vs->video_fd);    if (!vs->v4l_convert) {        return TC_ERROR;    }    memset(&(vs->v4l_dst_fmt), 0, sizeof(vs->v4l_dst_fmt));    vs->v4l_dst_fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;    vs->v4l_dst_fmt.fmt.pix.width       = width;    vs->v4l_dst_fmt.fmt.pix.height      = height;    vs->v4l_dst_fmt.fmt.pix.pixelformat = vs->v4l_dst_csp;	    err = v4lconvert_try_format(vs->v4l_convert,                                &(vs->v4l_dst_fmt), &(vs->v4l_src_fmt));    if (err) {        tc_log_error(MOD_NAME, "unable to match formats: %s",                     v4lconvert_get_error_message(vs->v4l_convert));        return TC_ERROR;    }    err = v4l2_ioctl(vs->video_fd, VIDIOC_S_FMT, &(vs->v4l_src_fmt));    if (err < 0) {        tc_log_error(MOD_NAME, "error while setting the cam image format");        return TC_ERROR;                }    if (!v4lconvert_needs_conversion(vs->v4l_convert,                                    &(vs->v4l_src_fmt),                                    &(vs->v4l_dst_fmt))) {        tc_log_info(MOD_NAME, "fetch frames directly");        vs->fetch_data = tc_v4l2_fetch_data_memcpy;        /* Into the near future we should aim for zero-copy. -- FR */    } else {        char src_fcc[5] = { '/0' };        char dst_fcc[5] = { '/0' };        pixfmt_to_fourcc(vs->v4l_src_fmt.fmt.pix.pixelformat, src_fcc);        pixfmt_to_fourcc(vs->v4l_dst_fmt.fmt.pix.pixelformat, dst_fcc);        tc_log_info(MOD_NAME, "fetch frames using libv4lconvert "                              "[%s] -> [%s]",                              src_fcc, dst_fcc);        vs->fetch_data = tc_v4l2_fetch_data_v4lconv;    }    return TC_OK;}

int tc_socket_init(const char *socket_path_){    struct sockaddr_un server_addr;    client_sock = -1;    server_sock = -1;    tc_mutex_init(&tc_socket_msg_lock);    if (tc_snprintf(socket_path, sizeof(socket_path), "%s", socket_path_) < 0){        tc_log_error(__FILE__, "Socket pathname too long (1)");        *socket_path = 0;        return 0;    }    errno = 0;    if (unlink(socket_path) != 0 && errno != ENOENT) {        tc_log_error(__FILE__, "Unable to remove /"%s/": %s",                     socket_path, strerror(errno));        return 0;    }    server_addr.sun_family = AF_UNIX;    if (tc_snprintf(server_addr.sun_path, sizeof(server_addr.sun_path),                    "%s", socket_path) < 0    ) {        tc_log_error(__FILE__, "Socket pathname too long");        return 0;    }    server_sock = socket(AF_UNIX, SOCK_STREAM, 0);    if (server_sock < 0) {        tc_log_perror(__FILE__, "Unable to create server socket");        return 0;    }    if (bind(server_sock, (struct sockaddr *)&server_addr,             sizeof(server_addr))    ) {        tc_log_perror(__FILE__, "Unable to bind server socket");        close(server_sock);        server_sock = -1;        unlink(socket_path);  // just in case        return 0;    }    if (listen(server_sock, 5) < 0) {        tc_log_perror(__FILE__, "Unable to activate server socket");        close(server_sock);        unlink(socket_path);        return 0;    }    return 1;}

static int nuv_configure(TCModuleInstance *self,                         const char *options, vob_t *vob){    PrivateData *pd;    struct rtfileheader hdr;    const char *filename = vob->video_in_file;    TC_MODULE_SELF_CHECK(self, "configure");    pd = self->userdata;    // FIXME: is this a good place for open()?  And how do we know which    // file (video or audio) to open?    pd->fd = open(filename, O_RDONLY);    if (pd->fd < 0) {        tc_log_error(MOD_NAME, "Unable to open %s: %s", filename,                     strerror(errno));        return TC_OK;    }    if (read(pd->fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {        tc_log_error(MOD_NAME, "Unable to read file header from %s", filename);        close(pd->fd);        pd->fd = -1;        return TC_OK;    }    if (strcmp(hdr.finfo, "NuppelVideo") != 0) {        tc_log_error(MOD_NAME, "Bad file header in %s", filename);        close(pd->fd);        pd->fd = -1;        return TC_OK;    }    if (strcmp(hdr.version, "0.05") != 0) {        tc_log_error(MOD_NAME, "Bad format version in %s", filename);        close(pd->fd);        pd->fd = -1;        return TC_OK;    }    pd->width = hdr.width;    pd->height = hdr.height;    pd->fps = hdr.fps;    pd->tsoffset = 0;    pd->framenum = 0;    pd->have_vframe = 0;    pd->audiorate = NUV_ARATE;    pd->audiofrac = 0;    memset(pd->cdata, 0, sizeof(pd->cdata));    pd->saved_vframelen = 0;    pd->saved_vcomptype = 'N';  // black frame    return TC_OK;}

int f_manage_input_xml(const char *p_name,int s_type,audiovideo_t *p_audiovideo){    static xmlDocPtr p_doc;    xmlNodePtr p_node;    xmlNsPtr ns;    if (s_type)     //read the file from p_name    {        p_doc = xmlParseFile(p_name);        p_node = xmlDocGetRootElement(p_doc);        if (p_node == NULL)        {            xmlFreeDoc(p_doc);            tc_log_error(__FILE__,"Invalid file format");            return(-1);        }        ns = xmlSearchNsByHref(p_doc, p_node, (const xmlChar *) "http://www.w3.org/2001/SMIL20/Language");        if (ns == NULL)        {            xmlFreeDoc(p_doc);            tc_log_error(__FILE__,"Invalid Namespace");            return(-1);        }        ns = xmlSearchNs(p_doc, p_node, (const xmlChar *) "smil2");        if (ns == NULL)        {            xmlFreeDoc(p_doc);            tc_log_error(__FILE__,"Invalid Namespace");            return(-1);        }        if (xmlStrcmp(p_node->name, (const xmlChar *) "smil"))        {            xmlFreeDoc(p_doc);            tc_log_error(__FILE__,"Invalid Namespace");            return(-1);        }        f_delete_unused_node(p_node);        memset(p_audiovideo,'/0',sizeof(audiovideo_t));        if(f_parse_tree(p_node,p_audiovideo))            return(1);        if (f_complete_tree(p_audiovideo))            return(1);    }    else    {            f_free_tree(p_audiovideo);            xmlFreeDoc(p_doc);    }    return(0);}

static int tc_vorbis_configure(TCModuleInstance *self,                               const char *options, vob_t *vob){    VorbisPrivateData *pd = NULL;    int samplerate = (vob->mp3frequency) ? vob->mp3frequency : vob->a_rate;    float quality = TC_CLAMP(vob->mp3quality, 0.0, 9.9) / 10.0;    int ret, br = vob->mp3bitrate * 1000;    TC_MODULE_SELF_CHECK(self, "configure");    pd = self->userdata;    if (vob->dm_bits != 16) {        tc_log_error(MOD_NAME, "Only 16-bit samples supported");        return TC_ERROR;    }     pd->flush_flag    = vob->encoder_flush;    pd->end_of_stream = TC_FALSE;    pd->channels      = vob->dm_chan;    pd->bits          = vob->dm_bits;    pd->packets       = 0;    pd->frames        = 0;    vorbis_info_init(&pd->vi);    if (quality > ZERO_QUALITY) {        ret = vorbis_encode_init_vbr(&pd->vi, pd->channels,                                     samplerate, quality);    } else {        ret = vorbis_encode_init(&pd->vi, pd->channels, samplerate,                                 -1, br, -1);    }    if (ret) {        tc_log_error(MOD_NAME, "the Vorbis encoder could not set up a mode"                               " according to the requested settings.");        ret = TC_ERROR;    } else {        vorbis_comment_init(&pd->vc);        vorbis_comment_add_tag(&pd->vc, "ENCODER", PACKAGE " " VERSION);        vorbis_analysis_init(&pd->vd, &pd->vi);        vorbis_block_init(&pd->vd, &pd->vb);        ret = tc_ogg_new_extradata(pd);        if (ret == TC_OK) {            /* publish it */            vob->ex_a_xdata = &(pd->xdata);        }    }    return ret;}

METHOD int pvn_configure(TCModuleInstance *self,                         const char *options, vob_t *vob){    PrivateData *pd = NULL;    char buf[TC_BUF_MAX];    int len;    TC_MODULE_SELF_CHECK(self, "configure");    pd->width  = vob->ex_v_width;    pd->height = vob->ex_v_height;    /* FIXME: stdout should be handled in a more standard fashion */    if (strcmp(vob->video_out_file, "-") == 0) {  // allow /dev/stdout too?        pd->fd = 1;    } else {        pd->fd = open(vob->video_out_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);        if (pd->fd < 0) {            tc_log_error(MOD_NAME, "Unable to open %s: %s",                         vob->video_out_file, strerror(errno));            goto fail;        }    }    len = tc_snprintf(buf, sizeof(buf), "PV%da/r/n%d %d/r/n",                      vob->decolor ? 5 : 6,                      pd->width, pd->height);    if (len < 0)        goto fail;    if (tc_pwrite(pd->fd, buf, len) != len) {        tc_log_error(MOD_NAME, "Unable to write header to %s: %s",                     vob->video_out_file, strerror(errno));        goto fail;    }    pd->framecount_pos = lseek(pd->fd, 0, SEEK_CUR);  // failure okay    len = tc_snprintf(buf, sizeof(buf), "%10d/r/n8/r/n%lf/r/n",                      0, (double)vob->ex_fps);    if (len < 0)        goto fail;    if (tc_pwrite(pd->fd, buf, len) != len) {        tc_log_error(MOD_NAME, "Unable to write header to %s: %s",                     vob->video_out_file, strerror(errno));        goto fail;    }    return TC_OK;fail:    pvn_stop(self);    return TC_ERROR;}

int load_plugin(const char *path, int id, int verbose){    const char *error = NULL;    char module[TC_BUF_MAX];    int n;    if (filter[id].name == NULL) {        tc_log_error(__FILE__, "bad filter#%i name (%s)",                     id, filter[id].name);        return -1;    }    filter[id].options = NULL;    /* replace "=" by "/0" in filter name */    for (n = 0; n < strlen(filter[id].name); n++) {        if (filter[id].name[n] == '=') {            filter[id].name[n] = '/0';            filter[id].options = filter[id].name + n + 1;            break;        }    }    tc_snprintf(module, sizeof(module), "%s/filter_%s.so", path, filter[id].name);    /* try transcode's module directory */    filter[id].handle = dlopen(module, RTLD_LAZY);    if (filter[id].handle != NULL) {        filter[id].entry = dlsym(filter[id].handle, "tc_filter");    } else {        if (verbose) {            tc_log_error(__FILE__, "loading filter module '%s' failed (reason: %s)",                         module, dlerror());        }        return -1;    }    error = dlerror();    if (error != NULL)  {        if (verbose) {            tc_log_error(__FILE__, "error while loading '%s': %s/n",                         module, error);        }        return -1;    }    return 0;}

/* * configure_colorspace: find correct source colorspace, and setup * module private data accordingly * * Parameters: *        pd: module private data to setup *       fmt: internal transcode colorspace format *   verbose: if nonzero, tc_log out operation. * Return Value: *     TC_ERROR on failure (unknown internal format), TC_OK on success */static int configure_colorspace(SDLPrivateData *pd, int fmt, int verbose){    const char *fmt_name = "unknown";    switch (fmt) {      case TC_CODEC_YUV420P:        pd->src_fmt = IMG_YUV420P;        fmt_name = "YUV420";        break;      case TC_CODEC_YUV422P:        pd->src_fmt = IMG_YUV422P;        fmt_name = "YUV422";        break;      case TC_CODEC_RGB24:        pd->src_fmt = IMG_RGB24;        fmt_name = "RGB24";        break;      default:        tc_log_error(MOD_NAME, "unknown colorspace");        return TC_ERROR;    }    if (verbose) {        tc_log_info(MOD_NAME, "colorspace conversion: %s -> YV12",                    fmt_name);    }    return TC_OK;}

int tc_x11source_close(TCX11Source *handle){    if (handle != NULL) {        if (handle->dpy != NULL) {            int ret = handle->fini(handle);            if (ret != 0) {                return ret;            }            tcv_free(handle->tcvhandle);            XFreePixmap(handle->dpy, handle->pix); /* XXX */            XFreeGC(handle->dpy, handle->gc); /* XXX */            ret = XCloseDisplay(handle->dpy);            if (ret == 0) {                handle->dpy = NULL;            } else {                tc_log_error(__FILE__, "XCloseDisplay() failed: %i", ret);                return -1;            }        }    }    return 0;}

static int tc_v4l2_video_init(V4L2Source *vs,                            int layout, const char *device,                           int width, int height, int fps,                           const char *options){    int ret = tc_v4l2_parse_options(vs, layout, options);    RETURN_IF_FAILED(ret);    vs->video_fd = v4l2_open(device, O_RDWR, 0);    if (vs->video_fd < 0) {        tc_log_error(MOD_NAME, "cannot open video device %s", device);        return TC_ERROR;    }    ret = tc_v4l2_video_check_capabilities(vs);    RETURN_IF_FAILED(ret);    ret = tc_v4l2_video_setup_image_format(vs, width, height);    RETURN_IF_FAILED(ret);    ret = tc_v4l2_video_setup_stream_parameters(vs, fps);    RETURN_IF_FAILED(ret);    ret = tc_v4l2_video_get_capture_buffer_count(vs);    RETURN_IF_FAILED(ret);    ret = tc_v4l2_video_setup_capture_buffers(vs);    RETURN_IF_FAILED(ret);    return tc_v4l2_capture_start(vs);}

static int tc_v4l2_video_get_capture_buffer_count(V4L2Source *vs){    struct v4l2_requestbuffers reqbuf;    int err = 0;    reqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;    reqbuf.memory = V4L2_MEMORY_MMAP;    reqbuf.count  = TC_V4L2_BUFFERS_NUM;    err = v4l2_ioctl(vs->video_fd, VIDIOC_REQBUFS, &reqbuf);    if (err < 0) {        tc_log_perror(MOD_NAME, "VIDIOC_REQBUFS");        return TC_ERROR;    }    vs->buffers_count = TC_MIN(reqbuf.count, TC_V4L2_BUFFERS_NUM);    if (vs->buffers_count < 2) {        tc_log_error(MOD_NAME, "not enough buffers for capture");        return TC_ERROR;    }    if (verbose_flag > TC_INFO) {        tc_log_info(MOD_NAME, "%i buffers available (maximum supported: %i)",                    vs->buffers_count, TC_V4L2_BUFFERS_NUM);    }    return TC_OK;}

static int modrequest_scan(const char *modpath, const char *modstr,                           glob_t *globbuf){    char path_model[PATH_MAX];    char buf[TC_BUF_MIN];    const char *pc = NULL;    int err = 0;    pc = strchr(modstr, ':');    if (pc == NULL) {        return 1;    }    if ((pc - modstr + 1) > sizeof(buf)) {        return 2; /* XXX watch out here */    }    strlcpy(buf, modstr, pc - modstr + 1);    tc_snprintf(path_model, sizeof(path_model), "%s/%s_*.so", modpath, buf);    err = glob(path_model, GLOB_ERR, NULL, globbuf);    if (err) {        tc_log_error(EXE, "error while scanning for modules: %s",                     (err == GLOB_NOSPACE)   ?"can't get enough memory" :                     (err == GLOB_ABORTED)   ?"read error" :                          /* GLOB_NOMATCH */ "no modules found");        return -1;    }    return 0;}

/* XXX */static int check_module_pair(const ModRequest *head,                             const ModRequest *tail,                             const ModRequest *ref,                             int verbose){    int ret = 0;    if (head->module == NULL || tail->module == NULL) {        tc_log_error(EXE, "check_module_pair: missing module handle");        return -1;    }    ret = tc_module_info_match(TC_CODEC_ANY,                               tc_module_get_info(head->module),                               tc_module_get_info(tail->module));    if (verbose >= TC_DEBUG) {        tc_log_info(EXE, "%s:%s | %s:%s [%s]",                    head->type, head->name, tail->type, tail->name,                    (ret == 1) ?"OK" :"MISMATCH");     } else if (verbose >= TC_INFO) {        if (ret == 1) {            printf("%s/n", ref->name);        }    }    return ret;}

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;}

voidprobe_bktr(info_t * ipipe){    struct bktr_capture_area caparea;    unsigned short status, fps;    close(ipipe->fd_in);    ipipe->fd_in = open(ipipe->name, O_RDONLY, 0);    if (ipipe->fd_in < 0) {	tc_log_error(__FILE__, "cannot open device: %s", strerror(errno));	goto error;    }    /* try a bktr ioctl */    if (ipipe->verbose & TC_DEBUG)	tc_log_msg(__FILE__, "checking if bktr ioctls are supported...");    if (ioctl(ipipe->fd_in, METEORSTATUS, &status) < 0) {	if (ipipe->verbose & TC_DEBUG)	    tc_log_msg(__FILE__, "... no");	goto error;    } else {        if (ipipe->verbose & TC_DEBUG)            tc_log_msg(__FILE__, "... yes");    }    if (ioctl(ipipe->fd_in, BT848_GCAPAREA, &caparea) < 0) {	tc_log_perror(__FILE__, "BT848_GCAPAREA");        goto error;    }    ipipe->probe_info->width = caparea.x_size;    ipipe->probe_info->height = caparea.y_size;    if (ioctl(ipipe->fd_in, METEORGFPS, &fps) < 0) {	tc_log_perror(__FILE__, "METEORGFPS");        goto error;    }    ipipe->probe_info->fps = fps;    switch(fps) {        case 30:            ipipe->probe_info->frc = 4;            break;        case 25:            ipipe->probe_info->frc = 3;            break;        default:            break;    }    ipipe->probe_info->magic = TC_MAGIC_BKTR_VIDEO;    return;error:    ipipe->error = 1;    ipipe->probe_info->codec = TC_CODEC_UNKNOWN;    ipipe->probe_info->magic = TC_MAGIC_UNKNOWN;    return;}

static int tc_frame_audio_add_ogg_packet(VorbisPrivateData *pd,                                          TCFrameAudio *f, ogg_packet *op){    int16_t *pkt_num = (int16_t*)f->audio_buf;    double ts = vorbis_granule_time(&(pd->vd), op->granulepos);    int needed = sizeof(*op) + op->bytes;    int avail = f->audio_size - f->audio_len;    TC_FRAME_SET_TIMESTAMP_DOUBLE(f, ts);    if (avail < needed) {        tc_log_error(__FILE__, "(%s) no buffer in frame: (avail=%i|needed=%i)",                     __func__, avail, needed);        return TC_ERROR;    }    ac_memcpy(f->audio_buf + f->audio_len, op, sizeof(*op));    f->audio_len += sizeof(*op);    ac_memcpy(f->audio_buf + f->audio_len, op->packet, op->bytes);    f->audio_len += op->bytes;    *pkt_num += 1;    if (op->e_o_s) {        f->attributes |= TC_FRAME_IS_END_OF_STREAM; // useless?    }    return TC_OK;}