Subversion Repositories AndroidProjects

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <libraw1394/raw1394.h>
#include <libdv/dv.h>
#include <AR/config.h>
#include <AR/ar.h>
#include <AR/video.h>

#define VIDEO_MODE_PAL             0
#define VIDEO_MODE_NTSC            1
#define DEFAULT_VIDEO_MODE         VIDEO_MODE_NTSC

#define ARV_BUF_FRAME_DATA    150000
#define ARV_NTSC_FRAME_SIZE   120000
#define ARV_PAL_FRAME_SIZE    144000

#define ARV_PACKET_NUM_NTSC      250
#define ARV_PACKET_NUM_PAL       300

#define ARV_BIG_PACKET_SIZE      492
#define ARV_PACKET_DATA_SIZE     480



static AR2VideoParamT   *gVid = NULL;

static void ar2VideoCapture(AR2VideoParamT *vid);
static int ar2VideoRawISOHandler(raw1394handle_t handle, int channel, size_t length, quadlet_t *data);
static int ar2VideoBusResetHandler(raw1394handle_t handle, unsigned int generation);
static int ar2VideoBufferInit(AR2VideoBufferT *buffer, int size);
static int ar2VideoBufferClose(AR2VideoBufferT *buffer);
static int ar2VideoBufferRead(AR2VideoBufferT *buffer, ARUint8 *dest, int size, int flag);
static int ar2VideoBufferWrite(AR2VideoBufferT *buffer, ARUint8 *src, int size, int flag);
static ARUint8 *ar2VideoBufferReadDV(AR2VideoParamT *vid);

int arVideoDispOption( void )
{
    return  ar2VideoDispOption();
}

int arVideoOpen( char *config )
{
    if( gVid != NULL ) {
        printf("Device has been opened!!\n");
        return -1;
    }
    gVid = ar2VideoOpen( config );
    if( gVid == NULL ) return -1;

    return 0;
}

int arVideoClose( void )
{
        int result;
       
    if( gVid == NULL ) return -1;

        result = ar2VideoClose(gVid);
        gVid = NULL;
    return (result);
}

int arVideoInqSize( int *x, int *y )
{
    if( gVid == NULL ) return -1;

    return ar2VideoInqSize( gVid, x, y );
}

ARUint8 *arVideoGetImage( void )
{
    if( gVid == NULL ) return NULL;

    return ar2VideoGetImage( gVid );
}

int arVideoCapStart( void )
{
    if( gVid == NULL ) return -1;

    return ar2VideoCapStart( gVid );
}

int arVideoCapStop( void )
{
    if( gVid == NULL ) return -1;

    return ar2VideoCapStop( gVid );
}

int arVideoCapNext( void )
{
    if( gVid == NULL ) return -1;

    return ar2VideoCapNext( gVid );
}

/*-------------------------------------------*/

int ar2VideoDispOption( void )
{
    printf("ARVideo may be configured using one or more of the following options,\n");
    printf("separated by a space:\n\n");
    printf(" -mode=[PAL|NTSC]\n");
    printf("    specifies TV signal mode.\n");
    printf("\n");

    return 0;
}

