示例#1
0
/*! \brief uninitialize the descriptor for local video stream */
static int video_out_uninit(struct video_desc *env)
{
	struct video_out_desc *v = &env->out;
	int i; /* integer variable used as iterator */
	
	/* XXX this should be a codec callback */
	if (v->enc_ctx) {
		AVCodecContext *enc_ctx = (AVCodecContext *)v->enc_ctx;
		avcodec_close(enc_ctx);
		av_free(enc_ctx);
		v->enc_ctx = NULL;
	}
	if (v->enc_in_frame) {
		av_free(v->enc_in_frame);
		v->enc_in_frame = NULL;
	}
	v->codec = NULL;	/* nothing to free, this is only a reference */
	/* release the buffers */
	fbuf_free(&env->enc_in);
	fbuf_free(&v->enc_out);
	/* close the grabbers */
	for (i = 0; i < v->device_num; i++) {
		if (v->devices[i].grabber){
			v->devices[i].grabber_data =
				v->devices[i].grabber->close(v->devices[i].grabber_data);
			v->devices[i].grabber = NULL;
			/* dev_buf is already freed by grabber->close() */
			v->devices[i].dev_buf = NULL;
		}
		v->devices[i].status_index = 0;
	}
	v->picture_in_picture = 0;
	env->frame_freeze = 0;
	return -1;
}
示例#2
0
/*! \brief uninitialize the descriptor for local video stream */
static int video_out_uninit(struct video_desc *env)
{
	struct video_out_desc *v = &env->out;

	/* XXX this should be a codec callback */
	if (v->enc_ctx) {
		AVCodecContext *enc_ctx = (AVCodecContext *)v->enc_ctx;
		avcodec_close(enc_ctx);
		av_free(enc_ctx);
		v->enc_ctx = NULL;
	}
	if (v->enc_in_frame) {
		av_free(v->enc_in_frame);
		v->enc_in_frame = NULL;
	}
	v->codec = NULL;	/* nothing to free, this is only a reference */
	/* release the buffers */
	fbuf_free(&env->enc_in);
	fbuf_free(&v->enc_out);
	/* close the grabber */
	if (v->grabber) {
		v->grabber_data = v->grabber->close(v->grabber_data);
		v->grabber = NULL;
	}
	return -1;
}
示例#3
0
static void *grab_v4l1_close(void *desc)
{
	struct grab_v4l1_desc *v = desc;

	close(v->fd);
	v->fd = -1;
	fbuf_free(&v->b);
	ast_free(v);
	return NULL;
}
示例#4
0
static inline void
shc_multi_context_destroy(shc_multi_ctx_t *ctx)
{
    async_read_context_destroy(ctx->reader);
    fbuf_free(ctx->commands);
    free(ctx->items);

    if (ctx->fd >= 0) {
        if (ctx->response_index == ctx->num_requests)
            connections_pool_add(ctx->client->connections, ctx->peer, ctx->fd);
        else
            close(ctx->fd);
    }

    free(ctx);
}
示例#5
0
文件: wurfld.c 项目: passani/wurfld
void *worker(void *priv) {
    wurfld_connection_context *ctx = (wurfld_connection_context *)priv;

    DEBUG1("Worker %p started on fd %d", pthread_self(), ctx->fd);

    // we don't need to receive anything anymore on this fd
    int err = shutdown(ctx->fd, SHUT_RD);
    if (err != 0)
        NOTICE("Can't shutdown the receive part of fd %d : %s", ctx->fd, strerror(errno));

    int opts = fcntl(ctx->fd, F_GETFL);
    if (opts >= 0) {
        err = fcntl(ctx->fd, F_SETFL, opts & (~O_NONBLOCK));
        if (err != 0)
            NOTICE("Can't set blocking mode on fd %d : %s", ctx->fd, strerror(errno));
    } else {
        ERROR("Can't get flags on fd %d : %s", ctx->fd, strerror(errno));
    }

    char *useragent = NULL;
    fbuf_trim(ctx->input);

    // parse the request 
    char *request_data = fbuf_data(ctx->input);
    struct sockaddr_in peer;
    socklen_t socklen = sizeof(struct sockaddr);
    getpeername(ctx->fd, (struct sockaddr *)&peer, &socklen);
    if (use_http && strncmp(request_data, "GET /lookup/", 12) == 0) {
        char *reqline_start = fbuf_data(ctx->input) + 12;
        char *reqline_end = reqline_start;

        while (*reqline_end != '\r' && *reqline_end != '\n')
            reqline_end++;
        reqline_end++;

        char reqline[reqline_end-reqline_start];
        snprintf(reqline, reqline_end-reqline_start, "%s", reqline_start);

        char *httpv = strstr(reqline, " HTTP/1");
        if (httpv) {
            *httpv = 0;
            httpv++;
            ctx->is_http10 = (strncmp(httpv, "HTTP/1.0", 8) == 0);
        }
        useragent = unescape_uri_request(reqline);
    } else if (!use_http) {
        useragent = strdup(fbuf_data(ctx->input));
    }

    if (useragent) {
        NOTICE("(%p) Lookup request from %s: %s", pthread_self(), inet_ntoa(peer.sin_addr), useragent);
        ctx->useragent = useragent;
        send_response(ctx);
    } else if (use_http) {
        NOTICE("(%p) Unsupported Request from %s: %s", pthread_self(), inet_ntoa(peer.sin_addr), request_data);
        char response[2048];

        snprintf(response, sizeof(response),
                 "%s 400 NOT SUPPORTED\r\n"
                 "Content-Type: text/plain\r\n"
                 "Content-Length: 17\r\n\r\n"
                 "400 NOT SUPPORTED",
                 ctx->is_http10 ? "HTTP/1.0" : "HTTP/1.1");

        if (write_socket(ctx->fd, response, strlen(response)) != 0) {
            ERROR("Worker %p failed writing reponse: %s", pthread_self(), strerror(errno));
        }
    }
    DEBUG1("Worker %p finished on fd %d", pthread_self(), ctx->fd);
    shutdown(ctx->fd, SHUT_RDWR);
    close(ctx->fd);
    fbuf_free(ctx->input);
    fbuf_free(ctx->output);
    free(ctx->useragent); 
    free(ctx);
    return NULL;
}
示例#6
0
main( int argc, char **argv )
{
	fbuf_uint32_t buf_sz = 512;
        int           N_frames = 2;
	const char    filename[] = "fbuf.data";

	filebuf_t    *fbuf_ptr;
        MixedElem    *elem_ptr;

	int           icontinue;
        fbuf_uint32_t frame_count;
        fbuf_uint32_t frame_idx_max;
        fbuf_uint32_t frame_idx;
        fbuf_uint32_t N_frame_elem;
        fbuf_uint32_t elem_idx;

	if ( argc > 1 ) 
		if ( isdigit( argv[1][0] ) ) buf_sz = atoi( argv[1] );
	if ( argc > 2 )
		if ( isdigit( argv[2][0] ) ) N_frames = atoi( argv[2] );

	fbuf_ptr       = fbuf_create( buf_sz );
        fbuf_filedesc( fbuf_ptr, fopen( filename, "wb" ) );
	bswp_fwrite( &(fbuf_ptr->bsize),
                     sizeof( fbuf_uint32_t ), 1, fbuf_ptr->fd );

        elem_idx = 0;
        for ( frame_count = 0; frame_count < N_frames; frame_count++ ) {
	        fbuf_increment( sizeof( fbuf_uint32_t ), fbuf_ptr );
	        icontinue = true; frame_idx = 0;
	        while( icontinue ) {
			elem_ptr = elem_create( ( double ) ( elem_idx * 10 ),
	                                        ( int ) elem_idx );
			if ( icontinue = elem2fbuf( fbuf_ptr, elem_ptr ) ) {
				printf( "elem_idx = %d,  used buffer = %d\n",
				        elem_idx, 
                                        fbuf_ptr->ptr - fbuf_ptr->head );
				frame_idx++; elem_idx++;
 			}
			else {
	 			frame_idx_max = frame_idx - 1;
				N_frame_elem  = frame_idx;
			}
			elem_free( elem_ptr );
		}
		/*  set fbuf to its head  */
		fbuf_decrement( fbuf_ptr->ptr - fbuf_ptr->head, fbuf_ptr );
		fbuf_deposit( &N_frame_elem, sizeof( fbuf_uint32_t ), 1,
                              fbuf_ptr );
                /*
		memcpy( fbuf_ptr->head, &N_frame_elem,
	                sizeof( fbuf_uint32_t )/sizeof( char ) );
                */

	        fbuf_empty( fbuf_ptr );
        }

	printf( "sizeof( MixedElem ) = %d\n",
                sizeof( MixedElem )/sizeof( char ) );
	printf( "The elem_idx_max is %d\n", elem_idx-1 );

	fclose( fbuf_ptr->fd );
	fbuf_free( fbuf_ptr );
}
示例#7
0
/*! \brief
 * Open the local video source and allocate a buffer
 * for storing the image.
 */
