开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
visca.c
资源名称：unicap-0.2.19.tar.gz　[点击查看]
上传用户：shyika
上传日期：2017-11-25
资源大小：1227k
文件大小：18k
源码类别：

视频捕捉/采集

开发平台：

Unix_Linux

visca.c：源码内容
  1. /*
  2.   unicap
  3.   Copyright (C) 2004  Arne Caspari  ( arne_caspari@users.sourceforge.net )
  5.   This program is free software; you can redistribute it and/or modify
  6.   it under the terms of the GNU General Public License as published by
  7.   the Free Software Foundation; either version 2 of the License, or
  8.   (at your option) any later version.
  10.   This program is distributed in the hope that it will be useful,
  11.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.   GNU General Public License for more details.
  15.   You should have received a copy of the GNU General Public License
  16.   along with this program; if not, write to the Free Software
  17.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  20. #include "config.h"
  22. #include <string.h>
  23. #include <netinet/in.h>
  25. #include "unicap.h"
  27. #include "vid21394_base.h"
  28. #include "visca.h"
  29. #include "visca_private.h"
  30. #include "visca_property_table.h"
  32. #if VID21394_DEBUG
  33. #define DEBUG
  34. #endif
  35. #include "debug.h"
  37. // --------------------------------------------------------------------------
  38. // Constants and Definitions
  39. // --------------------------------------------------------------------------
  40. struct ae_mode
  41. {
  42.       char param;
  43.       char *menu_item;
  44. };
  46. struct ae_mode ae_modes[] =
  47. {
  48.    { VISCA_AE_MODE_FULL_AUTO,    VISCA_AE_MENU_ITEM_FULL_AUTO }, 
  49.    { VISCA_AE_MODE_MANUAL,       VISCA_AE_MENU_ITEM_MANUAL }, 
  50.    { VISCA_AE_MODE_SHUTTER_PRIO, VISCA_AE_MENU_ITEM_SHUTTER_PRIO }, 
  51.    { VISCA_AE_MODE_IRIS_PRIO,    VISCA_AE_MENU_ITEM_IRIS_PRIO }, 
  52.    { VISCA_AE_MODE_BRIGHT,       VISCA_AE_MENU_ITEM_BRIGHT },
  53.    { 0xff, 0 }
  54. };
  56. // --------------------------------------------------------------------------
  57. // Helper functions
  58. // --------------------------------------------------------------------------
  59. static void visca_init_command_packet_1( unsigned char *packet_data, unsigned char command, unsigned char param1 )
  60. {
  61.    packet_data[0] = 0x81;
  62.    packet_data[1] = 0x01;
  63.    packet_data[2] = 0x04;
  64.    packet_data[3] = command;
  65.    packet_data[4] = param1;
  66.    packet_data[5] = 0xff;
  67. }
  69. static void visca_init_command_packet_4( unsigned char *packet_data, unsigned char command, 
  70.  unsigned char param1, unsigned char param2, 
  71.  unsigned char param3, unsigned char param4 )
  72. {
  73.    packet_data[0] = 0x81;
  74.    packet_data[1] = 0x01;
  75.    packet_data[2] = 0x04;
  76.    packet_data[3] = command;
  77.    packet_data[4] = param1;
  78.    packet_data[5] = param2;
  79.    packet_data[6] = param3;
  80.    packet_data[7] = param4;
  81.    packet_data[8] = 0xff;
  82. }
  84. static void visca_init_inq_packet( unsigned char *packet_data, unsigned char command )
  85. {
  86.    packet_data[0] = 0x81;
  87.    packet_data[1] = 0x09;
  88.    packet_data[2] = 0x04;
  89.    packet_data[3] = command;
  90.    packet_data[4] = 0xff;
  91. }
  93. static void visca_init_device_type_inq_packet( unsigned char *packet_data )
  94. {
  95.    packet_data[0] = 0x81;
  96.    packet_data[1] = 0x09;
  97.    packet_data[2] = 0x00;
  98.    packet_data[3] = 0x02;
  99.    packet_data[4] = 0xff;
  100. }
  102. static void visca_htofla( unsigned char *ar, size_t s )
  103. {
  104.    unsigned int *i_ar;
  105.    int i;
  107.    i_ar = ( unsigned int *)ar;
  109.    if( s % 4 )
  110.    {
  111.       s += 4 - ( s%4 );
  112.    }
  114.    for( i = 0; i < ( s/4 ); i++ )
  115.    {
  116.       i_ar[i] = htonl( i_ar[i] );
  117.    }
  118. }
  122. // --------------------------------------------------------------------------
  123. // Functions
  124. // --------------------------------------------------------------------------
  126. unicap_status_t visca_check_inq_response( unsigned char *response )
  127. {
  128.    unicap_status_t status = STATUS_SUCCESS;
  130.    if( ( response[1] & 0xf0 ) != VISCA_COMMAND_COMPLETE )
  131.    {
  132.       status = STATUS_FAILURE;
  133.    }
  135.    return status;
  136. }
  138. unicap_status_t visca_set_white_balance( vid21394handle_t vid21394handle, 
  139.  unicap_property_t *property )
  140. {
  141.    int out_bytes, in_bytes;
  142.    unsigned char out_data[8];
  143.    unsigned char in_data[8];
  144.    unicap_status_t status;
  146.    out_bytes = 6;
  147.    in_bytes = 6;
  149.    if( property->flags & UNICAP_FLAGS_AUTO )
  150.    {
  151.       visca_init_command_packet_1( out_data, VISCA_COMMAND_WHITE_BALANCE, VISCA_WHITE_BALANCE_AUTO );
  152.    }
  153.    else
  154.    {
  155.       if( property->value == 3200 )
  156.       {
  157.  visca_init_command_packet_1( out_data, VISCA_COMMAND_WHITE_BALANCE, VISCA_WHITE_BALANCE_INDOOR );
  158.       }
  159.       else
  160.       {
  161.  visca_init_command_packet_1( out_data, VISCA_COMMAND_WHITE_BALANCE, VISCA_WHITE_BALANCE_OUTDOOR );
  162.       }
  163.    }
  165.    visca_htofla( out_data, out_bytes );
  167.    status = vid21394_rs232_io( vid21394handle, 
  168.        out_data, out_bytes, 
  169.        in_data, in_bytes );
  171.    return status;
  172. }
  174. unicap_status_t visca_get_white_balance( vid21394handle_t vid21394handle, 
  175.  unicap_property_t *property )
  176. {
  177.    int out_bytes, in_bytes;
  178.    unsigned char out_data[8];
  179.    unsigned char in_data[8];
  180.    unicap_status_t status;
  182.    out_bytes = 5;
  183.    in_bytes = 4;
  185.    visca_init_inq_packet( out_data, VISCA_COMMAND_WHITE_BALANCE );
  187.    visca_htofla( out_data, out_bytes );
  189.    status = vid21394_rs232_io( vid21394handle, 
  190.        out_data, out_bytes, 
  191.        in_data, in_bytes );
  193.    if( SUCCESS( status ) )
  194.    {
  195.       status = visca_check_inq_response( in_data );
  197.       property->flags = UNICAP_FLAGS_MANUAL;
  199.       switch( in_data[2] )
  200.       {
  201.  case VISCA_WHITE_BALANCE_AUTO:
  202.  {
  203.     property->flags = UNICAP_FLAGS_AUTO;
  204.  }
  205.  break;
  207.  case VISCA_WHITE_BALANCE_INDOOR:
  208.  {
  209.     property->value = 3200;
  210.  }
  211.  break;
  213.  case VISCA_WHITE_BALANCE_OUTDOOR:
  214.  {
  215.     property->value = 5600;
  216.  }
  217.  break;
  218.       }
  219.    }
  221.    return status;
  222. }
  224. unicap_status_t visca_set_zoom( vid21394handle_t vid21394handle, 
  225. unicap_property_t *property )
  226. {
  227.    int out_bytes, in_bytes;
  228.    unsigned char out_data[12];
  229.    unsigned char in_data[8];
  230.    unicap_status_t status;
  232.    unsigned char p1, p2, p3, p4;
  234.    unsigned int value;
  236.    out_bytes = 9;
  237.    in_bytes = 3;
  239.    value = property->value;
  241.    p1 = ( value >> 12 ) & 0xf;
  242.    p2 = ( value >> 8 ) & 0xf;
  243.    p3 = ( value >> 4 ) & 0xf ; 
  244.    p4 = value & 0xf;
  246.    visca_init_command_packet_4( out_data, VISCA_COMMAND_ZOOM_DIRECT, p1, p2, p3, p4 );
  248.    visca_htofla( out_data, out_bytes );
  250.    status = vid21394_rs232_io( vid21394handle, 
  251.        out_data, out_bytes, 
  252.        in_data, in_bytes );
  254.    return status;
  255. }
  257. unicap_status_t visca_get_zoom( vid21394handle_t vid21394handle, 
  258. unicap_property_t *property )
  259. {
  260.    int out_bytes, in_bytes;
  261.    unsigned char out_data[8];
  262.    unsigned char in_data[8];
  263.    unicap_status_t status;
  265.    out_bytes = 5;
  266.    in_bytes = 7;
  268.    visca_init_inq_packet( out_data, VISCA_COMMAND_ZOOM_DIRECT );
  270.    visca_htofla( out_data, out_bytes );
  272.    status = vid21394_rs232_io( vid21394handle, 
  273.        out_data, out_bytes, 
  274.        in_data, in_bytes );
  276.    if( SUCCESS( status ) )
  277.    {
  278.       property->value = ( in_data[2] * 0x1000 + 
  279.   in_data[3] * 0x100 + 
  280.   in_data[4] * 0x10 + 
  281.   in_data[5] );
  282.    }
  284.    return status;
  285. }
  287. unicap_status_t visca_set_focus( vid21394handle_t vid21394handle, 
  288.  unicap_property_t *property )
  289. {
  290.    int out_bytes, in_bytes;
  291.    unsigned char out_data[12];
  292.    unsigned char in_data[8];
  293.    unicap_status_t status;
  297.    if( property->flags & UNICAP_FLAGS_AUTO )
  298.    {
  299.       out_bytes = 6;
  300.       in_bytes = 6;
  302.       visca_init_command_packet_1( out_data, VISCA_COMMAND_FOCUS_AUTO, VISCA_FOCUS_AUTO );
  303.    }
  304.    else
  305.    {
  306.       out_bytes = 6;
  307.       in_bytes = 6;
  309.       visca_init_command_packet_1( out_data, VISCA_COMMAND_FOCUS_AUTO, VISCA_FOCUS_MANUAL );
  311.       visca_htofla( out_data, out_bytes );
  313.       status = vid21394_rs232_io( vid21394handle, 
  314.   out_data, out_bytes, 
  315.   in_data, in_bytes );
  317.       if( SUCCESS( status ) )
  318.       {
  319.  unsigned char p1, p2, p3, p4;
  321.  unsigned int value;
  323.  out_bytes = 9;
  324.  in_bytes = 6;
  326.  value = property->value;
  328.  p1 = ( value >> 12 ) & 0xf;
  329.  p2 = ( value >> 8 ) & 0xf;
  330.  p3 = ( value >>4 ) & 0xf;
  331.  p4 = value & 0xf;
  333.  visca_init_command_packet_4( out_data, VISCA_COMMAND_FOCUS_DIRECT, p1, p2, p3, p4 );
  334.       }
  335.       else
  336.       {
  337.  return status;
  338.       }
  339.    }
  341.    visca_htofla( out_data, out_bytes );
  343.    status = vid21394_rs232_io( vid21394handle, 
  344.        out_data, out_bytes, 
  345.        in_data, in_bytes );
  348.    return status;
  349. }
  351. unicap_status_t visca_get_focus( vid21394handle_t vid21394handle, 
  352.  unicap_property_t *property )
  353. {
  354.    int out_bytes, in_bytes;
  355.    unsigned char out_data[8];
  356.    unsigned char in_data[8];
  357.    unicap_status_t status;
  359.    out_bytes = 5;
  360.    in_bytes = 4;
  362.    visca_init_inq_packet( out_data, VISCA_COMMAND_FOCUS_AUTO );
  364.    visca_htofla( out_data, out_bytes );
  366.    status = vid21394_rs232_io( vid21394handle, 
  367.        out_data, out_bytes, 
  368.        in_data, in_bytes );
  371.    if( SUCCESS( status ) )
  372.    {
  373.       status = visca_check_inq_response( in_data );
  375.       property->flags = UNICAP_FLAGS_MANUAL;
  377.       switch( in_data[2] )
  378.       {
  379.  case VISCA_FOCUS_AUTO:
  380.  {
  381.     property->flags = UNICAP_FLAGS_AUTO;
  382. /*      TRACE( "AUTO FOCUS enabledn" ); */
  383.  }
  384.  break;
  386.  default:
  387.  case VISCA_FOCUS_MANUAL:
  388.  {
  389. /*      TRACE( "MANUAL FOCUS enabledn" ); */
  390.  }
  391.  break;
  392.       }
  393.       out_bytes = 5;
  394.       in_bytes = 7;
  396.       visca_init_inq_packet( out_data, VISCA_COMMAND_FOCUS_DIRECT );
  398.       visca_htofla( out_data, out_bytes );
  400.       status = vid21394_rs232_io( vid21394handle, 
  401.   out_data, out_bytes, 
  402.   in_data, in_bytes );
  405.       if( SUCCESS( status ) )
  406.       {
  407.  property->value = ( in_data[2] * 0x1000 + 
  408.      in_data[3] * 0x100 + 
  409.      in_data[4] * 0x10 + 
  410.      in_data[5] );
  411.       }
  412.    }
  414.    return status;
  415. }
  417. unicap_status_t visca_set_gain( vid21394handle_t vid21394handle, 
  418. unicap_property_t *property )
  419. {
  420.    int out_bytes, in_bytes;
  421.    unsigned char out_data[12];
  422.    unsigned char in_data[8];
  423.    unicap_status_t status;
  425.    unsigned char p3, p4;
  426.    unsigned int value;
  429.    out_bytes = 9;
  430.    in_bytes = 6;
  432.    p3 = ( value & 0xf0 ) >> 8;
  433.    p4 = value & 0xf;
  435.    visca_init_command_packet_4( out_data, VISCA_COMMAND_FOCUS_DIRECT, 0, 0, p3, p4 );
  437.    visca_htofla( out_data, out_bytes );
  439.    status = vid21394_rs232_io( vid21394handle, 
  440.        out_data, out_bytes, 
  441.        in_data, in_bytes );
  443.    return status;
  444. }
  446. unicap_status_t visca_get_gain( vid21394handle_t vid21394handle, 
  447. unicap_property_t *property )
  448. {
  449.    int out_bytes, in_bytes;
  450.    unsigned char out_data[8];
  451.    unsigned char in_data[8];
  452.    unicap_status_t status;
  454.    out_bytes = 5;
  455.    in_bytes = 7;
  457.    visca_init_inq_packet( out_data, VISCA_COMMAND_GAIN_DIRECT );
  459.    visca_htofla( out_data, out_bytes );
  461.    status = vid21394_rs232_io( vid21394handle, 
  462.        out_data, out_bytes, 
  463.        in_data, in_bytes );
  465.    if( SUCCESS( status ) )
  466.    {
  467.       property->value = ( in_data[4] * 0x10 + 
  468.   in_data[5] );
  469.    }
  471.    property->flags = UNICAP_FLAGS_MANUAL;
  473.    return status;
  474. }
  476. unicap_status_t visca_set_shutter( vid21394handle_t vid21394handle, 
  477.    unicap_property_t *property )
  478. {
  479.    int out_bytes, in_bytes;
  480.    unsigned char out_data[12];
  481.    unsigned char in_data[8];
  482.    unicap_status_t status;
  486.    unsigned char p3, p4;
  488.    unsigned int value;
  490.    out_bytes = 9;
  491.    in_bytes = 6;
  493.    p3 = ( value & 0xf0 ) >> 8;
  494.    p4 = value & 0xf;
  496.    visca_init_command_packet_4( out_data, VISCA_COMMAND_SHUTTER_DIRECT, 0, 0, p3, p4 );
  498.    visca_htofla( out_data, out_bytes );
  500.    status = vid21394_rs232_io( vid21394handle, 
  501.        out_data, out_bytes, 
  502.        in_data, in_bytes );
  504.    return status;
  505. }
  507. unicap_status_t visca_get_shutter( vid21394handle_t vid21394handle, 
  508.    unicap_property_t *property )
  509. {
  510.    int out_bytes, in_bytes;
  511.    unsigned char out_data[8];
  512.    unsigned char in_data[8];
  513.    unicap_status_t status;
  515.    out_bytes = 5;
  516.    in_bytes = 7;
  518.    visca_init_inq_packet( out_data, VISCA_COMMAND_SHUTTER_DIRECT );
  520.    visca_htofla( out_data, out_bytes );
  522.    status = vid21394_rs232_io( vid21394handle, 
  523.        out_data, out_bytes, 
  524.        in_data, in_bytes );
  526.    if( SUCCESS( status ) )
  527.    {
  528.       property->value = ( in_data[4] * 0x10 + 
  529.   in_data[5] );
  530.    }
  532.    property->flags = UNICAP_FLAGS_MANUAL;
  534.    return status;
  535. }
  537. unicap_status_t visca_set_iris( vid21394handle_t vid21394handle, 
  538. unicap_property_t *property )
  539. {
  540.    int out_bytes, in_bytes;
  541.    unsigned char out_data[12];
  542.    unsigned char in_data[8];
  543.    unicap_status_t status;
  547.    unsigned char p3, p4;
  549.    unsigned int value;
  551.    out_bytes = 9;
  552.    in_bytes = 6;
  554.    p3 = ( value & 0xf0 ) >> 8;
  555.    p4 = value & 0xf;
  557.    visca_init_command_packet_4( out_data, VISCA_COMMAND_IRIS_DIRECT, 0, 0, p3, p4 );
  559.    visca_htofla( out_data, out_bytes );
  561.    status = vid21394_rs232_io( vid21394handle, 
  562.        out_data, out_bytes, 
  563.        in_data, in_bytes );
  565.    return status;
  566. }
  568. unicap_status_t visca_get_iris( vid21394handle_t vid21394handle, 
  569. unicap_property_t *property )
  570. {
  571.    int out_bytes, in_bytes;
  572.    unsigned char out_data[8];
  573.    unsigned char in_data[8];
  574.    unicap_status_t status;
  576.    out_bytes = 5;
  577.    in_bytes = 7;
  579.    visca_init_inq_packet( out_data, VISCA_COMMAND_IRIS_DIRECT );
  581.    visca_htofla( out_data, out_bytes );
  583.    status = vid21394_rs232_io( vid21394handle, 
  584.        out_data, out_bytes, 
  585.        in_data, in_bytes );
  587.    if( SUCCESS( status ) )
  588.    {
  589.       property->value = ( in_data[4] * 0x10 + 
  590.   in_data[5] );
  591.    }
  593.    property->flags = UNICAP_FLAGS_MANUAL;
  595.    return status;
  596. }
  600. unicap_status_t visca_set_ae_mode( vid21394handle_t vid21394handle, 
  601.    unicap_property_t *property )
  602. {
  603.    int out_bytes, in_bytes;
  604.    unsigned char out_data[8];
  605.    unsigned char in_data[8];
  606.    unicap_status_t status;
  607.    unsigned char param = 0xff;
  608.    int i;
  610.    out_bytes = 6;
  611.    in_bytes = 6;
  613.    for( i = 0; ae_modes[i].param != 0xff; i++ )
  614.    {
  615.       if( !strcmp( property->menu_item, ae_modes[i].menu_item ) )
  616.       {
  617.  param = ae_modes[i].param;
  618.  break;
  619.       }
  620.    }
  622.    if( param == 0xff )
  623.    {
  624.       return STATUS_INVALID_PARAMETER;
  625.    };
  627.    visca_init_command_packet_1( out_data, VISCA_COMMAND_AE_MODE, param );
  629.    visca_htofla( out_data, out_bytes );
  631.    status = vid21394_rs232_io( vid21394handle, 
  632.        out_data, out_bytes, 
  633.        in_data, in_bytes );
  635.    return status;
  636. }
  638. unicap_status_t visca_get_ae_mode( vid21394handle_t vid21394handle, 
  639.    unicap_property_t *property )
  640. {
  641.    int out_bytes, in_bytes;
  642.    unsigned char out_data[8];
  643.    unsigned char in_data[8];
  644.    unicap_status_t status;
  646.    out_bytes = 5;
  647.    in_bytes = 4;
  649.    visca_init_inq_packet( out_data, VISCA_COMMAND_AE_MODE );
  651.    visca_htofla( out_data, out_bytes );
  653.    status = vid21394_rs232_io( vid21394handle, 
  654.        out_data, out_bytes, 
  655.        in_data, in_bytes );
  657.    if( SUCCESS( status ) )
  658.    {
  659.       status = visca_check_inq_response( in_data );
  661.       property->flags = UNICAP_FLAGS_MANUAL;
  663.       switch( in_data[2] )
  664.       {
  665.  case VISCA_AE_MODE_MANUAL:
  666.  {
  667.     strcpy( property->menu_item, VISCA_AE_MENU_ITEM_MANUAL );
  668.  }
  669.  break;
  671.  case VISCA_AE_MODE_FULL_AUTO:
  672.  {
  673.     strcpy( property->menu_item, VISCA_AE_MENU_ITEM_FULL_AUTO );
  674.  }
  675.  break;
  677.  case VISCA_AE_MODE_SHUTTER_PRIO:
  678.  {
  679.     strcpy( property->menu_item, VISCA_AE_MENU_ITEM_SHUTTER_PRIO );
  680.  }
  681.  break;
  683.  case VISCA_AE_MODE_IRIS_PRIO:
  684.  {
  685.     strcpy( property->menu_item, VISCA_AE_MENU_ITEM_IRIS_PRIO );
  686.  }
  687.  break;
  689.  case VISCA_AE_MODE_BRIGHT:
  690.  {
  691.     strcpy( property->menu_item, VISCA_AE_MENU_ITEM_BRIGHT );
  692.  }
  693.  break;
  695.  default:
  696.  {
  697.     strcpy( property->menu_item, "Unknown" );
  698.  }
  699.  break;
  700.       }
  701.    }
  703.    return status;
  704. }
  706. unicap_status_t visca_reenumerate_properties( vid21394handle_t vid21394handle, int *count )
  707. {
  708.    *count = ( sizeof( visca_property_table ) / sizeof( visca_property_t ) );
  710.    return STATUS_SUCCESS;
  711. }
  713. unicap_status_t visca_enumerate_properties( unicap_property_t *property, int index )
  714. {
  715.    if( ( index < 0 ) ||
  716.        ( index >= ( sizeof( visca_property_table ) / sizeof( visca_property_t ) ) ) )
  717.    {
  718.       return STATUS_NO_MATCH;
  719.    }
  721.    unicap_copy_property( property, &visca_property_table[index].property );
  723.    return STATUS_SUCCESS;
  724. }
  726. unicap_status_t visca_set_property( vid21394handle_t vid21394handle, unicap_property_t *property )
  727. {
  728.    int i;
  729.    unicap_status_t status = STATUS_INVALID_PARAMETER;
  731.    for( i = 0; i < ( sizeof( visca_property_table ) / sizeof( visca_property_t ) ); i++ )
  732.    {
  733.       if( !strcmp( visca_property_table[i].property.identifier, property->identifier ) )
  734.       {
  735.  status = visca_property_table[i].set_function( vid21394handle, property );
  736.  break;
  737.       }
  738.    }
  740.    return status;
  741. }
  743. unicap_status_t visca_get_property( vid21394handle_t vid21394handle, unicap_property_t *property )
  744. {
  745.    int i;
  746.    unicap_status_t status = STATUS_INVALID_PARAMETER;
  748.    for( i = 0; i < ( sizeof( visca_property_table ) / sizeof( visca_property_t ) ); i++ )
  749.    {
  750.       if( !strcmp( visca_property_table[i].property.identifier, property->identifier ) )
  751.       {
  752.  unicap_copy_property( property, & visca_property_table[i].property );
  753.  status = visca_property_table[i].get_function( vid21394handle, property );
  754.  break;
  755.       }
  756.    }
  758.    return status;
  759. }
  761. unicap_status_t visca_check_camera( vid21394handle_t vid21394handle, visca_camera_type_t *type )
  762. {
  763.    int out_bytes, in_bytes;
  764.    unsigned char out_data[8];
  765.    unsigned char in_data[10];
  766.    unicap_status_t status = STATUS_FAILURE;
  768.    *type = VISCA_CAMERA_TYPE_NONE;
  770.    out_bytes = 5;
  771.    in_bytes = 10;
  773.    visca_init_device_type_inq_packet( out_data );
  775.    vid21394_rs232_set_baudrate( vid21394handle, 9600 );
  777.    visca_htofla( out_data, out_bytes );
  779.    status = vid21394_rs232_io( vid21394handle, 
  780.        out_data, out_bytes, 
  781.        in_data, in_bytes );
  783.    if( !SUCCESS( status ) )
  784.    {
  785.       TRACE( "Get camera type failedn" );
  786.       return status;
  787.    }
  789.    // Check Vendor ID
  790.    if( ( in_data[2] != 0x0 ) ||
  791.        ( in_data[3] != 0x20 ) )
  792.    {
  793.       TRACE( "Wrong Vendor IDn" );
  794.    } 
  795.    else if( ( in_data[4] != 0x4 ) )  // Check Model ID
  796.    {
  797.       TRACE( "Unknown camera type!n" );
  798.       *type = VISCA_CAMERA_TYPE_UNKNOWN;
  799.    }
  800.    else
  801.    {
  802.       *type = VISCA_CAMERA_TYPE_FCB_IX47;
  803.    }
  805.    return status;
  806. }