void queue_raw_data(TCPsocket sock, const char* buf, int len)
{
buffer* queued_buf = new buffer(sock);
assert(*buf == 31);
make_network_buffer(buf, len, queued_buf->raw_buffer);
queue_buffer(sock, queued_buf);
}
void init_device()
{
set_format();
request_buffer();
query_buf_and_mmap();
queue_buffer();
}
MjpegFrame *MjpegCamera::get_frame( ) {
size_t bytesused;
int bufno = dequeue_buffer(bytesused);
MjpegFrame *ret = new MjpegFrame(buffers[bufno].start, bytesused);
queue_buffer(bufno);
return ret;
}
void v4l2Capture::queue_all(void)
{
// fprintf(stderr, "v4l2Capture::queue_all()\n");
for (;;)
{
if (queue - waiton >= reqbufs.count)
return;
if (0 != queue_buffer())
return;
}
}
size_t queue_data(TCPsocket sock,const config& buf, const std::string& packet_type)
{
DBG_NW << "queuing data...\n";
buffer* queued_buf = new buffer(sock);
output_to_buffer(sock, buf, queued_buf->stream);
const size_t size = queued_buf->stream.str().size();
network::add_bandwidth_out(packet_type, size);
queue_buffer(sock, queued_buf);
return size;
}
static int cli_client_send(struct cli_client_t *tcln, const void *_buf, int size)
{
struct tcp_client_t *cln = container_of(tcln, typeof(*cln), cli_client);
int n, k;
struct buffer_t *b;
const uint8_t *buf = (const uint8_t *)_buf;
if (cln->disconnect)
return -1;
if (cln->xmit_buf) {
b = _malloc(sizeof(*b) + size);
b->size = size;
memcpy(b->buf, buf, size);
queue_buffer(cln, b);
return 0;
}
for (n = 0; n < size; n += k) {
k = write(cln->hnd.fd, buf + n, size - n);
if (k < 0) {
if (errno == EAGAIN) {
b = _malloc(sizeof(*b) + size - n);
b->size = size - n;
memcpy(b->buf, buf + n, size - n);
queue_buffer(cln, b);
triton_md_enable_handler(&cln->hnd, MD_MODE_WRITE);
break;
}
if (errno != EPIPE)
log_error("cli: write: %s\n", strerror(errno));
//disconnect(cln);
cln->disconnect = 1;
return -1;
}
}
return 0;
}
XCamReturn
V4l2Device::start ()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
// request buffer first
ret = request_buffer ();
XCAM_FAIL_RETURN (
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
"device(%s) start failed", XCAM_STR (_name));
//alloc buffers
ret = init_buffer_pool ();
XCAM_FAIL_RETURN (
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
"device(%s) start failed", XCAM_STR (_name));
//queue all buffers
for (uint32_t i = 0; i < _buf_count; ++i) {
SmartPtr<V4l2Buffer> &buf = _buf_pool [i];
XCAM_ASSERT (buf.ptr());
XCAM_ASSERT (buf->get_buf().index == i);
ret = queue_buffer (buf);
if (ret != XCAM_RETURN_NO_ERROR) {
XCAM_LOG_ERROR (
"device(%s) start failed on queue index:%d",
XCAM_STR (_name), i);
stop ();
return ret;
}
}
// stream on
if (io_control (VIDIOC_STREAMON, &_capture_buf_type) < 0) {
XCAM_LOG_ERROR (
"device(%s) start failed on VIDIOC_STREAMON",
XCAM_STR (_name));
stop ();
return XCAM_RETURN_ERROR_IOCTL;
}
_active = true;
XCAM_LOG_INFO ("device(%s) started successfully", XCAM_STR (_name));
return XCAM_RETURN_NO_ERROR;
}
void V4L2UpscaledInputAdapter::run_thread( ) {
int bufno;
size_t bufsize;
RawFrame *out;
for (;;) {
bufno = dequeue_buffer(bufsize);
out = new RawFrame(1920, 1080, RawFrame::CbYCrY8422);
if (out_pipe.can_put( )) {
do_upscale(out, (uint8_t *) buffers[bufno].start);
out_pipe.put(out);
} else {
fprintf(stderr, "V4L2 in: dropping input frame on floor\n");
delete out;
}
queue_buffer(bufno);
}
}
int main(int argc, char **argv)
{
int shmid;
int i,j;
char in_str[16];
process_arguments(argc, argv);
/* open the camera device */
if( (camera_fd = open(psz_video_dev, O_RDWR)) < 0 )
{
char error_buf[256];
sprintf(error_buf, "open() %s", psz_video_dev);
perror(error_buf);
exit(-1);
}
get_caps();
get_format();
if( b_verbose ) printf("Device opened.\n");
if( b_verbose )
{
printf("Video device:\t\t%s\n", psz_video_dev);
print_caps();
print_format();
printf("Ouput directory:\t%s\n", psz_output_dir);
printf("Image format:\t\t%s\n",str_formats[e_outfmt]);
printf("\n");
printf("Opening device %s\n", psz_video_dev);
if( b_named_filename )
{
printf("Ouput filename:\t%s\n", psz_output_filename);
}
else if( b_named_pipe )
{
printf("Using named pipe %s\n", psz_named_pipe);
}
if( b_shared_mem )
printf("Using shared memory. key = %i\n", shared_mem_key);
}
if( b_printinfo )
{
printf("Device info:\n");
print_caps();
print_format();
close(camera_fd);
exit(EXIT_SUCCESS);
}
(void)signal(SIGINT, exit_program);
if( b_shared_mem && b_named_pipe )
{
printf("WARNING: shared memory and named pipe can't be used together. Use more instances of camshot. Defaulting to named pipe.\n");
b_shared_mem = 0;
}
if( b_named_pipe )
{
int ret_val = mkfifo(psz_named_pipe, 0666);
if ((ret_val == -1) && (errno != EEXIST)) {
perror("Error creating the named pipe");
exit(EXIT_FAILURE);
}
}
if( req_width && req_height )
{
if( b_verbose )
printf("Trying to set resolution to %ux%u.\n", req_width, req_height);
if( set_width_height(req_width,req_height) == -1 )
printf("Unable to set the desired resolution.\n");
else
if( b_verbose )
printf("Resolution set to %ux%u\n", req_width, req_height);
} else {
get_format();
req_width = camera_format.fmt.pix.width;
req_height = camera_format.fmt.pix.height;
}
if( b_shared_mem )
{
if((shmid = shmget(shared_mem_key, req_width*req_height*3, IPC_CREAT | 0666)) < 0) {
perror("Error getting shared memory id");
exit(EXIT_FAILURE);
}
if((p_shm = (uint8_t *)shmat(shmid, NULL, 0)) == (void *) -1) {
perror("Error getting shared memory ptr");
exit(EXIT_FAILURE);
}
shm_sem = semget((key_t)shared_mem_key, 1, IPC_CREAT | 0666);
sem_set(&shm_sem);
if( b_verbose )
printf("Shared memory ID: %i\nSemaphore ID: %i\n", shmid, shm_sem);
}
total_buffers = req_mmap_buffers(2);
/* start the capture */
streaming_on();
/* let the camera self adjust by 'ignoring' 200 complete buffer queues */
printf("Letting the camera automaticaly adjust the picture:");
for(i=0; i<AUTO_ADJUST_TURNS; i++)
{
for(j=0; j<total_buffers; j++)
{
int ready_buf = dequeue_buffer();
/* don't queue the last buffers */
if( i<AUTO_ADJUST_TURNS-1 )
queue_buffer(ready_buf);
}
printf(".");
fflush(stdout);
}
printf("Done.\n");
if( b_shared_mem || b_named_pipe )
{
pthread_create(&stream_thread, NULL, &stream_func, NULL);
while(1)
{
pthread_join(stream_thread, NULL);
}
}
else
{
pthread_create(&capture_thread, NULL, &capture_func, NULL);
}
if( b_named_filename )
{
usleep(200000);
pthread_mutex_lock(&cond_mutex);
pthread_cond_signal(&condition);
pthread_mutex_unlock(&cond_mutex);
usleep(200000);
exit_program(SIGINT);
fflush(stdout);
return 0;
}
while( in_str[0] != 'q' )
{
printf("Command (h for help): ");
fflush(stdout);
if( fgets(in_str, 16, stdin) == NULL )
{
printf("Got NULL! Try again.\n");
continue;
}
switch(in_str[0])
{
case 'x':
pthread_mutex_lock(&cond_mutex);
pthread_cond_signal(&condition);
pthread_mutex_unlock(&cond_mutex);
break;
case 'h':
printf("\nCommands:\n");
printf("\tx\tCapture a picture from camera.\n");
printf("\th\tPrints this help.\n");
printf("\tq\tQuits the program.\n");
printf("\n");
break;
case 'q':
case '\n':
break;
default:
fprintf(stderr, "Unknown command %c\n", in_str[0]);
break;
}
}
/* Clean up */
exit_program(SIGINT);
return 0;
}
void MjpegCamera::get_frame_to(MjpegFrame *target) {
size_t bytesused;
int bufno = dequeue_buffer(bytesused);
target->assign(buffers[bufno].start, bytesused);
queue_buffer(bufno);
}
void queue_file(TCPsocket sock, const std::string& filename)
{
buffer* queued_buf = new buffer(sock);
queued_buf->config_error = filename;
queue_buffer(sock, queued_buf);
}
void MjpegCamera::discard_frame( ) {
size_t bytesused; /* dummy here */
int bufno = dequeue_buffer(bytesused);
queue_buffer(bufno);
}
static void * comp_proc(void * para)
{
int i, j;
int fd;
int channel;
int n_buffers = 0;
unsigned int length, offset;
int index, num;
struct buffer_av buf_av;
int result;
struct pollfd pfd;
unsigned int buf_index;
unsigned int buf_num;
char * packet_addr;
struct packet_header pkt_header;
Query_Buf_Res * buffers = NULL; //用于保存获取视频数据
Spct_Data comp_data;
int got_video[CHS_PER_CARD];
int got_audio[CHS_PER_CARD];
struct timeval v_time_stamp[CHS_PER_CARD];
struct timeval a_time_stamp[CHS_PER_CARD];
unsigned int last_vtstamp[CHS_PER_CARD];
unsigned int last_atstamp[CHS_PER_CARD];
unsigned int duration;
DebugPrintf("thread compress\n");
Ip_Cam_Device * ipcam = (Ip_Cam_Device *) para;
memset(&buf_av, 0, sizeof(buf_av));
memset(&got_video, 0, sizeof(got_video));
memset(&got_audio, 0, sizeof(got_audio));
memset(&last_vtstamp, 0, sizeof(last_vtstamp));
memset(&last_atstamp, 0, sizeof(last_atstamp));
fd = ipcam->comp_fd;
action_fd = fd;
n_buffers = request_buffer(fd);
buffers = calloc(n_buffers, sizeof(* buffers));
if(!buffers)
EXIT("Out of memory.");
for(i = 0; i < n_buffers; ++i)
{
if(query_buffer(fd, i, &length, &offset) != 0)
EXIT("VIDIOC_QUERYBUF");
buffers[i].length = length;
buffers[i].start = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
DebugPrintf("buffers[%d].start = 0x%x\n",i, buffers[i].start);
if(MAP_FAILED == buffers[i].start)
EXIT("mmap");
}
for(index = 0; index < n_buffers; index++)
if(queue_buffer(fd, index) != 0)
EXIT("VIDIOC_QBUF");
if(streaming_on(fd) != 0)
EXIT("VIDIOC_STREAMON");
DebugPrintf("card stream on================================\n");
pfd.fd = fd;
pfd.events = POLLIN;
int comp_proc_count = 0;
//set_action(fd, catch_sen); // fd threshold time
/*检测ipcam是否处于运行状态*/
while(ipcam->status == CAM_STATUS_RUN)
{
comp_proc_count++;
/*定时打印信息*/
if(comp_proc_count == 3000)
{
comp_proc_count = 0;
PrintScreen("\n----- comp_proc thread running -----\n");
}
//IsSetaction(fd);
/*一个结构体，函数阻塞时间为15s*/
result = poll(&pfd, 1, 15000);
/*函数调用失败*/
if(result < 0)
DebugPrintf("pool ing errro ==================\n");
/*在规定时间内没有检测到可读套接字*/
if(result == 0)
{
DebugPrintf("pool ing time out --------------\n");
exit(1);
}
if(result < 0)
continue;
if(result == 0)
continue;
dequeue_buffer(fd, &buf_av);
buf_index = buf_av.buf_index;
buf_num = buf_av.length;
for(i = 0; i < CHS_PER_CARD; i++)
{
index = buf_index & 0xff;
num = buf_num & 0xff;
buf_index >>= 8;
buf_num >>= 8;
if(index != 0xff)
{
/*DATA PACKET*/
channel = i;
for(j = 0, packet_addr = buffers[index].start; j < num; j++)
{
/*s数据包处理，动态处理就在此实现*/
parse_packet(&packet_addr, &pkt_header);
//pkt_header.motion_addr, 4 * 9
/*捕捉到动作*/
if(pkt_header.motion_flag)
{
#if RELEASE_MODE
#else
PrintScreen("\n-------------receive a motion------------\n\n");
#endif
catchonemotion = 1;
is_action = 1;
}
if (pkt_header.videolost_flag)
{
//DebugPrintf("video lost\n");
}
if(pkt_header.audio_flag)
{//length
if(!got_audio[channel])
{
got_audio[channel] = 1;
//a_time_stamp[channel] = buf_av.timestamp;
a_time_stamp[channel].tv_usec = ((pkt_header.audio_timestamp % 32768) * 1000ULL * 1000ULL) >> 15;
a_time_stamp[channel].tv_sec = (pkt_header.audio_timestamp >> 15) + (a_time_stamp[channel].tv_usec / 1000000);
a_time_stamp[channel].tv_usec %= 1000000;
}
else
{
duration = pkt_header.audio_timestamp - last_atstamp[channel];
a_time_stamp[channel].tv_usec += ((duration % 32768) * 1000ULL * 1000ULL) >> 15;
a_time_stamp[channel].tv_sec += (duration >> 15) + (a_time_stamp[channel].tv_usec / 1000000);
a_time_stamp[channel].tv_usec %= 1000000;
}
last_atstamp[channel] = pkt_header.audio_timestamp;
//DebugPrintf("audio frame\n");
comp_data.channel = channel;
comp_data.type = DATA_AUDIO;
comp_data.flags = 0;
comp_data.timestamp = a_time_stamp[channel];
comp_data.size = pkt_header.audio_length;
comp_data.data = pkt_header.audio_addr;
ipcam->fun(ipcam->datahandler, &comp_data);
}
if(pkt_header.video_flag)
{
if(!got_video[channel])
{
got_video[channel] = 1;
//v_time_stamp[channel] = buf_av.timestamp;
v_time_stamp[channel].tv_usec = ((pkt_header.video_timestamp % 32768) * 1000ULL * 1000ULL) >> 15;
v_time_stamp[channel].tv_sec = (pkt_header.video_timestamp >> 15) + (v_time_stamp[channel].tv_usec / 1000000);
v_time_stamp[channel].tv_usec %= 1000000;
}
else
{
duration = pkt_header.video_timestamp - last_vtstamp[channel];
v_time_stamp[channel].tv_usec += ((duration % 32768) * 1000ULL * 1000ULL) >> 15;
v_time_stamp[channel].tv_sec += (duration >> 15) + (v_time_stamp[channel].tv_usec / 1000000);
v_time_stamp[channel].tv_usec %= 1000000;
}
last_vtstamp[channel] = pkt_header.video_timestamp;
comp_data.channel = channel;
comp_data.type = DATA_VIDEO;
comp_data.flags = pkt_header.video_type;
comp_data.timestamp = v_time_stamp[channel];
comp_data.size = pkt_header.video_length;
comp_data.data = pkt_header.video_addr;
ipcam->fun(ipcam->datahandler, &comp_data);
}
static void
mainloop(void)
{
unsigned int count;
int buf_idx[MAX_DEVICES];
count = 100;
while (count-- > 0) {
for (;;) {
fd_set fds;
struct timeval tv;
int r;
int i;
for (i = 0; i < n_devices; ++i)
{
FD_ZERO(&fds);
FD_SET(devices[i].fd, &fds);
/* Timeout. */
tv.tv_sec = 2;
tv.tv_usec = 0;
r = select(devices[i].fd + 1, &fds, NULL, NULL, &tv);
if (-1 == r) {
if (EINTR == errno)
continue;
errno_exit("select");
}
if (0 == r) {
fprintf(stderr, "select timeout\n");
exit (EXIT_FAILURE);
}
//gettimeofday(&tv, NULL);
//printf("buffer ready %s %ld.%03ld\n", devices[i].dev_name, tv.tv_sec, tv.tv_usec/1000);
}
struct thr_data tdata[MAX_DEVICES];
for (i = 0; i < n_devices; ++i)
{
//buf_idx[i] = read_frame(&devices[i]);
buf_idx[i] = -1;
tdata[i].dev = &devices[i];
pthread_create(&(tdata[i].thr), NULL, read_frame_thr, &tdata[i]);
}
for (i = 0; i < n_devices; ++i)
{
pthread_join(tdata[i].thr, NULL);
buf_idx[i] = tdata[i].rval;
}
for (i = 0; i < n_devices; ++i)
{
if (buf_idx[i] >= 0)
{
queue_buffer(&devices[i], buf_idx[i]);
}
}
/* EAGAIN - continue select loop. */
}
}
}
int main (int argc,char *argv[])
{
int videofd1 = open("/dev/video0",O_RDWR);
int videofd2 = open("/dev/video0",O_RDWR);
IDirectFBSurface *SurfaceHandle;
IDirectFBSurface *SurfaceHandle2;
void *ptr,*ptr2;
int pitch,pitch2;
int colour_palette[256];
int colour_palette2_real[256]; /* random... */
int *colour_palette2 = colour_palette2_real;
int is_lut8;
is_lut8 = (argc > 1 && !strcmp (argv[1], "both"));
memset(&colour_palette,0x0,4*256);
//memset(&colour_palette[1],0xff,255*4);
colour_palette[0] = 0xff000000; // black
colour_palette[1] = 0xffff0000; // red
colour_palette[2] = 0xff00ff00; // green
colour_palette[3] = 0xff0000ff; // blue
colour_palette[4] = 0xffffffff; // white
colour_palette[5] = 0x80808000; // half-transp yellow
colour_palette[6] = 0x00000000; // transp black
if (videofd1 < 0)
perror("Couldn't open video device 1\n");
if (videofd2 < 0)
perror("Couldn't open video device 2\n");
v4l2_list_outputs (videofd1);
fb_make_transparent();
init_dfb(&SurfaceHandle,is_lut8);
init_dfb(&SurfaceHandle2,1);
v4l2_set_output_by_name (videofd1, "RGB1");
v4l2_set_output_by_name (videofd2, "RGB2");
init_v4l(videofd1,0,0,1280,720,is_lut8);
init_v4l(videofd2,0,0,1280,720,1);
printf("%s:%d\n",__FUNCTION__,__LINE__);
// memcpy (colour_palette, colour_palette2, sizeof (colour_palette));
colour_palette2 = colour_palette;
{
int coords = 60;
int size = 100;
// clear
if (!is_lut8) SurfaceHandle->Clear (SurfaceHandle, 0x00, 0x00, 0x00, 0x00);
else {
SurfaceHandle->SetColorIndex (SurfaceHandle, 0x6);
SurfaceHandle->FillRectangle (SurfaceHandle, 0, 0, 600, 600);
}
// White
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x4);
else SurfaceHandle->SetColor (SurfaceHandle, 0xff, 0xff, 0xff, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Red
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x1);
else SurfaceHandle->SetColor (SurfaceHandle, 0xff, 0x00, 0x00, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Green
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x2);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0xff, 0x00, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// Blue
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x3);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0x00, 0xff, 0xff);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// half transp yellow
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x5);
else SurfaceHandle->SetColor (SurfaceHandle, 0x80, 0x80, 0x00, 0x80);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
// transp
if (is_lut8) SurfaceHandle->SetColorIndex (SurfaceHandle, 0x6);
else SurfaceHandle->SetColor (SurfaceHandle, 0x00, 0x00, 0x00, 0x00);
SurfaceHandle->FillRectangle (SurfaceHandle, coords, coords, size, size);
coords += size;
}
{
int xcoords = 60 + (100 * 6), ycoords = 60;
int size = 100;
// clear
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x6);
SurfaceHandle2->FillRectangle (SurfaceHandle2, 220, 220, 440, 440);
// transp
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x6);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// half transp yellow
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x5);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Blue
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x3);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Green
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x2);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// Red
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x1);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
// White
SurfaceHandle2->SetColorIndex (SurfaceHandle2, 0x4);
SurfaceHandle2->FillRectangle (SurfaceHandle2, xcoords, ycoords, size, size);
xcoords -= size; ycoords += size;
}
DFBCHECK (SurfaceHandle->Lock (SurfaceHandle, DSLF_READ, &ptr, &pitch));
DFBCHECK (SurfaceHandle2->Lock (SurfaceHandle2, DSLF_READ, &ptr2, &pitch2));
printf("%s:%d\n",__FUNCTION__,__LINE__);
zorder(videofd2,V4L2_CID_STM_Z_ORDER_RGB2,1);
zorder(videofd1,V4L2_CID_STM_Z_ORDER_RGB1,2);
queue_buffer( videofd1, ptr, (is_lut8 ? colour_palette : 0), 0ULL);
stream_on( videofd1 );
getchar();
queue_buffer( videofd2, ptr2, colour_palette2, 0ULL);
printf("%s:%d\n",__FUNCTION__,__LINE__);
stream_on( videofd2 );
printf("%s:%d\n",__FUNCTION__,__LINE__);
getchar();
zorder(videofd2,V4L2_CID_STM_Z_ORDER_RGB2,2);
zorder(videofd1,V4L2_CID_STM_Z_ORDER_RGB1,1);
fprintf(stderr,"Press Return/Enter to quit\n");
getchar();
// This seems to dequeue all buffers too, but that's what the spec says
// so this is ok.
stream_off( videofd1 );
stream_off( videofd2 );
deinit_dfb();
close(videofd1);
return 0;
}
void V4L2UpscaledInputAdapter::queue_all_buffers( ) {
int i;
for (i = 0; i < n_buffers; i++) {
queue_buffer(i);
}
}
void MjpegCamera::queue_all_buffers( ) {
int i;
for (i = 0; i < n_buffers; i++) {
queue_buffer(i);
}
}
void *stream_func(void *ptr)
{
unsigned char *rgb_buffer;
int ready_buf;
char cur_name[64];
int i;
if( b_shared_mem )
{
rgb_buffer = p_shm;
}
else
{
rgb_buffer = (unsigned char *)malloc(req_width*req_height*3);
}
for(i=0; i<total_buffers; i++)
{
queue_buffer(i);
}
for(;;)
{
/* get the idx of ready buffer */
for(i=0; i<total_buffers; i++)
{
/* Check if the thread should stop. */
if( stream_finish ) return NULL;
ready_buf = dequeue_buffer();
if( b_verbose )
{
printf("Buffer %d ready. Length: %uB\n", ready_buf, image_buffers[ready_buf].length);
}
switch( check_pixelformat() )
{
case V4L2_PIX_FMT_YUYV:
/* convert data to rgb */
if( b_shared_mem )
sem_down(&shm_sem);
if( convert_yuv_to_rgb_buffer(
(unsigned char *)(image_buffers[ready_buf].start),
rgb_buffer, req_width, req_height) == 0 )
{
if( b_verbose )
{
printf("\tConverted to rgb.\n");
}
}
if( b_shared_mem )
sem_up(&shm_sem);
break;
default:
print_pixelformat(stderr);
fprintf(stderr,"\n");
return NULL;
}
/* make the image */
/* create the file name */
if( b_named_pipe )
sprintf(cur_name, "%s", psz_named_pipe);
switch( e_outfmt )
{
case FORMAT_BMP:
if( b_shared_mem )
{
printf("Unsupported!\n");
break;
}
make_bmp(rgb_buffer,
cur_name,
req_width,
req_height);
break;
case FORMAT_RGB:
if( b_shared_mem )
{
/* The buffer is already rgb :) */
break;
}
make_rgb(rgb_buffer,
cur_name,
req_width,
req_height);
break;
default:
fprintf(stderr, "Not supported format requested!\n");
break;
}
queue_buffer(ready_buf);
}
}
return NULL;
}
void *capture_func(void *ptr)
{
unsigned char *rgb_buffer;
int ready_buf;
char cur_name[64];
int i;
struct timeval timestamp;
if( b_shared_mem )
{
rgb_buffer = p_shm;
}
else
{
rgb_buffer = (unsigned char *)malloc(req_width*req_height*3);
}
for(;;)
{
/* Wait for the start condition */
pthread_mutex_lock(&cond_mutex);
pthread_cond_wait(&condition, &cond_mutex);
pthread_mutex_unlock(&cond_mutex);
/* queue one buffer and 'refresh it' */
/* @todo Change 2 to some #define */
for(i=0; i<2; i++)
{
queue_buffer(i);
}
for(i=0; i<2 - 1; i++)
{
dequeue_buffer();
}
/* get the idx of ready buffer */
ready_buf = dequeue_buffer();
if( b_verbose )
{
printf("Buffer %d ready. Length: %uB\n", ready_buf, image_buffers[ready_buf].length);
}
switch( check_pixelformat() )
{
case V4L2_PIX_FMT_YUYV:
/* convert data to rgb */
if( convert_yuv_to_rgb_buffer(
(unsigned char *)(image_buffers[ready_buf].start),
rgb_buffer, req_width, req_height) == 0 )
{
if( b_verbose )
{
printf("\tConverted to rgb.\n");
}
}
break;
default:
print_pixelformat(stderr);
fprintf(stderr,"\n");
return NULL;
}
timestamp = query_buffer(0);
/* make the image */
/* create the file name */
if( b_named_filename )
{
sprintf(cur_name, "%s%s", psz_output_dir, psz_output_filename);
}
else if( !b_named_pipe )
sprintf(cur_name, "%scamshot_%lu.bmp", psz_output_dir, timestamp.tv_sec);
else
sprintf(cur_name, "%s", psz_named_pipe);
switch( e_outfmt )
{
case FORMAT_BMP:
make_bmp(rgb_buffer,
cur_name,
req_width,
req_height);
break;
case FORMAT_RGB:
make_rgb(rgb_buffer,
cur_name,
req_width,
req_height);
break;
default:
fprintf(stderr, "Not supported format requested!\n");
break;
}
}
return NULL;
}
static void* audio_start(void *aux)
{
audio_fifo_t *af = aux;
audio_fifo_data_t *afd;
unsigned int frame = 0;
ALCdevice *device = NULL;
ALCcontext *context = NULL;
ALuint buffers[NUM_BUFFERS];
ALuint source;
ALint processed;
ALenum error;
ALint rate;
ALint channels;
device = alcOpenDevice(NULL); /* Use the default device */
if (!device) error_exit("failed to open device");
context = alcCreateContext(device, NULL);
alcMakeContextCurrent(context);
alListenerf(AL_GAIN, 1.0f);
alDistanceModel(AL_NONE);
alGenBuffers((ALsizei)NUM_BUFFERS, buffers);
alGenSources(1, &source);
/* First prebuffer some audio */
queue_buffer(source, af, buffers[0]);
queue_buffer(source, af, buffers[1]);
queue_buffer(source, af, buffers[2]);
for (;;) {
alSourcePlay(source);
for (;;) {
/* Wait for some audio to play */
do {
alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
usleep(100);
} while (!processed);
/* Remove old audio from the queue.. */
alSourceUnqueueBuffers(source, 1, &buffers[frame % 3]);
/* and queue some more audio */
afd = audio_get(af);
alGetBufferi(buffers[frame % 3], AL_FREQUENCY, &rate);
alGetBufferi(buffers[frame % 3], AL_CHANNELS, &channels);
if (afd->rate != rate || afd->channels != channels) {
printf("rate or channel count changed, resetting\n");
free(afd);
break;
}
alBufferData(buffers[frame % 3],
afd->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
afd->samples,
afd->nsamples * afd->channels * sizeof(short),
afd->rate);
free(afd);
alSourceQueueBuffers(source, 1, &buffers[frame % 3]);
if ((error = alcGetError(device)) != AL_NO_ERROR) {
printf("openal al error: %d\n", error);
exit(1);
}
frame++;
}
/* Format or rate changed, so we need to reset all buffers */
alSourcei(source, AL_BUFFER, 0);
alSourceStop(source);
/* Make sure we don't lose the audio packet that caused the change */
alBufferData(buffers[0],
afd->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
afd->samples,
afd->nsamples * afd->channels * sizeof(short),
afd->rate);
alSourceQueueBuffers(source, 1, &buffers[0]);
queue_buffer(source, af, buffers[1]);
queue_buffer(source, af, buffers[2]);
frame = 0;
}
}
static void* audio_start(void *aux)
{
audio_fifo_t *af = aux;
audio_fifo_data_t *afd;
ALCdevice *device = NULL;
ALCcontext *context = NULL;
ALuint buffers[NUM_BUFFERS];
ALint processed;
ALenum error;
ALint rate;
ALint channels;
device = alcOpenDevice(NULL); /* Use the default device */
if (!device) error_exit("failed to open device");
context = alcCreateContext(device, NULL);
alcMakeContextCurrent(context);
alListenerf(AL_GAIN, 1.0f);
alDistanceModel(AL_NONE);
alGenBuffers((ALsizei)NUM_BUFFERS, buffers);
alGenSources(1, &source);
/* First prebuffer some audio */
queue_buffer(source, af, buffers[0]);
queue_buffer(source, af, buffers[1]);
queue_buffer(source, af, buffers[2]);
for (;;) {
alSourcePlay(source);
for (;;) {
/* Wait for some audio to play */
alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
if (processed <= 0)
{
usleep(200);
continue;
}
/* Remove old audio from the queue.. */
ALuint buffer;
alSourceUnqueueBuffers(source, 1, &buffer);
/* and queue some more audio */
afd = audio_get(af);
alGetBufferi(buffer, AL_FREQUENCY, &rate);
alGetBufferi(buffer, AL_CHANNELS, &channels);
if (afd->rate != rate || afd->channels != channels)
{
log_debug("openal","audio_start","rate or channel count changed, resetting");
break;
}
alBufferData(buffer,
afd->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
afd->samples,
afd->nsamples * afd->channels * sizeof(int16_t),
afd->rate);
free(afd);
ALenum error = alGetError();
if (error != AL_NO_ERROR)
{
log_error("openal","audio_start","Error buffering: %s", alGetString(error));
return NULL;
}
alSourceQueueBuffers(source, 1, &buffer);
error = alGetError();
if (alGetError() != AL_NO_ERROR)
{
log_error("openal","audio_start","Error queing buffering: %s", alGetString(error));
return NULL;
}
alGetSourcei(source, AL_SOURCE_STATE, &processed);
if (processed != AL_PLAYING)
{
// Resume playing
alSourcePlay(source);
}
if ((error = alcGetError(device)) != AL_NO_ERROR) {
log_error("openal","audio_start","Error queing buffering: %s", alGetString(error));
exit(1);
}
}
/* Format or rate changed, so we need to reset all buffers */
alSourcei(source, AL_BUFFER, 0);
alSourceStop(source);
/* Make sure we don't lose the audio packet that caused the change */
alBufferData(buffers[0],
afd->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
afd->samples,
afd->nsamples * afd->channels * sizeof(short),
afd->rate);
free(afd);
alSourceQueueBuffers(source, 1, &buffers[0]);
queue_buffer(source, af, buffers[1]);
queue_buffer(source, af, buffers[2]);
}
}