AR2VideoParamT *ar2VideoOpen( char *config_in )
{
    struct raw1394_portinfo    g_pinf[16];
    AR2VideoParamT            *vid;
    char                      *config, *a, line[256];
    int                        numcards;
    int                        i;

    arMalloc( vid, AR2VideoParamT, 1 );
    vid->mode       = DEFAULT_VIDEO_MODE;
    vid->debug      = 0;
    vid->status     = 0;

        /* If no config string is supplied, we should use the environment variable, otherwise set a sane default */
        if (!config_in || !(config_in[0])) {
                /* None suppplied, lets see if the user supplied one from the shell */
                char *envconf = getenv ("ARTOOLKIT_CONFIG");
                if (envconf && envconf[0]) {
                        config = envconf;
                        printf ("Using config string from environment [%s].\n", envconf);
                } else {
                        config = NULL;
                        printf ("No video config string supplied, using defaults.\n");
                }
        } else {
                config = config_in;
                printf ("Using supplied video config string [%s].\n", config_in);
        }
       
    a = config;
    if( a != NULL) {
        for(;;) {
            while( *a == ' ' || *a == '\t' ) a++;
            if( *a == '\0' ) break;

            if( strncmp( a, "-mode=", 6 ) == 0 ) {
                if( strncmp( &a[6], "PAL", 3 ) == 0 )        vid->mode = VIDEO_MODE_PAL;
                else if( strncmp( &a[6], "NTSC", 4 ) == 0 )  vid->mode = VIDEO_MODE_NTSC;
                else {
                    ar2VideoDispOption();
                    free( vid );
                    return 0;
                }
            } else if( strncmp( a, "-debug", 6 ) == 0 ) {
                vid->debug = 1;
            } else {
                ar2VideoDispOption();
                free( vid );
                return 0;
            }

            while( *a != ' ' && *a != '\t' && *a != '\0') a++;
        }
    }


    if ((vid->handle = raw1394_new_handle()) == NULL) {
        free( vid );
        perror("raw1394 - couldn't get handle");
        return NULL;
    }
   
    if ((numcards = raw1394_get_port_info(vid->handle, g_pinf, 16)) < 0) {
        free( vid );
        perror("raw1394 - couldn't get card info");
        return NULL;
    }
    else {
        if( vid->debug ) {
            printf("NUMCARDS = %d\n", numcards);
            for (i = 0; i < numcards; i++) {
                printf("%2d: %s\n", g_pinf[i].nodes, g_pinf[i].name);
            }
        }
    }

    if (raw1394_set_port(vid->handle, 0) < 0) {
        free(vid);
        perror("raw1394 - couldn't set port");
        return NULL;
    }

    if ((vid->dv_decoder = dv_decoder_new((vid->mode == VIDEO_MODE_NTSC), FALSE, FALSE)) == 0) {
                free(vid);
        return NULL;
    }
    vid->dv_decoder->quality = 5;
        if (vid->mode == VIDEO_MODE_NTSC) {
                vid->dv_decoder->height = 480;
                vid->dv_decoder->arg_video_system = 1; // video standard: 0=autoselect [default], 1=525/60 4:1:1 (NTSC), 2=625/50 4:2:0 (PAL,IEC 61834 DV), 3=625/50 4:1:1 (PAL,SMPTE 314M DV).
        } else { // (vid->mode == VIDEO_MODE_PAL)
                vid->dv_decoder->height = 576;
                vid->dv_decoder->arg_video_system = 2;
        }
    dv_init(FALSE, FALSE);

    arMalloc( vid->buffer, AR2VideoBufferT, 1 );
    vid->buffer->init = 0;
    ar2VideoBufferInit( vid->buffer, ARV_BUF_FRAME_DATA );

    arMalloc( vid->image, ARUint8, 720*576*4 ); // Make buffer big enough for PAL BGRA images.

    return vid;
}

int ar2VideoCapStart( AR2VideoParamT *vid )
{
    if( vid->status != 0 ) return -1;
    vid->status = 1;
    vid->packet_num = 0;

    pthread_create(&(vid->capture), NULL, (void * (*)(void *))ar2VideoCapture, vid);

    return 0;
}

int ar2VideoCapStop( AR2VideoParamT *vid )
{
    if( vid->status != 1 ) return -1;
    vid->status = 2;

    return 0;
}

int ar2VideoCapNext( AR2VideoParamT *vid )
{
    return 0;
}

int ar2VideoClose( AR2VideoParamT *vid )
{
    if( vid->status == 1 || vid->status == 2 ) vid->status = 0;
     else return -1;

    pthread_join( vid->capture, NULL );

    ar2VideoBufferClose(vid->buffer);
    free( vid->buffer );
    free( vid->image );

    raw1394_stop_fcp_listen(vid->handle);
    raw1394_destroy_handle(vid->handle);

    free( vid );

    return 0;
}


 
static void ar2VideoCapture(AR2VideoParamT *vid)
{
    raw1394_set_userdata(vid->handle, vid);
    raw1394_set_bus_reset_handler(vid->handle, ar2VideoBusResetHandler);
    raw1394_set_iso_handler(vid->handle, 63, ar2VideoRawISOHandler);
    if( raw1394_start_iso_rcv(vid->handle, 63) < 0 ) {
        perror("raw1394 - couldn't start iso receive");
        exit(-1);
    }
 
    for(;;) {
        if( vid->status == 1 ) {
            while ( vid->status == 1 ) {
                raw1394_loop_iterate(vid->handle);
            }
            raw1394_stop_iso_rcv(vid->handle, 63);
        }
        else if( vid->status == 2 ) usleep(10);
        else break;
    }

    return;
}