static void *grab_v4l1_open(const char *dev, struct fbuf_t *geom, int fps)
{
	struct video_window vw = { 0 };	/* camera attributes */
	struct video_picture vp;
	int fd, i;
	struct grab_v4l1_desc *v;
	struct fbuf_t *b;

	/* name should be something under /dev/ */
	if (strncmp(dev, "/dev/", 5)) 
		return NULL;
	fd = open(dev, O_RDONLY | O_NONBLOCK);
	if (fd < 0) {
		ast_log(LOG_WARNING, "error opening camera %s\n", dev);
		return NULL;
	}

	v = ast_calloc(1, sizeof(*v));
	if (v == NULL) {
		ast_log(LOG_WARNING, "no memory for camera %s\n", dev);
		close(fd);
		return NULL;	/* no memory */
	}
	v->fd = fd;
	v->b = *geom;
	b = &v->b;	/* shorthand */

	i = fcntl(fd, F_GETFL);
	if (-1 == fcntl(fd, F_SETFL, i | O_NONBLOCK)) {
		/* non fatal, just emit a warning */
		ast_log(LOG_WARNING, "error F_SETFL for %s [%s]\n",
			dev, strerror(errno));
	}
	/* set format for the camera.
	 * In principle we could retry with a different format if the
	 * one we are asking for is not supported.
	 */
	vw.width = b->w;
	vw.height = b->h;
	vw.flags = fps << 16;
	if (ioctl(fd, VIDIOCSWIN, &vw) == -1) {
		ast_log(LOG_WARNING, "error setting format for %s [%s]\n",
			dev, strerror(errno));
		goto error;
	}
	if (ioctl(fd, VIDIOCGPICT, &vp) == -1) {
		ast_log(LOG_WARNING, "error reading picture info\n");
		goto error;
	}
	ast_log(LOG_WARNING,
		"contrast %d bright %d colour %d hue %d white %d palette %d\n",
		vp.contrast, vp.brightness,
		vp.colour, vp.hue,
		vp.whiteness, vp.palette);
	/* set the video format. Here again, we don't necessary have to
	 * fail if the required format is not supported, but try to use
	 * what the camera gives us.
	 */
	b->pix_fmt = vp.palette;
	vp.palette = VIDEO_PALETTE_YUV420P;
	if (ioctl(v->fd, VIDIOCSPICT, &vp) == -1) {
		ast_log(LOG_WARNING, "error setting palette, using %d\n",
			b->pix_fmt);
	} else
		b->pix_fmt = vp.palette;
	/* allocate the source buffer.
	 * XXX, the code here only handles yuv411, for other formats
	 * we need to look at pix_fmt and set size accordingly
	 */
	b->size = (b->w * b->h * 3)/2;	/* yuv411 */
	ast_log(LOG_WARNING, "videodev %s opened, size %dx%d %d\n",
		dev, b->w, b->h, b->size);
	b->data = ast_calloc(1, b->size);
	if (!b->data) {
		ast_log(LOG_WARNING, "error allocating buffer %d bytes\n",
			b->size);
		goto error;
	}
	ast_log(LOG_WARNING, "success opening camera\n");
	return v;

error:
	close(v->fd);
	fbuf_free(b);
	ast_free(v);
	return NULL;
}