static void* Raw1394EventThread( vlc_object_t *p_this )
{
event_thread_t *p_ev = (event_thread_t *) p_this;
access_t *p_access = (access_t *) p_ev->p_access;
access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
int result = 0;
int canc = vlc_savecancel ();
AVCPlay( p_access, p_sys->i_node );
while( vlc_object_alive (p_sys->p_ev) )
{
while( ( result = poll( &(p_sys->raw1394_poll), 1, 200 ) ) < 0 )
{
if( !( errno == EAGAIN || errno == EINTR ) )
{
perror( "error: raw1394 poll" );
msg_Err( p_access, "retrying device raw1394" );
}
}
if( !vlc_object_alive (p_sys->p_ev) )
break;
if( result > 0 && ( ( p_sys->raw1394_poll.revents & POLLIN )
|| ( p_sys->raw1394_poll.revents & POLLPRI ) ) )
result = raw1394_loop_iterate( p_sys->p_raw1394 );
}
AVCStop( p_access, p_sys->i_node );
vlc_restorecancel (canc);
return NULL;
}
static void* Raw1394EventThread( void *obj )
{
event_thread_t *p_ev = (event_thread_t *)obj;
access_t *p_access = (access_t *) p_ev->p_access;
access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
int result = 0;
int canc = vlc_savecancel();
AVCPlay( p_access, p_sys->i_node );
vlc_cleanup_push( Raw1394EventThreadCleanup, p_ev );
vlc_restorecancel( canc );
for( ;; )
{
while( ( result = poll( &p_sys->raw1394_poll, 1, -1 ) ) < 0 )
{
if( errno != EINTR )
msg_Err( p_access, "poll error: %s", vlc_strerror_c(errno) );
}
if( result > 0 && ( ( p_sys->raw1394_poll.revents & POLLIN )
|| ( p_sys->raw1394_poll.revents & POLLPRI ) ) )
{
canc = vlc_savecancel();
result = raw1394_loop_iterate( p_sys->p_raw1394 );
vlc_restorecancel( canc );
}
}
vlc_cleanup_pop();
vlc_assert_unreachable();
}
static int do_iso_listen(struct raw1394_handle *handle, int channel)
{
struct sync_cb_data sd = { 0, 0 };
struct raw1394_reqhandle rh = { (req_callback_t)_raw1394_sync_cb, &sd };
int err;
struct raw1394_request req;
CLEAR_REQ(&req);
req.type = RAW1394_REQ_ISO_LISTEN;
req.generation = handle->generation;
req.misc = channel;
req.tag = ptr2int(&rh);
req.recvb = ptr2int(handle->buffer);
req.length = HBUF_SIZE;
err = write(handle->fd, &req, sizeof(req));
while (!sd.done) {
if (err < 0) return err;
err = raw1394_loop_iterate(handle);
}
switch (sd.errcode) {
case RAW1394_ERROR_ALREADY:
errno = EALREADY;
return -1;
case RAW1394_ERROR_INVALID_ARG:
errno = EINVAL;
return -1;
default:
errno = 0;
return sd.errcode;
}
}
void firewire_source::poll()
{
envir().taskScheduler().turnOffBackgroundReadHandling(
raw1394_get_fd(handle_.get()));
if (raw1394_loop_iterate(handle_.get()) < 0)
handleClosure(this);
else
FramedSource::afterGetting(this);
}
// This function checks if there is a pending read on the IEEE-1394 bus,
// which could include a bus reset
void FirewirePort::PollEvents(void)
{
fd_set fds;
struct timeval timeout = {0, 0};
int fd = raw1394_get_fd(handle);
FD_ZERO(&fds);
FD_SET(fd, &fds);
int ret = select(fd+1, &fds, 0, 0, &timeout);
if (ret > 0)
raw1394_loop_iterate(handle);
}
/*
loop in the background while capturing to call the iso handle regularly
*/
void *dcam_capture_thread( void *data )
{
dcam_handle_t dcamhandle = (dcam_handle_t)data;
pthread_cleanup_push( cleanup_handler, data );
while( dcamhandle->capture_running )
{
raw1394_loop_iterate( dcamhandle->raw1394handle );
}
pthread_cleanup_pop( 0 );
return 0;
}
int raw1394_iso_xmit_write(raw1394handle_t handle, unsigned char *data, unsigned int len,
unsigned char tag, unsigned char sy)
{
struct raw1394_iso_status *stat = &handle->iso_status;
struct raw1394_iso_packets packets;
struct raw1394_iso_packet_info info;
if(handle->iso_mode != ISO_XMIT || handle->iso_xmit_handler != NULL) {
errno = EINVAL;
return -1;
}
/* wait until buffer space is available */
while(handle->iso_status.n_packets == 0) {
/* if the file descriptor has been set non-blocking,
return immediately */
if(fcntl(handle->fd, F_GETFL) & O_NONBLOCK) {
errno = EAGAIN;
return -1;
}
if(raw1394_loop_iterate(handle)) {
return -1;
}
}
/* copy the data to the packet buffer */
info.offset = handle->next_packet * handle->iso_buf_stride;
info.len = len;
info.tag = tag;
info.sy = sy;
memcpy(handle->iso_buffer + info.offset, data, len);
packets.n_packets = 1;
packets.infos = &info;
if(ioctl(handle->fd, RAW1394_IOC_ISO_XMIT_PACKETS, &packets))
return -1;
stat->n_packets--;
handle->next_packet = (handle->next_packet + 1) % stat->config.buf_packets;
if(stat->xmit_cycle != -1)
stat->xmit_cycle = (stat->xmit_cycle + 1) % 8000;
return 0;
}
int main(int argc, char** argv)
{
int rc; /**< return code */
int port = 0; /*!< fw handle port number */
// parse command line (port number)
opterr = 0; // getopt no err output
const char short_options[] = "p:";
int next_opt;
do {
next_opt = getopt(argc, argv, short_options);
switch(next_opt)
{
case 'p':
port = atoi(optarg);
break;
case '?':
std::cerr << "Invalid argument" << std::endl;
break;
default:
break;
}
}
while(next_opt != -1);
// Setup signal handler to exit on Ctrl-C
signal(SIGINT, signal_handler);
// ----- Get handle and set port for the handle -------
// create handle
handle = raw1394_new_handle();
if (handle == NULL) {
std::cerr << "**** Error: could not create 1394 handle " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// get port number & sanity check
int numPorts = raw1394_get_port_info(handle, NULL, 0);
if (port < 0 || port >= numPorts) {
std::cerr << "Invalid port number" << std::endl;
return EXIT_FAILURE;
}
// let user to choose which port to use
rc = raw1394_set_port(handle, 0);
if (rc) {
std::cerr << "**** Error: failed to set port " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// -------- Set FireWire bus reset handler --------
// set bus reset handler
bus_reset_handler_t old_bus_reset_handler;
old_bus_reset_handler = raw1394_set_bus_reset_handler(handle, my_bus_reset_handler);
// ----------------------------------------------------------------------------
// Start tutorial 2 arm server
// ----------------------------------------------------------------------------
// -------- Register arm register to handle arm request --------
const nodeaddr_t arm_start_addr = 0xffffff000000; // arm start address
const size_t arm_length = 4; // arm length to register
// arm initial buffer
byte_t arm_init_buffer[arm_length];
memset(arm_init_buffer, 0x02, arm_length); // set inital value to all 0x02
// setup arm request handle
raw1394_arm_reqhandle arm_reqhandle;
char my_arm_callback_context[] = "my_arm_callback_context";
arm_reqhandle.pcontext = my_arm_callback_context;
arm_reqhandle.arm_callback = my_arm_req_callback;
int access_mode = RAW1394_ARM_WRITE|RAW1394_ARM_READ; // allow read and write transaction
rc = raw1394_arm_register(handle, // fw handle
arm_start_addr, // arm start address
arm_length * 4, // arm_length quadlet * 4 to bytes
arm_init_buffer, // arm init buffer value
(octlet_t) &arm_reqhandle, // arm request handler
access_mode, // access permission
access_mode, // client handler will be notified
0); // client handler will need to handle these transactions
if (rc) {
std::cerr << "**** Error: failed to setup arm register, error " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// -------- Read from this arm buffer ---------
// NOTE: this is a simple way to test if
const size_t arm_read_size = 4;
byte_t arm_read_buffer[arm_read_size];
rc = raw1394_arm_get_buf(handle, arm_start_addr, arm_read_size, arm_read_buffer);
if (rc) {
std::cerr << "**** Error: failed to read arm register, error " << strerror(errno) << std::endl;
return EXIT_FAILURE;
} else {
// if success then print value
std::cout << "ARM buffer read value: \n";
for (size_t i = 0; i < arm_read_size; i++) {
std::cout << std::hex << " " << (int)arm_read_buffer[i];
}
std::cout << std::endl;
}
// -------- Set value to this arm buffer ---------
const size_t arm_write_size = 4;
byte_t arm_write_buffer[arm_write_size] = {0x11, 0x22, 0x33, 0x44};
rc = raw1394_arm_set_buf(handle, arm_start_addr, arm_write_size, arm_write_buffer);
if (rc) {
std::cerr << "**** Error: failed to set arm register, error " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// --------- Now read the value back from buffer ------
rc = raw1394_arm_get_buf(handle, arm_start_addr, arm_read_size, arm_read_buffer);
if (rc) {
std::cerr << "**** Error: failed to read arm register, error " << strerror(errno) << std::endl;
return EXIT_FAILURE;
} else {
// if success then print value
std::cout << "ARM buffer read value: \n";
for (size_t i = 0; i < arm_read_size; i++) {
std::cout << std::hex << " " << (int)arm_read_buffer[i];
}
std::cout << std::endl;
}
// --------- Infinite raw1394 event loop ----------
std::cout << "--------- Now start arm server -----------" << std::endl;
std::cout << " node id = " << raw1394_get_local_id(handle) << std::endl;
while (true)
{
raw1394_loop_iterate(handle);
}
// clean up & exit
raw1394_destroy_handle(handle);
return EXIT_SUCCESS;
}
static GstFlowReturn
gst_hdv1394src_create (GstPushSrc * psrc, GstBuffer ** buf)
{
GstHDV1394Src *dv1394src = GST_HDV1394SRC (psrc);
struct pollfd pollfds[2];
pollfds[0].fd = raw1394_get_fd (dv1394src->handle);
pollfds[0].events = POLLIN | POLLERR | POLLHUP | POLLPRI;
pollfds[1].fd = READ_SOCKET (dv1394src);
pollfds[1].events = POLLIN | POLLERR | POLLHUP | POLLPRI;
/* allocate a 2048 samples buffer */
dv1394src->outdata = g_malloc (2048 * 188);
dv1394src->outoffset = 0;
GST_DEBUG ("Create...");
while (TRUE) {
int res = poll (pollfds, 2, -1);
GST_LOG ("res:%d", res);
if (G_UNLIKELY (res < 0)) {
if (errno == EAGAIN || errno == EINTR)
continue;
else
goto error_while_polling;
}
if (G_UNLIKELY (pollfds[1].revents)) {
char command;
if (pollfds[1].revents & POLLIN)
READ_COMMAND (dv1394src, command, res);
goto told_to_stop;
} else if (G_LIKELY (pollfds[0].revents & POLLIN)) {
int pt;
pt = dv1394src->frame_sequence;
/* shouldn't block in theory */
GST_LOG ("Iterating ! (%d)", dv1394src->frame_sequence);
raw1394_loop_iterate (dv1394src->handle);
GST_LOG ("After iteration : %d (diff:%d)",
dv1394src->frame_sequence, dv1394src->frame_sequence - pt);
if (dv1394src->outoffset)
break;
}
}
g_assert (dv1394src->outoffset);
GST_LOG ("We have some frames (%u bytes)", (guint) dv1394src->outoffset);
/* Create the buffer */
*buf = gst_buffer_new_wrapped (dv1394src->outdata, dv1394src->outoffset);
dv1394src->outdata = NULL;
dv1394src->outoffset = 0;
return GST_FLOW_OK;
error_while_polling:
{
GST_ELEMENT_ERROR (dv1394src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
return GST_FLOW_EOS;
}
told_to_stop:
{
GST_DEBUG_OBJECT (dv1394src, "told to stop, shutting down");
return GST_FLOW_FLUSHING;
}
}
int main(int argc, char** argv)
{
int rc; /**< return code */
int port = 0; /*!< fw handle port number */
int nodeid = 0; /*!< arm server node id */
// parse command line (port number)
opterr = 0; // getopt no err output
const char short_options[] = "hp:n:";
int next_opt;
do {
next_opt = getopt(argc, argv, short_options);
switch(next_opt)
{
case 'h':
print_usage();
return EXIT_SUCCESS;
break;
case 'p':
port = atoi(optarg);
break;
case 'n':
nodeid = atoi(optarg);
break;
case '?':
std::cerr << "Invalid argument" << std::endl;
break;
default:
break;
}
}
while(next_opt != -1);
// ----- Get handle and set port for the handle -------
// create handle
handle = raw1394_new_handle();
if (handle == NULL) {
std::cerr << "**** Error: could not create 1394 handle " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// get port number & sanity check
int numPorts = raw1394_get_port_info(handle, NULL, 0);
if (port < 0 || port >= numPorts) {
std::cerr << "Invalid port number" << std::endl;
return EXIT_FAILURE;
}
// let user to choose which port to use
rc = raw1394_set_port(handle, port);
if (rc) {
std::cerr << "**** Error: failed to set port " << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
// -------- Set FireWire bus reset handler --------
// set bus reset handler
raw1394_set_bus_reset_handler(handle, my_bus_reset_handler);
// ----------------------------------------------------------------------------
// Start tutorial 4 async broadcast
// ----------------------------------------------------------------------------
/**
*
*/
// ----- receving end -------------
unsigned char channel = 0x5;
raw1394_iso_dma_recv_mode mode = RAW1394_DMA_DEFAULT;
raw1394_iso_recv_init(handle,
my_iso_recv_handler,
BUFFER, // buf_packets
PACKET_MAX, // max_packet_size
channel, // channel
mode, // dma mode
-1); // irq_interval
// start receiving
raw1394_iso_recv_start(handle, -1, -1, 0);
while (true)
{
rc = raw1394_loop_iterate(handle);
if (rc) break;
}
// stop, clean up & exit
raw1394_iso_stop(handle);
raw1394_iso_shutdown(handle);
raw1394_destroy_handle(handle);
return EXIT_SUCCESS;
}