static int ar2VideoRawISOHandler(raw1394handle_t handle, int channel, size_t length, quadlet_t *data)
{
    AR2VideoParamT  *vid = (AR2VideoParamT *)raw1394_get_userdata(handle);
    ARUint8         *packet = (ARUint8 *)data;
    int              len = 0;

    if(length == ARV_BIG_PACKET_SIZE) {
        if(vid->packet_num == 0) {
            if(packet[12] == 0x1f && packet[13] == 0x07) {
                if( vid->debug ) printf("Receiving...\n");
            }
            else return 0;
        }

        if (packet[12] == 0x1f && packet[13] == 0x07) {
            if(vid->packet_num == 0) {
                vid->packet_num++;
                len = ar2VideoBufferWrite(vid->buffer, (ARUint8 *)(data+3), ARV_PACKET_DATA_SIZE, 0);
            }
            else {
                vid->packet_num = 0;
                vid->packet_num++;
                len = ar2VideoBufferWrite(vid->buffer, (ARUint8 *)(data+3), ARV_PACKET_DATA_SIZE, 2);
            }
        }
        else {
            vid->packet_num++;
            if( (vid->mode == VIDEO_MODE_NTSC && vid->packet_num == ARV_PACKET_NUM_NTSC)
             || (vid->mode == VIDEO_MODE_PAL  && vid->packet_num == ARV_PACKET_NUM_PAL) ) {
                len = ar2VideoBufferWrite(vid->buffer, (ARUint8 *)(data+3), ARV_PACKET_DATA_SIZE, 1);
                vid->packet_num = 0;
            }
            else {
                len = ar2VideoBufferWrite(vid->buffer, (ARUint8 *)(data+3), ARV_PACKET_DATA_SIZE, 0);
            }
        }
    }

    return len;
}

static int ar2VideoBusResetHandler(raw1394handle_t handle, unsigned int generation)
{
    static int       i = 0;
    AR2VideoParamT  *vid = (AR2VideoParamT *)raw1394_get_userdata(handle);

    fprintf(stderr,"reset %d\n", i++);
    if (i == 10) {
        vid->status = 0;
    }

    return 0;
}

ARUint8 *ar2VideoGetImage( AR2VideoParamT *vid )
{
    return ar2VideoBufferReadDV( vid );
}

static ARUint8 *ar2VideoBufferReadDV(AR2VideoParamT *vid)
{
    static int     f = 1;
    ARUint8       *tmp;
    int            read_size;
    int            pitches[3];
    unsigned char *pixels[3];

    if( vid->buffer->init == 0 ) return NULL;

    pthread_mutex_lock(&(vid->buffer->mutex));
    tmp = vid->buffer->buff_wait;
    vid->buffer->buff_wait = vid->buffer->buff_out;
    vid->buffer->buff_out = tmp;

    vid->buffer->fill_size_out = vid->buffer->fill_size_wait;
    vid->buffer->read_size = 0;
    vid->buffer->fill_size_wait = 0;
    pthread_mutex_unlock(&(vid->buffer->mutex));
 
    if( vid->mode == VIDEO_MODE_NTSC ) {
        if( vid->buffer->fill_size_out != ARV_NTSC_FRAME_SIZE ) return NULL;
    }
    else if( vid->mode == VIDEO_MODE_PAL ) {
        if( vid->buffer->fill_size_out != ARV_PAL_FRAME_SIZE ) return NULL;
    }
    if( f ) {
        dv_parse_header(vid->dv_decoder, vid->image);
        if( vid->mode == VIDEO_MODE_NTSC ) {
            if( vid->dv_decoder->width != 720 || vid->dv_decoder->height != 480 ) {
                printf("Image format is not correct.\n");
                return NULL;
            }
        }
        else if( vid->mode == VIDEO_MODE_PAL ) {
            if( vid->dv_decoder->width != 720 || vid->dv_decoder->height != 576 ) {
                printf("Image format is not correct.\n");
                return NULL;
            }
        }
        f = 0;
    }

    pitches[0] = 720*AR_PIX_SIZE_DEFAULT;
    pixels[0] =  vid->image;
#if (AR_DEFAULT_PIXEL_FORMAT == AR_PIXEL_FORMAT_RGB)
    dv_decode_full_frame(vid->dv_decoder, vid->buffer->buff_out, e_dv_color_rgb, pixels, pitches );
#elif (AR_DEFAULT_PIXEL_FORMAT == AR_PIXEL_FORMAT_BGRA)
    dv_decode_full_frame(vid->dv_decoder, vid->buffer->buff_out, e_dv_color_bgr0, pixels, pitches );
#else
#  error Unsupported pixel format defined in <AR/config.h>.
#endif

    return vid->image;
}

