PROTO_THREAD_ROUTINE(app,nomParams) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_com_config_t icc; vp_stages_decoder_filter_config_t dfc; vp_stages_output_sdl_config_t osc; vp_com_t com; vp_com_bluetooth_connection_t connection; vp_com_bluetooth_config_t config; vp_os_memset( &icc, 0, sizeof(vp_stages_input_com_config_t) ); vp_os_memset( &connection, 0, sizeof(vp_com_bluetooth_connection_t) ); vp_com_str_to_address("00:01:48:03:70:54",&connection.address); vp_stages_fill_default_config(BLUETOOTH_COM_CONFIG, &config, sizeof(config)); vp_os_memset(&com, 0, sizeof(vp_com_t)); vp_stages_fill_default_config(DECODER_MPEG4_CONFIG, &dfc, sizeof(dfc)); vp_stages_fill_default_config(SDL_DECODING_CONFIG, &osc, sizeof(osc)); com.type = VP_COM_BLUETOOTH; icc.com = &com; icc.config = (vp_com_config_t*)&config; icc.connection = (vp_com_connection_t*)&connection; icc.socket.type = VP_COM_CLIENT; icc.socket.protocol = VP_COM_TCP; icc.socket.port = 5555; icc.buffer_size = 6400; strcpy(icc.socket.serverHost,"192.168.2.23"); stages[0].type = VP_API_INPUT_SOCKET; stages[0].cfg = (void *)&icc; stages[0].funcs = vp_stages_input_com_funcs; #ifdef USE_FFMPEG stages[1].type = VP_API_FILTER_DECODER; stages[1].cfg = (void *)&dfc; stages[1].funcs = vp_stages_decoder_filter_funcs; stages[2].type = VP_API_OUTPUT_SDL; stages[2].cfg = (void *)&osc; stages[2].funcs = vp_stages_output_sdl_funcs; #endif pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_com_t com; vp_stages_input_com_config_t icc; vp_com_serial_config_t config; vp_stages_decoder_ffmpeg_config_t dfc; vp_stages_output_sdl_config_t osc; vp_os_memset(&icc,0,sizeof(vp_stages_input_com_config_t)); vp_os_memset(&com, 0, sizeof(vp_com_t)); vp_stages_fill_default_config(UART1_COM_CONFIG, &config, sizeof(config)); vp_stages_fill_default_config(DECODER_MPEG4_CONFIG, &dfc, sizeof(dfc)); vp_stages_fill_default_config(SDL_DECODING_CONFIG, &osc, sizeof(osc)); com.type = VP_COM_SERIAL; icc.com = &com; icc.socket.type = VP_COM_CLIENT; icc.config = (vp_com_config_t *)&config; icc.buffer_size = 1024; stages[0].type = VP_API_INPUT_SOCKET; stages[0].cfg = (void *)&icc; stages[0].funcs = vp_stages_input_com_funcs; stages[1].type = VP_API_FILTER_DECODER; stages[1].cfg = (void *)&dfc; stages[1].funcs = vp_stages_decoder_ffmpeg_funcs; stages[2].type = VP_API_OUTPUT_SDL; stages[2].cfg = (void *)&osc; stages[2].funcs = vp_stages_output_sdl_funcs; pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) { //vp_os_delay( 200 ); } vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_com_config_t icc; vp_stages_output_sdl_config_t osc; vp_com_t com; vp_com_wifi_config_t config; vp_com_wifi_connection_t connection; vp_os_memset( &icc, 0, sizeof(vp_stages_input_com_config_t)); vp_os_memset( &connection, 0, sizeof(vp_com_wifi_connection_t) ); strcpy(connection.networkName,"linksys"); vp_stages_fill_default_config(WIFI_COM_CONFIG, &config, sizeof(config)); vp_os_memset(&com, 0, sizeof(vp_com_t)); vp_stages_fill_default_config(SDL_DECODING_QCIF_CONFIG, &osc, sizeof(osc)); com.type = VP_COM_WIFI; icc.com = &com; icc.config = (vp_com_config_t*)&config; icc.connection = (vp_com_connection_t*)&connection; icc.socket.type = VP_COM_CLIENT; icc.socket.protocol = VP_COM_TCP; icc.socket.port = 5555; icc.buffer_size = 6400; strcpy(icc.socket_client.serverHost,"192.168.1.23"); stages[0].type = VP_API_INPUT_SOCKET; stages[0].cfg = (void *)&icc; stages[0].funcs = vp_stages_input_com_funcs; stages[1].type = VP_API_OUTPUT_SDL; stages[1].cfg = (void *)&osc; stages[1].funcs = vp_stages_output_sdl_funcs; pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
int main(int argc, char **argv) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_com_config_t icc; vp_com_t com; vp_com_bluetooth_config_t config; vp_com_bluetooth_connection_t connection; vp_os_memset( &icc, 0, sizeof(vp_stages_input_com_config_t) ); vp_os_memset( &connection, 0, sizeof(vp_com_bluetooth_connection_t) ); vp_com_str_to_address("00:01:48:03:70:54",&connection.address); vp_stages_fill_default_config(BLUETOOTH_COM_CONFIG, &config, sizeof(config)); vp_os_memset(&com, 0, sizeof(vp_com_t)); com.type = VP_COM_BLUETOOTH; icc.com = &com; icc.config = (vp_com_config_t*)&config; icc.connection = (vp_com_connection_t*)&connection; icc.socket.type = VP_COM_CLIENT; icc.socket.protocol = VP_COM_TCP; icc.socket.port = 5555; icc.buffer_size = 64; strcpy(icc.socket.serverHost,"192.168.2.23"); stages[0].type = VP_API_INPUT_SOCKET; stages[0].cfg = (void *)&icc; stages[0].funcs = vp_stages_input_com_funcs; stages[1].type = VP_API_OUTPUT_CONSOLE; stages[1].cfg = NULL; stages[1].funcs = vp_stages_output_console_funcs; pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
PROTO_THREAD_ROUTINE(app, params) { uint32_t num_stages = 0; vp_api_picture_t picture; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_file_config_t ifc; vp_stages_output_file_config_t ofc; // vp_stages_output_sdl_config_t osc; buffer_to_picture_config_t bpc; mjpeg_stage_encoding_config_t mec; picture_to_buffer_config_t pbc; mjpeg_stage_decoding_config_t dec; /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = ACQ_WIDTH; picture.height = ACQ_HEIGHT; picture.framerate = 15; picture.y_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT ); picture.cr_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.cb_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.y_line_size = ACQ_WIDTH; picture.cb_line_size = ACQ_WIDTH / 2; picture.cr_line_size = ACQ_WIDTH / 2; picture.y_pad = 0; picture.c_pad = 0; vp_os_memset(&ifc,0,sizeof(vp_stages_input_file_config_t)); ifc.name = "../in.yuv"; ifc.buffer_size = (ACQ_WIDTH*ACQ_HEIGHT*3)/2; ofc.name = "../temp.mjpg"; stages[num_stages].type = VP_API_INPUT_FILE; stages[num_stages].cfg = (void *)&ifc; stages[num_stages].funcs = vp_stages_input_file_funcs; num_stages++; if( codec == MJPEG_ENCODER ) { bpc.picture = &picture; mec.picture = &picture; mec.out_buffer_size = 4096 * 4; stages[num_stages].type = VP_API_FILTER_DECODER; stages[num_stages].cfg = (void *)&bpc; stages[num_stages].funcs = buffer_to_picture_funcs; num_stages++; stages[num_stages].type = MJPEG_ENCODER; stages[num_stages].cfg = (void*)&mec; stages[num_stages].funcs = mjpeg_encoding_funcs; } else if( codec == MJPEG_DECODER ) { dec.picture = &picture; dec.out_buffer_size = 4096 * 4; pbc.picture = &picture; stages[num_stages].type = MJPEG_DECODER; stages[num_stages].cfg = (void*)&dec; stages[num_stages].funcs = mjpeg_decoding_funcs; num_stages++; stages[num_stages].type = VP_API_FILTER_ENCODER; stages[num_stages].cfg = (void *)&pbc; stages[num_stages].funcs = picture_to_buffer_funcs; } num_stages++; stages[num_stages].type = VP_API_OUTPUT_FILE; stages[num_stages].cfg = (void*)&ofc; stages[num_stages].funcs = vp_stages_output_file_funcs; num_stages++; pipeline.nb_stages = num_stages; pipeline.stages = &stages[0]; PRINT("Pipeline configured with %d stages\n", num_stages); vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; #ifdef RECORD_VIDEO video_stage_recorder_config_t vrc; #endif /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = QVGA_WIDTH; picture.height = QVGA_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT ); picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.y_line_size = QVGA_WIDTH; picture.cb_line_size = QVGA_WIDTH / 2; picture.cr_line_size = QVGA_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = QVGA_WIDTH; vec.height = QVGA_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; #ifdef RECORD_VIDEO vrc.fp = NULL; #endif pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; #ifdef RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vrc; stages[pipeline.nb_stages].funcs = video_recorder_funcs; pipeline.nb_stages++; #endif // RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = NULL; stages[pipeline.nb_stages].funcs = vp_stages_output_gtk_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; /* Processing of a pipeline */ if( !ardrone_tool_exit() ) { PRINT("\n Video stage thread initialisation\n\n"); res = vp_api_open(&pipeline, &pipeline_handle); if( SUCCEED(res) ) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; while( !ardrone_tool_exit() && (loop == SUCCESS) ) { if( SUCCEED(vp_api_run(&pipeline, &out)) ) { if( (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING) ) { loop = SUCCESS; } } else loop = -1; // Finish this thread } vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" Video stage thread ended\n\n"); return (THREAD_RET)0; }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; vlib_stage_decoding_config_t vec; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&picture, 0, sizeof( picture )); //#ifdef RECORD_VIDEO // video_stage_recorder_config_t vrc; //#endif /// Picture configuration picture.format = /*PIX_FMT_YUV420P */ PIX_FMT_RGB565; picture.width = 512; picture.height = 512; picture.framerate = 15; picture.y_buf = vp_os_malloc( picture.width * picture.height * 2); picture.cr_buf = NULL; picture.cb_buf = NULL; picture.y_line_size = picture.width * 2; picture.cb_line_size = 0; picture.cr_line_size = 0; icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = 512; vec.height = 512; vec.picture = &picture; vec.luma_only = FALSE; vec.block_mode_enable = TRUE; pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; /* #ifdef RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vrc; stages[pipeline.nb_stages].funcs = video_recorder_funcs; pipeline.nb_stages++; #endif */ stages[pipeline.nb_stages].type = VP_API_OUTPUT_LCD; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = video_stage_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; if( !ardrone_tool_exit() ) { PRINT("\nvideo stage thread initialisation\n\n"); // NICK video_stage_init(); res = vp_api_open(&pipeline, &pipeline_handle); if( VP_SUCCEEDED(res) ) { int loop = VP_SUCCESS; out.status = VP_API_STATUS_PROCESSING; #ifdef RECORD_VIDEO { DEST_HANDLE dest; dest.stage = 2; dest.pipeline = pipeline_handle; vp_api_post_message( dest, PIPELINE_MSG_START, NULL, (void*)NULL); } #endif video_stage_in_pause = FALSE; while( !ardrone_tool_exit() && (loop == VP_SUCCESS) ) { if(video_stage_in_pause) { vp_os_mutex_lock(&video_stage_mutex); icc.num_retries = VIDEO_MAX_RETRIES; vp_os_cond_wait(&video_stage_condition); vp_os_mutex_unlock(&video_stage_mutex); } if( VP_SUCCEEDED(vp_api_run(&pipeline, &out)) ) { if( (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING) ) { loop = VP_SUCCESS; } } else loop = -1; // Finish this thread } vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" video stage thread ended\n\n"); return (THREAD_RET)0; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_picture_t picture; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_com_config_t icc; mjpeg_stage_decoding_config_t dec; vp_stages_output_sdl_config_t osc; vp_com_t com; vp_com_bluetooth_connection_t connection; vp_com_bluetooth_config_t config; /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = ACQ_WIDTH; picture.height = ACQ_HEIGHT; picture.framerate = 15; picture.y_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT ); picture.cr_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.cb_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.y_line_size = ACQ_WIDTH; picture.cb_line_size = ACQ_WIDTH / 2; picture.cr_line_size = ACQ_WIDTH / 2; picture.y_pad = 0; picture.c_pad = 0; dec.picture = &picture; dec.out_buffer_size = 4096; vp_os_memset( &icc, 0, sizeof(vp_stages_input_com_config_t) ); vp_os_memset( &osc, 0, sizeof(vp_stages_output_sdl_config_t) ); vp_os_memset( &connection, 0, sizeof(vp_com_bluetooth_connection_t) ); vp_os_memset( &config, 0, sizeof(vp_com_bluetooth_config_t) ); vp_os_memset( &com, 0, sizeof(vp_com_t) ); vp_com_str_to_address("08:75:48:03:60:34",&connection.address); // vp_com_str_to_address("00:12:1C:FF:A4:EE",&connection.address); strcpy(config.itfName, "bnep0"); strcpy(config.localHost, "192.168.2.58"); strcpy(config.netmask, "255.255.255.0"); strcpy(config.broadcast, "192.168.2.255"); strcpy(config.gateway, "192.168.2.0"); strcpy(config.server, "192.168.2.0"); strcpy(config.passkey, "1234" ); config.secure = 1; com.type = VP_COM_BLUETOOTH; icc.com = &com; icc.config = (vp_com_config_t*)&config; icc.connection = (vp_com_connection_t*)&connection; icc.socket.type = VP_COM_CLIENT; icc.socket.protocol = VP_COM_TCP; icc.socket.port = 5555; icc.buffer_size = 1600; // icc.sockopt = VP_COM_NON_BLOCKING; strcpy(icc.socket.serverHost,"192.168.2.23"); osc.width = 320; osc.height = 240; osc.bpp = 16; osc.window_width = 320; osc.window_height = 240; osc.pic_width = ACQ_WIDTH; osc.pic_height = ACQ_HEIGHT; osc.y_size = ACQ_WIDTH*ACQ_HEIGHT; osc.c_size = (ACQ_WIDTH*ACQ_HEIGHT) >> 2; stages[0].type = VP_API_INPUT_SOCKET; stages[0].cfg = (void *)&icc; stages[0].funcs = vp_stages_input_com_funcs; stages[1].type = VP_API_FILTER_DECODER; stages[1].cfg = (void*)&dec; stages[1].funcs = mjpeg_decoding_funcs; stages[2].type = VP_API_OUTPUT_SDL; stages[2].cfg = (void *)&osc; stages[2].funcs = vp_stages_output_sdl_funcs; pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; #ifdef RECORD_VIDEO video_stage_recorder_config_t vrc; #endif /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = QVGA_WIDTH; picture.height = QVGA_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT ); picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.y_line_size = QVGA_WIDTH; picture.cb_line_size = QVGA_WIDTH / 2; picture.cr_line_size = QVGA_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = QVGA_WIDTH; vec.height = QVGA_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; #ifdef RECORD_VIDEO vrc.fp = NULL; #endif pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; #ifdef RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vrc; stages[pipeline.nb_stages].funcs = video_recorder_funcs; pipeline.nb_stages++; #endif // RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = NULL; stages[pipeline.nb_stages].funcs = vp_stages_output_gtk_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; /* Processing of a pipeline */ if( !ardrone_tool_exit() ) { PRINT("Video stage thread initialization\n"); res = vp_api_open(&pipeline, &pipeline_handle); // PRINT("VP_API OPENED\n"); if( SUCCEED(res) ) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; cvStartWindowThread(); #define frontWindow "DroneView" cvNamedWindow(frontWindow, CV_WINDOW_AUTOSIZE); frontImgStream = cvCreateImage(cvSize(picture.width, picture.height), IPL_DEPTH_8U, 3); #define bottomWindow "BomberView" if(extractBottomImage) cvNamedWindow(bottomWindow, CV_WINDOW_AUTOSIZE); bottomImgStream = cvCreateImage(cvSize(bottomWidth, bottomHeight), IPL_DEPTH_8U, 3); IplImage *frame; CvCapture *capture; if(USEWEBCAM) { capture = cvCaptureFromCAM(WEBCAMINDEX); if(!capture) { printf("ERROR: Cannot Initialize Webcam.\n"); loop = !SUCCESS; } } while( !ardrone_tool_exit() && (loop == SUCCESS) ) { if(!USEWEBCAM) { if( SUCCEED(vp_api_run(&pipeline, &out)) ) { if (vec.controller.num_frames==0) continue; /*int i; for(i = 0; i < (picture.width)*(picture.height); i++) { frontImgStream->imageData[i*3] = picture.y_buf[i]; frontImgStream->imageData[i*3+1] = picture.y_buf[i]; frontImgStream->imageData[i*3+2] = picture.y_buf[i]; } */ cvCvtColor(rgbHeader, frontImgStream, CV_RGB2BGR); //[for colour] if(extractBottomImage) { int j = 0, i; for(i = 0; j < bottomHeight*bottomWidth; i = i%picture.width >= bottomWidth-1 ? i - (i%picture.width) + picture.width : i+1) { bottomImgStream->imageData[j*3] = frontImgStream->imageData[i*3]; bottomImgStream->imageData[j*3+1] = frontImgStream->imageData[i*3+1]; bottomImgStream->imageData[j*3+2] = frontImgStream->imageData[i*3+2]; frontImgStream->imageData[i*3] = 0; frontImgStream->imageData[i*3+1] = 0; frontImgStream->imageData[i*3+2] = 0; j++; } } //cvLine(frontImgStream, cvPoint(picture.width/2, 0), cvPoint(picture.width/2, picture.height), CV_RGB(0,255,0), 1, CV_AA, 0 ); cvShowImage(frontWindow, frontImgStream); if(extractBottomImage) cvShowImage(bottomWindow, bottomImgStream); if(CAPTUREIMAGESTREAM) { char filename[256]; struct timeval t; gettimeofday(&t, NULL); sprintf(filename, "%d.%06d.jpg", (int)t.tv_sec, (int)t.tv_usec); if(frontImgStream != NULL && cvSaveImage(filename, cvCloneImage(frontImgStream), 0)) printf("Image dumped to %s\n", filename); else printf("Error dumping image...\n"); if(extractBottomImage) { sprintf(filename, "%d.%06dbottom.jpg", (int)t.tv_sec, (int)t.tv_usec); if(bottomImgStream != NULL && cvSaveImage(filename, cvCloneImage(bottomImgStream), 0)) printf("Bottom Image dumped to %s\n", filename); else printf("Error dumping bottom image...\n"); } } } else loop = -1; } else //use webcam { frame = cvQueryFrame(capture); if(!frame) break; cvResize(frame, frontImgStream, CV_INTER_LINEAR); cvShowImage(frontWindow, frontImgStream); cvWaitKey(1); } } cvDestroyWindow(frontWindow); if(extractBottomImage) cvDestroyWindow(bottomWindow); //cvReleaseImage(&imgBottom); //cvDestroyWindow(bottomWindow); cvReleaseImage(&frontImgStream); vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" Video stage thread ended\n\n"); return (THREAD_RET)0; }
int main(int argc, char **argv) { vp_api_picture_t video_picture; vp_api_picture_t buffer_blockline; #ifdef BLOCK_MODE vp_api_picture_t video_blockline; #endif vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES_MAX]; vp_os_memset(&ivc,0,sizeof(ivc)); vp_os_memset(&ofc,0,sizeof(ofc)); vp_os_memset(&occ,0,sizeof(occ)); // CAMIF config ivc.camera = "/dev/video1"; ivc.i2c = "/dev/i2c-0"; #ifdef OV_CAM ivc.camera_configure = &camera_configure_ov77xx; #else #ifdef CRESYN_CAM ivc.camera_configure = &camera_configure_cresyn; #else #error no cam selected #endif #endif ivc.resolution = VGA; ivc.nb_buffers = 8; ivc.format = V4L2_PIX_FMT_YUV420; ivc.y_pad = 0; ivc.c_pad = 0; ivc.offset_delta = 0; #ifdef BLOCK_MODE ivc.vp_api_blockline = &video_blockline; #endif ivc.vp_api_picture = &video_picture; ivc.use_chrominances = 1; ivc.framerate = 15; // BUFFER #ifdef BLOCK_MODE bbc.picture = &video_blockline; #endif // ENCODER vec.width = 320; vec.height = 240; #ifdef BLOCK_MODE vec.block_mode_enable = TRUE; #else vec.block_mode_enable = FALSE; #endif vec.picture = &video_picture; // OUTPUT FILE config ofc.name = "/tmp/out.yuv"; // COM CONFIG occ.com = wired_com(); occ.config = wired_config(); occ.connection = wired_connection(); occ.socket.type = VP_COM_SERVER; occ.socket.protocol = VP_COM_TCP; occ.socket.port = 5555; occ.buffer_size = 640*480*3/2; // build pipeline pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_CAMIF; stages[pipeline.nb_stages].cfg = (void *)&ivc; stages[pipeline.nb_stages++].funcs = V4L2_funcs; #ifdef BLOCK_MODE #ifdef BUFFER stages[pipeline.nb_stages].type = VP_API_INPUT_CAMIF; stages[pipeline.nb_stages].cfg = (void *)&bbc; stages[pipeline.nb_stages++].funcs = blockline_to_buffer_funcs; #endif #endif #ifdef ENCODE stages[pipeline.nb_stages].type = VP_API_FILTER_ENCODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages++].funcs = vlib_encoding_funcs; #endif #ifdef FILE_OUTPUT stages[pipeline.nb_stages].type = VP_API_OUTPUT_FILE; stages[pipeline.nb_stages].cfg = (void *)&ofc; stages[pipeline.nb_stages++].funcs = vp_stages_output_file_funcs; #endif #ifdef ETHERNET_OUTPUT stages[pipeline.nb_stages].type = VP_API_OUTPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&occ; stages[pipeline.nb_stages++].funcs = vp_stages_output_com_funcs; #endif pipeline.stages = &stages[0]; // launch pipelines vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; ///////////////////////////////////////////////////////////////////////////////////////// uint16_t i = 0; struct timeval time1,time2; printf("Pipeline launched....\n"); gettimeofday(&time1,NULL); while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING)) { i++; //printf("image %d \n",i); if (i>50) break; //vp_os_delay(20); } ///////////////////////////////////////////////////////////////////////////////////////// gettimeofday(&time2,NULL); int seconde = time2.tv_sec-time1.tv_sec; int ms = time2.tv_usec-time1.tv_usec; if (ms<0) { seconde--; ms += 1000000; } ms = ms/1000; float fps = ((float)i*1000)/(float)(seconde*1000+ms); printf("temps ecoule : %d.%d / nombre image : %d average fps : %f\n",seconde,ms,i,fps); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
/* The video processing thread. This function can be kept as it is by most users. It automatically receives the video stream in a loop, decode it, and then call the 'output_rendering_device_stage_transform' function for each decoded frame. */ DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; /* Picture configuration */ picture.format = PIX_FMT_YUV420P; picture.width = DRONE_VIDEO_MAX_WIDTH; picture.height = DRONE_VIDEO_MAX_HEIGHT; picture.framerate = 15; //picture.framerate = 3; picture.y_buf = vp_os_malloc( DRONE_VIDEO_MAX_WIDTH * DRONE_VIDEO_MAX_HEIGHT ); picture.cr_buf = vp_os_malloc( DRONE_VIDEO_MAX_WIDTH * DRONE_VIDEO_MAX_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( DRONE_VIDEO_MAX_WIDTH * DRONE_VIDEO_MAX_HEIGHT / 4 ); picture.y_line_size = DRONE_VIDEO_MAX_WIDTH; picture.cb_line_size = DRONE_VIDEO_MAX_WIDTH / 2; picture.cr_line_size = DRONE_VIDEO_MAX_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); /* Video socket configuration */ icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); /* Video decoder configuration */ /* Size of the buffers used for decoding This must be set to the maximum possible video resolution used by the drone The actual video resolution will be stored by the decoder in vec.controller (see vlib_stage_decode.h) */ vec.width = DRONE_VIDEO_MAX_WIDTH; vec.height = DRONE_VIDEO_MAX_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; /* Video pipeline building */ pipeline.nb_stages = 0; /* Video stream reception */ stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; /* Video stream decoding */ stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; /* YUV to RGB conversion YUV format is used by the video stream protocol Remove this stage if your rendering device can handle YUV data directly */ stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; /* User code */ stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; /* Set to VP_API_OUTPUT_SDL even if SDL is not used */ stages[pipeline.nb_stages].cfg = (void*)&vec; /* give the decoder information to the renderer */ stages[pipeline.nb_stages].funcs = vp_stages_output_rendering_device_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; /* Processing of a pipeline */ if( !ardrone_tool_exit() ) { PRINT("\n Video stage thread initialisation\n\n"); // switch to vertical camera //ardrone_at_zap(ZAP_CHANNEL_VERT); res = vp_api_open(&pipeline, &pipeline_handle); if( VP_SUCCEEDED(res) ) { int loop = VP_SUCCESS; out.status = VP_API_STATUS_PROCESSING; while( !ardrone_tool_exit() && (loop == VP_SUCCESS) ) { if( VP_SUCCEEDED(vp_api_run(&pipeline, &out)) ) { if( (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING) ) { loop = VP_SUCCESS; } } else loop = -1; // Finish this thread } vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" Video stage thread ended\n\n"); return (THREAD_RET)0; }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t * stages; video_stage_merge_slices_config_t merge_slices_cfg; uint8_t i; specific_parameters_t * params = (specific_parameters_t *)(data); if (1 == params->needSetPriority) { CHANGE_THREAD_PRIO (video_stage, params->priority); } vp_os_memset(&icc_tcp, 0, sizeof ( icc_tcp)); vp_os_memset(&icc_udp, 0, sizeof ( icc_udp)); // Video Communication config icc_tcp.com = COM_VIDEO(); icc_tcp.buffer_size = (1024*1024); icc_tcp.protocol = VP_COM_TCP; COM_CONFIG_SOCKET_VIDEO(&icc_tcp.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); // Video Communication config icc_udp.com = COM_VIDEO(); icc_udp.buffer_size = (1024*1024); icc_udp.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc_udp.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); icc.nb_sockets = 2; icc.configs = icc_tab; icc.forceNonBlocking = &(tcpConf.tcpStageHasMoreData); icc_tab[1] = &icc_tcp; icc_tab[0] = &icc_udp; icc.buffer_size = (1024*1024); vp_os_memset(&vec, 0, sizeof ( vec)); stages = (vp_api_io_stage_t*) (vp_os_calloc( NB_STAGES + params->pre_processing_stages_list->length + params->post_processing_stages_list->length, sizeof (vp_api_io_stage_t) )); vec.src_picture = params->in_pic; vec.dst_picture = params->out_pic; vp_os_memset(&tcpConf, 0, sizeof ( tcpConf)); tcpConf.maxPFramesPerIFrame = 30; tcpConf.frameMeanSize = 160*1024; tcpConf.tcpStageHasMoreData = FALSE; tcpConf.latencyDrop = 1; pipeline.name = "video_stage_pipeline"; pipeline.nb_stages = 0; pipeline.stages = &stages[0]; //ENCODED FRAME PROCESSING STAGES stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *) &icc; stages[pipeline.nb_stages++].funcs = video_com_multisocket_funcs; printf("thread_video_stage: adding multisocket_funcs as %d th stage (input type) to video_pipeline of AR.Drone with version %d.%d.%d\n", pipeline.nb_stages, ardroneVersion.majorVersion, ardroneVersion.minorVersion, ardroneVersion.revision ); stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void *) &tcpConf; stages[pipeline.nb_stages++].funcs = video_stage_tcp_funcs; printf("thread_video_stage: adding tcp_funcs to video_pipeline as %d nd stage (filter type) of AR.Drone\n", pipeline.nb_stages ); // Record Encoded video if(1 == ARDRONE_VERSION()) { ardrone_academy_stage_recorder_config.dest.pipeline = video_pipeline_handle; ardrone_academy_stage_recorder_config.dest.stage = pipeline.nb_stages; stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&ardrone_academy_stage_recorder_config; stages[pipeline.nb_stages++].funcs = ardrone_academy_stage_recorder_funcs; printf("thread_video_stage: adding academy_recorder_funcs to video_pipeline as %d rd stage (filter type) of AR.Drone\n", pipeline.nb_stages ); } else { // Nothing to do for AR.Drone 2 as we have a separated thread for recording } //PRE-DECODING STAGES ==> recording, ... for(i=0;i<params->pre_processing_stages_list->length;i++){ stages[pipeline.nb_stages].type = params->pre_processing_stages_list->stages_list[i].type; stages[pipeline.nb_stages].cfg = params->pre_processing_stages_list->stages_list[i].cfg; stages[pipeline.nb_stages++].funcs = params->pre_processing_stages_list->stages_list[i].funcs; } printf("thread_video_stage: adding pre_processing_stages_list to video_pipeline (now %d stages) of AR.Drone\n", pipeline.nb_stages ); stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void *)&merge_slices_cfg; stages[pipeline.nb_stages++].funcs = video_stage_merge_slices_funcs; printf("thread_video_stage: adding merge_slices_funcs to video_pipeline (now %d stages) of AR.Drone\n", pipeline.nb_stages ); //DECODING STAGES stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*) &vec; stages[pipeline.nb_stages++].funcs = video_decoding_funcs; printf("thread_video_stage: adding video_decoding_funcs to video_pipeline (now %d stages) of AR.Drone\n", pipeline.nb_stages ); //POST-DECODING STAGES ==> transformation, display, ... for(i=0;i<params->post_processing_stages_list->length;i++){ stages[pipeline.nb_stages].type = params->post_processing_stages_list->stages_list[i].type; stages[pipeline.nb_stages].cfg = params->post_processing_stages_list->stages_list[i].cfg; stages[pipeline.nb_stages++].funcs = params->post_processing_stages_list->stages_list[i].funcs; } printf("thread_video_stage: adding post_processing_stages_list to video_pipeline (now %d stages) of AR.Drone\n", pipeline.nb_stages ); if (!ardrone_tool_exit()) { PRINT("\nvideo stage thread initialisation\n\n"); res = vp_api_open(&pipeline, &video_pipeline_handle); if (SUCCEED(res)) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; while (!ardrone_tool_exit() && (loop == SUCCESS)) { if (video_stage_in_pause) { vp_os_mutex_lock(&video_stage_mutex); icc.num_retries = VIDEO_MAX_RETRIES; vp_os_cond_wait(&video_stage_condition); vp_os_mutex_unlock(&video_stage_mutex); } if (SUCCEED(vp_api_run(&pipeline, &out))) { if ((out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) { loop = SUCCESS; } } else loop = -1; // Finish this thread } vp_os_free(params->pre_processing_stages_list->stages_list); vp_os_free(params->post_processing_stages_list->stages_list); vp_os_free(params->pre_processing_stages_list); vp_os_free(params->post_processing_stages_list); vp_os_free(params->in_pic); vp_os_free(params->out_pic); vp_os_free(params); vp_api_close(&pipeline, &video_pipeline_handle); } } PRINT("\nvideo stage thread ended\n\n"); return (THREAD_RET) 0; }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; #ifdef RECORD_VIDEO video_stage_recorder_config_t vrc; #endif /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = QVGA_WIDTH; picture.height = QVGA_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT ); picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.y_line_size = QVGA_WIDTH; picture.cb_line_size = QVGA_WIDTH / 2; picture.cr_line_size = QVGA_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = QVGA_WIDTH; vec.height = QVGA_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; #ifdef RECORD_VIDEO vrc.fp = NULL; #endif pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; #ifdef RECORD_VIDEO PRINT("\n Record Video\n\n"); stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vrc; stages[pipeline.nb_stages].funcs = video_recorder_funcs; pipeline.nb_stages++; #endif // RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = NULL; stages[pipeline.nb_stages].funcs = vp_stages_output_gtk_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; /* Processing of a pipeline */ if( !ardrone_tool_exit() ) { PRINT("\n Video stage thread initialisation\n\n"); if ((sockfd = socket(AF_UNIX,SOCK_STREAM,0)) < 0) { printf("error creating socket"); } bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sun_family = AF_UNIX; unlink("/tmp/video"); strcpy(serv_addr.sun_path, "/tmp/video"); servlen=strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family); if(bind(sockfd,(struct sockaddr *)&serv_addr,servlen)<0) { printf("error binding socket"); } listen(sockfd,5); clilen = sizeof(serv_addr); newsockfd = accept( sockfd,(struct sockaddr *)&serv_addr,&clilen); printf("1 sockfd, %d", sockfd); PRINT("\n Video socket initialisation\n\n"); res = vp_api_open(&pipeline, &pipeline_handle); if( SUCCEED(res) ) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; while( !ardrone_tool_exit() && (loop == SUCCESS) ) { if( SUCCEED(vp_api_run(&pipeline, &out)) ) { if( (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING) ) { loop = SUCCESS; } } else loop = -1; // Finish this thread //printf("%s\n", pixbuf_data); //printf("!%d sizeof *\n", sizeof(pixbuf_data)); //printf("!%d --- %d\n", n, errno); } vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" Video stage thread ended\n\n"); return (THREAD_RET)0; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_picture_t picture; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_stages_input_file_config_t ifc; vp_stages_output_sdl_config_t osc; mjpeg_stage_decoding_config_t dec; vp_os_memset(&ifc,0,sizeof(vp_stages_input_file_config_t)); ifc.name = ((char**)argv)[1]; ifc.buffer_size = (ACQ_WIDTH*ACQ_HEIGHT*3)/2; osc.width = WINDOW_WIDTH; osc.height = WINDOW_HEIGHT; osc.bpp = 16; osc.window_width = WINDOW_WIDTH; osc.window_height = WINDOW_HEIGHT; osc.pic_width = ACQ_WIDTH; osc.pic_height = ACQ_HEIGHT; osc.y_size = ACQ_WIDTH*ACQ_HEIGHT; osc.c_size = (ACQ_WIDTH*ACQ_HEIGHT) >> 2; /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = ACQ_WIDTH; picture.height = ACQ_HEIGHT; picture.framerate = 15; picture.y_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT ); picture.cr_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.cb_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.y_line_size = ACQ_WIDTH; picture.cb_line_size = ACQ_WIDTH / 2; picture.cr_line_size = ACQ_WIDTH / 2; picture.y_pad = 0; picture.c_pad = 0; dec.picture = &picture; dec.out_buffer_size = 4096; stages[0].type = VP_API_INPUT_FILE; stages[0].cfg = (void *)&ifc; stages[0].funcs = vp_stages_input_file_funcs; stages[1].type = VP_API_FILTER_DECODER; stages[1].cfg = (void *)&dec; stages[1].funcs = mjpeg_decoding_funcs; stages[2].type = VP_API_OUTPUT_SDL; stages[2].cfg = (void *)&osc; stages[2].funcs = vp_stages_output_sdl_funcs; pipeline.nb_stages = NB_STAGES; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) { vp_os_delay( 30 ); } vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES_MAX]; uint16_t time1,time2; uint16_t i; time1 = clock(); vp_os_memset(&ivc,0,sizeof(ivc)); //vp_os_memset(&vec,0,sizeof(vec)); vp_os_memset(&occ,0,sizeof(occ)); ivc.device = "/tmp/video0"; ivc.width = ACQ_WIDTH; ivc.height = ACQ_HEIGHT; ivc.vp_api_picture = &picture; /* vec.width = ACQ_WIDTH; */ /* vec.height = ACQ_HEIGHT; */ /* vec.block_mode_enable = FALSE; */ /* vec.picture = &picture; */ occ.com = COM_VIDEO(); occ.config = COM_CONFIG_VIDEO(); occ.connection = COM_CONNECTION_VIDEO(); occ.socket.type = VP_COM_SERVER; occ.socket.protocol = VP_COM_TCP; occ.socket.port = 5555; occ.buffer_size = 320*240*3/2; pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_FILE; stages[pipeline.nb_stages].cfg = (void *)&ivc; stages[pipeline.nb_stages++].funcs = vp_stages_input_v4l_funcs; /* stages[pipeline.nb_stages].type = VP_API_FILTER_ENCODER; */ /* stages[pipeline.nb_stages].cfg = (void *)NULL; */ /* stages[pipeline.nb_stages++].funcs = buffer_to_picture_funcs; */ /* stages[pipeline.nb_stages].type = VP_API_FILTER_ENCODER; */ /* stages[pipeline.nb_stages].cfg = (void*)&vec; */ /* stages[pipeline.nb_stages++].funcs = vlib_encoding_funcs; */ stages[pipeline.nb_stages].type = VP_API_OUTPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&occ; stages[pipeline.nb_stages++].funcs = vp_stages_output_com_funcs; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; ///////////////////////////////////////////////////////////////////////////////////////// i = 0; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING)) { i++; PRINT("image %d \n",i); //vp_os_delay(50); } ///////////////////////////////////////////////////////////////////////////////////////// time2 = clock(); printf("temps ecoule : %d \n",time2-time1); vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
DEFINE_THREAD_ROUTINE(video_update_thread, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = STREAM_WIDTH; picture.height = STREAM_HEIGHT; picture.framerate = 30; picture.y_buf = (uint8_t *)vp_os_malloc( STREAM_WIDTH * STREAM_HEIGHT ); picture.cr_buf = (uint8_t *)vp_os_malloc( STREAM_WIDTH * STREAM_HEIGHT / 4 ); picture.cb_buf = (uint8_t *)vp_os_malloc( STREAM_WIDTH * STREAM_HEIGHT / 4 ); picture.y_line_size = STREAM_WIDTH; picture.cb_line_size = STREAM_WIDTH / 2; picture.cr_line_size = STREAM_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = STREAM_WIDTH; vec.height = STREAM_HEIGHT; vec.picture = &picture; #ifdef USE_VIDEO_YUV vec.luma_only = FALSE; #else vec.luma_only = TRUE; #endif // USE_VIDEO_YUV vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; if( CAMIF_H_CAMERA_USED == CAMIF_CAMERA_OVTRULY_UPSIDE_DOWN_ONE_BLOCKLINE_LESS ) yuv2rgbconf.mode = VP_STAGES_YUV2RGB_MODE_UPSIDE_DOWN; pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = (void *)&vec; stages[pipeline.nb_stages].funcs = vp_stages_export_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; PIPELINE_HANDLE pipeline_handle; res = vp_api_open(&pipeline, &pipeline_handle); if( SUCCEED(res) ) { while( SUCCEED(vp_api_run(&pipeline, &out)) ) { } vp_api_close(&pipeline, &pipeline_handle); } return (THREAD_RET)0; }
DEFINE_THREAD_ROUTINE(video_recorder, data) { if (1 >= ARDRONE_VERSION ()) // Run only for ARDrone 2 and upper { return (THREAD_RET)0; } C_RESULT res = C_OK; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[3]; PIPELINE_HANDLE video_recorder_pipeline_handle; video_recorder_thread_param_t *video_recorder_thread_param = (video_recorder_thread_param_t *)data; video_stage_tcp_config_t tcpConf; if(video_recorder_thread_param != NULL) { CHANGE_THREAD_PRIO(video_recorder, video_recorder_thread_param->priority); video_stage_encoded_recorder_config.finish_callback = video_recorder_thread_param->finish_callback; } vp_os_memset (&record_icc, 0x0, sizeof (record_icc)); record_icc.com = COM_VIDEO (); record_icc.buffer_size = (8*1024); record_icc.protocol = VP_COM_TCP; record_icc.forceNonBlocking = &tcpConf.tcpStageHasMoreData; COM_CONFIG_SOCKET_VIDEO (&record_icc.socket, VP_COM_CLIENT, VIDEO_RECORDER_PORT, wifi_ardrone_ip); record_icc.timeoutFunc = &video_stage_encoded_recorder_com_timeout; record_icc.timeoutFuncAfterSec = 10; vp_os_memset (&tcpConf, 0, sizeof (tcpConf)); tcpConf.maxPFramesPerIFrame = 30; tcpConf.frameMeanSize = 160*1024; tcpConf.latencyDrop = 0; pipeline.nb_stages = 0; pipeline.stages = &stages[0]; // Com stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&record_icc; stages[pipeline.nb_stages++].funcs = video_com_funcs; // TCP stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void *) &tcpConf; stages[pipeline.nb_stages++].funcs = video_stage_tcp_funcs; // Record stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void *) &video_stage_encoded_recorder_config; stages[pipeline.nb_stages++].funcs = video_encoded_recorder_funcs; while (FALSE == isInit) { printf ("Waiting for init\n"); } if (! ardrone_tool_exit ()) { PRINT ("Video recorder thread initialisation\n"); res = vp_api_open (&pipeline, &video_recorder_pipeline_handle); if (SUCCEED (res)) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; while (! ardrone_tool_exit () && (SUCCESS == loop)) { if (video_recorder_in_pause) { vp_os_mutex_lock (&video_recorder_mutex); record_icc.num_retries = VIDEO_MAX_RETRIES; vp_os_cond_wait (&video_recorder_condition); vp_os_mutex_unlock (&video_recorder_mutex); } if (SUCCEED (vp_api_run (&pipeline, &out))) { if ((VP_API_STATUS_PROCESSING == out.status) || (VP_API_STATUS_STILL_RUNNING == out.status)) { loop = SUCCESS; } else loop = -1; } else loop = -1; } vp_api_close (&pipeline, &video_recorder_pipeline_handle); } } PRINT ("Video recorder thread ended\n"); return (THREAD_RET)res; }
PROTO_THREAD_ROUTINE(app,argv) { vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES_MAX]; vp_os_memset( &icc, 0, sizeof(icc) ); vp_os_memset( &bpc, 0, sizeof(bpc) ); vp_os_memset( &osc, 0, sizeof(osc) ); icc.com = COM_VIDEO(); icc.buffer_size = ACQ_WIDTH*ACQ_HEIGHT*3/2; icc.socket.protocol = VP_COM_TCP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, 5555, SERVER_HOST); /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = ACQ_WIDTH; picture.height = ACQ_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT ); picture.cr_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.cb_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 ); picture.y_line_size = ACQ_WIDTH; picture.cb_line_size = ACQ_WIDTH / 2; picture.cr_line_size = ACQ_WIDTH / 2; picture.y_pad = 0; picture.c_pad = 0; bpc.picture = &picture; bpc.block_mode_enable = FALSE; bpc.y_buffer_size = ACQ_WIDTH * ACQ_HEIGHT; bpc.y_blockline_size = ACQ_WIDTH * 16; // each blockline have 16 lines bpc.y_current_size = 0; bpc.num_frames = 0; bpc.y_buf_ptr = NULL; bpc.luma_only = FALSE; bpc.cr_buf_ptr = NULL; bpc.cb_buf_ptr = NULL; osc.width = ACQ_WIDTH; osc.height = ACQ_HEIGHT; osc.bpp = 16; osc.window_width = ACQ_WIDTH; osc.window_height = ACQ_HEIGHT; osc.pic_width = ACQ_WIDTH; osc.pic_height = ACQ_HEIGHT; osc.y_size = ACQ_WIDTH*ACQ_HEIGHT; osc.c_size = (ACQ_WIDTH*ACQ_HEIGHT) >> 2; pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages++].funcs = vp_stages_input_com_funcs; stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&bpc; stages[pipeline.nb_stages++].funcs = vp_stages_buffer_to_picture_funcs; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = (void *)&osc; stages[pipeline.nb_stages++].funcs = vp_stages_output_sdl_funcs; pipeline.stages = &stages[0]; vp_api_open(&pipeline, &pipeline_handle); out.status = VP_API_STATUS_PROCESSING; while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) { } vp_api_close(&pipeline, &pipeline_handle); return EXIT_SUCCESS; }
DEFINE_THREAD_ROUTINE(drone_video_stage_thread, data) { PIPELINE_HANDLE pipeline_handle; printf("Vision thread started\n"); C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[DRONE_NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = QVGA_WIDTH; picture.height = QVGA_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT ); picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.y_line_size = QVGA_WIDTH; picture.cb_line_size = QVGA_WIDTH / 2; picture.cr_line_size = QVGA_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = QVGA_WIDTH; vec.height = QVGA_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = NULL; stages[pipeline.nb_stages].funcs = vp_video_output_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; pthread_mutex_lock(&drone_sharedDataMutex); int doRun = drone_doRun; pthread_mutex_unlock(&drone_sharedDataMutex); /* Processing of a pipeline */ if (doRun) { res = 0; res = vp_api_open(&pipeline, &pipeline_handle); if (SUCCEED(res)) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; while (doRun && (loop == SUCCESS)) { pthread_mutex_lock(&drone_sharedDataMutex); doRun = drone_doRun; pthread_mutex_unlock(&drone_sharedDataMutex); if( SUCCEED(vp_api_run(&pipeline, &out)) ) { if ((out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) { loop = SUCCESS; } } } fprintf(stderr, "BUG and WORKAROUND: vp_api_close was never called because it is buggy\n"); // vp_api_close(&pipeline, &pipeline_handle); // <- TODO: do not call this - fix this function in SDK } } vp_os_free(picture.y_buf); vp_os_free(picture.cr_buf); vp_os_free(picture.cb_buf); printf("Vision thread terminated\n"); return (THREAD_RET) 0; }