int ar2VideoInqSize(AR2VideoParamT *vid, int *x,int *y)
{
    if( vid->mode == VIDEO_MODE_NTSC ) {
        *x = 720;
        *y = 480;
    }
    else if( vid->mode == VIDEO_MODE_PAL ) {
        *x = 720;
        *y = 576;
    }
    else return -1;
 
    return 0;
}

static int ar2VideoBufferInit(AR2VideoBufferT *buffer, int size)
{
    if( buffer->init ) return -1;

    buffer->size = size;

    arMalloc( buffer->buff_in,   ARUint8, size );
    arMalloc( buffer->buff_wait, ARUint8, size );
    arMalloc( buffer->buff_out,  ARUint8, size );
    buffer->fill_size_in   = 0;
    buffer->fill_size_wait = 0;
    buffer->fill_size_out  = 0;
    buffer->read_size      = 0;

    pthread_mutex_init(&(buffer->mutex), NULL);

    buffer->init = 1;

    return 0;
}

static int ar2VideoBufferClose(AR2VideoBufferT *buffer)
{
    if( buffer->init == 0 ) return -1;

    pthread_mutex_lock(&(buffer->mutex));
    free( buffer->buff_in   );
    free( buffer->buff_wait );
    free( buffer->buff_out  );
    pthread_mutex_unlock(&(buffer->mutex));
    pthread_mutex_destroy(&(buffer->mutex));

    buffer->init = 0;

    return 0;
}

static int ar2VideoBufferRead(AR2VideoBufferT *buffer, ARUint8 *dest, int size, int flag)
{
    ARUint8   *tmp;
    int        read_size;

    if( buffer->init == 0 ) return -1;

    if( flag ) {
        pthread_mutex_lock(&(buffer->mutex));
        tmp = buffer->buff_wait;
        buffer->buff_wait = buffer->buff_out;
        buffer->buff_out = tmp;

        buffer->fill_size_out = buffer->fill_size_wait;
        buffer->read_size = 0;
        buffer->fill_size_wait = 0;
        pthread_mutex_unlock(&(buffer->mutex));
    }
 
    if( buffer->fill_size_out - buffer->read_size >= size ) read_size = size;
     else                                                   read_size = buffer->fill_size_out - buffer->read_size;
    memcpy(dest, buffer->buff_out + buffer->read_size, read_size);
    buffer->read_size += read_size;

    return read_size;
}

static int ar2VideoBufferWrite(AR2VideoBufferT *buffer, ARUint8 *src, int size, int flag)
{
    ARUint8   *tmp;
    int        write_size;

    if( buffer->init == 0 ) return -1;

    if( flag == 2 ) {
        buffer->fill_size_in = 0;
    }

    if( buffer->size - buffer->fill_size_in > size ) write_size = size;
     else                                            write_size = buffer->size - buffer->fill_size_in;
    memcpy(buffer->buff_in + buffer->fill_size_in, src, write_size);
    buffer->fill_size_in += write_size;

    if( flag == 1 ) {
        pthread_mutex_lock(&(buffer->mutex));
        tmp = buffer->buff_wait;
        buffer->buff_wait = buffer->buff_in;
        buffer->buff_in = tmp;

        buffer->fill_size_wait = buffer->fill_size_in;
        buffer->fill_size_in = 0;
        pthread_mutex_unlock(&(buffer->mutex));
    }

    return write_size;
}