at2041_api.c

这个是Linux下的应用程序

	uns16 min_chroma, uns16 max_chroma)
{
	_SET_REG_STR_ set_reg_st={0,0,{0,0,0,0,0,0}};
        /* min_luma : minimum value of luminance data, default is 16
         * max_luma : maximum value of luminance data, default is 235
         * min_chroma : minimum value of chrominance data, default is 16
         * max_chroma : maximum value of chrominance data, default is 239
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_DATA_SAT, W_FLAG);
#if 0
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &min_luma);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &max_luma);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &min_chroma);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &max_chroma);
#else
	set_reg_st.cmd_num=4;
	set_reg_st.addr=AT2041_RX_FIFO_ADDR;
	set_reg_st.value[0]=rx_id;	
	set_reg_st.value[1]=min_luma;set_reg_st.value[2]=max_luma;
	set_reg_st.value[3]=min_chroma;set_reg_st.value[4]=max_chroma;
	ioctl(at2042_fd, SET_REG, &set_reg_st);	        				
#endif
}

void set_preprocess(uns16 lpf, uns16 medf)
{
        /* lpf : low pass filter, '0' off, '1' on, default is 'on'
         * med : median filter, '0' off, '1' on, default is 'on'
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_PRE_PROC, W_FLAG);
        rx_data = ((medf & 0x01) << 1) | (lpf & 0x01);
        write_parm(rx_id, rx_data);
}

void set_input_video_shift_right_size(uns16 size)
{
        /* shift right pixel size = (size x 4) pixels, default is 0 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_SHR, W_FLAG);
        write_parm(rx_id, size);
}

void set_channel_id_interface_mode(uns16 mode)
{
        /* mode : '0' single channel encoding (channel ID = 0)
         *        '1' AT401xE VBI interface mode
         *        default is 0
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_CID_IF, W_FLAG);
        write_parm(rx_id, mode);
}

void watermark_enable(uns16 ena)
{
        /* ena : '0' disable, '1'; enable, default is 0 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_WM_EN, W_FLAG);
        write_parm(rx_id, ena);
}

void watermark_strength(uns16 level)
{
        /* strength : 0 ~ 4, default is 0 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_WM_LEVEL, W_FLAG);
        write_parm(rx_id, level);
}

/* review */
/*
void watermark_key(uns16 key)
{
}
*/

void watermark_key_update(void)
{
        /* after this command, the watermark key input is updated and applied */
        rx_id = RxID(GID_EV, 0x00, PID_EV_WM_UPDATA, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void set_time_code(uns16 hour, uns16 minute, uns16 second)
{
	_SET_REG_STR_ set_reg_st={0,0,{0,0,0,0,0,0}};
        rx_id = RxID(GID_EV, 0x00, PID_EV_TC, W_FLAG);
#if 0
        /* set hour */
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &hour);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &minute);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &second);
#else
	set_reg_st.cmd_num=3;
	set_reg_st.addr=AT2041_RX_FIFO_ADDR;
	set_reg_st.value[0]=rx_id;	
	set_reg_st.value[1]=hour;set_reg_st.value[2]=minute;set_reg_st.value[3]=minute;
	ioctl(at2042_fd, SET_REG, &set_reg_st);	        				
#endif
}

/* review */
/*
void set_intra_qmatrix_mpeg1n2()
{
}

void set_non_intra_qmatrix_mpeg1n2()
{
}

void set_intra_qmatrix_h263nmpeg4()
{
}
void set_non_intra_qmatrix_h263nmpeg4()
{
}
*/

/* Encoder video channel parameters */
void enc_restart(uns16 ch_id)
{
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RESTART, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void enc_pause(uns16 ch_id)
{
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_PAUSE, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void encode_standard(uns16 ch_id, uns16 std)
{
        /* ch_id : channel ID
         * std : encoding standard
         *       '0' JPEG, '1' MPEG1, '2' MPEG2, '3' H.263, '4' MPEG4
         *       default is '4'
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_STD, W_FLAG);
        write_parm(rx_id, std);
}

void rate_control_mode(uns16 ch_id, uns16 mode)
{
        /* ch_id : channel ID
         * mode : rate control mode
         *        '0' fixed Q, '1' CBR
         *        default is '0'
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RC_MODE, W_FLAG);
        write_parm(rx_id, mode);
}

void set_qscale_code(uns16 ch_id, uns16 qscale_code)
{
        /* ch_id : channel ID
         * qscale_code : Q value for fixed Q or JPEG image quality
         *               JPEG : 1 ~ 100(%)
         *               other standard : 1 ~ 31(Q)
         *               default is 5
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_FIX_Q, W_FLAG);
        write_parm(rx_id, qscale_code);
}

void rate_control_parm_CBR(uns16 ch_id, uns16 bit_rate)
{
        /* ch_id : channel ID 
         * bit_rate : average bit rate per frame (1000-bit unit), default is 100
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RC_PARM, W_FLAG);
        write_parm(rx_id, bit_rate);
}

void gop_structure(uns16 ch_id, uns16 closed_gop, uns16 gop_nm, uns16 gop_m)
{
        /* ch_id : channel ID
         * closed_gop : closed GOP
         *              '0' open GOP, '1' closed GOP, default is '1'
         * gop_nm : GOP_NM (N/M, > 0), default is 5
         * gop_m : GOP_M (M, > 0), default is 3
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_GOP, W_FLAG);
 
        /* set open/closed GOP */
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &closed_gop);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &gop_nm);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &gop_m);
}

void force_I(uns16 ch_id)
{
        /* insert I-frame by force */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_FRC_I, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void mpeg4_resync_mode(uns16 ch_id, uns16 mode)
{
        /* ch_id : channel ID
         * mode : resync mode
         *        '0' off, '1' resync interval mode, '2' slice mode
         *        default is '2'
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RESYNC_M, W_FLAG);
        write_parm(rx_id, mode);
}

void mpeg4_resync_interval(uns16 ch_id, uns16 interval)
{
        /* interval : resync interval(byte unit) only if resync mode == 1
         *            default is 1024
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RESYNC_I, W_FLAG);
        write_parm(rx_id, interval);
}

void mpeg_encode_parmeter(uns16 ch_id, uns16 intra_dc_prec, uns16 qscale_type, 
	uns16 intra_vlc_format, uns16 alternate_scan, uns16 vop_round_type, uns16 intra_dc_vlc_thr,
	uns16 quant_type, uns16 direct_mode, uns16 mode_4mv, uns16 ac_pred)
{
        /* ch_id            : channel ID
         * intra_dc_prec    : intra_dc_precision (MPEG2)
         *                    '0' 8-bit, '1' 9-bit, '2' 10-bit, '3' 11-bit
         *                    default is '0'
         * qscale_type      : q_scale_type (MPEG2)
         *                    '0' linear, '1' non-linear, default is '0'
         * intra_vlc_format : intra_vlc_format (MPEG2, refer to ISO/IEC 13818-2)
         * alternate_scan   : alternate scan (MPEG2, MPEG4)
         *                    '0' zigzag scan, '1' alternate scan, default is '0'
         * vop_round_type   : vop_rounding_type (MPEG4, refer to ISO/IEC 14496-2)
         * intra_dc_vlc_thr : intra_dc_vlc_thr (MPEG4, refer to ISO/IEC 14496-2)
         *                    0 ~ 7, default is 0
         * quant_type       : quant_type (MPEG4)
         *                    '0' off, '1' on, default is '0'
         * direct_mode      : direct mode (MPEG4)
         *                    '0' off, '1' on, default is '0'
         * mode_4mv         : 4MV mode (MPEG4)
         *                    '0' off, '1' on, default is '0'
         * ac_pred          : AC prediction (MPEG4)
         *                    '0' off, '1' on, default is '0'
         */
        rx_data = (uns16)((ac_pred & 0x01) << 12 | (mode_4mv & 0x01) << 11 |
                          (direct_mode & 0x01) << 10 | (quant_type & 0x01) << 9 |
                          (intra_dc_vlc_thr & 0x07) << 6 | (vop_round_type & 0x01) << 5 |
                          (alternate_scan & 0x01) << 4 | (intra_vlc_format & 0x01) << 3 |
                          (qscale_type & 0x01) << 2 | (intra_dc_prec & 0x03));
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_MPEG_PARM, W_FLAG);
        write_parm(rx_id, rx_data);

}

void physical_chid_assign(uns16 ch_id)
{
	/* physical channel ID, 0 ~ 15 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_PHY_CID, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void loss_video_channel_recoding_mode(uns16 ch_id, uns16 mode)
{
	/* mode : '0' record, '1' not record, default is 0 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_VLOSS_M, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void input_video_scale_mode(uns16 ch_id, uns16 hscale_mode, uns16 ef_vscale_mode, 
	uns16 of_vscale_mode)
{
	/* In this case, CID means physical channel ID
	 * ch_id          : channel ID
	 * hscale_mode    : horizontal scale mode
	 *                  '0' 1, '1' 8/9, '2' 1/2, '3' 4/9, '4' 1/4
	 *                  default is '0'
	 * ef_vscale_mode : even field vertical scale mode
	 *                  '0' 1, '1' 1/2(upper line), '2' 1/2(lower line)
	 *                  '3' 1/2(average), default is '0'
	 * of_vscale_mode : odd field vertical scale mode
	 *                  '0' 1, '1' 1/2(upper line), '2' 1/2(lower line)
	 *                  '3' 1/2(average), default is '0'
	 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_VSCL_M, W_FLAG);

        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &hscale_mode);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &ef_vscale_mode);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &of_vscale_mode);
}

void encode_region_info(uns16 ch_id, uns16 h_offset, uns16 v_offset, uns16 h_mbsize, uns16 v_mbsize)
{
        /* ch_id    : channel ID
         * h_offset : horizontal offset (16-pel unit), default is 0
         * v_offset : vertical offset (2-line unit), default is 0
         * h_mbsize : horizontal MB size (16-pel unit), default is 45
         * v_mbsize : vertical MB size (16-line unit), default is 30
         */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_REC_RGN, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &h_offset);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &v_offset);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &h_mbsize);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &v_mbsize);
}

void recoding_frame_rate_control(uns16 ch_id, uns16 input_frame_number, uns16 rec_frame_number)
{
	/* ch_id : channel ID
	 * input_frame_number : the number of input frames
	 *                      1 ~ 255, default is 1
	 * rec_frame_number   : the number of frames to be recorded out of input frames
	 *                      0 ~ number of input frame, default is 1
	 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_FPS_CTRL, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &input_frame_number);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rec_frame_number);
}

void motionless_record_mode(uns16 ch_id, uns16 mode)
{
        /* mode : '0' normal record, '1' not record, default is '0' */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_MD_MODE, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &mode);
}

void motion_detection_parameter(uns16 ch_id, uns16 sensitivity, uns16 pel_diff_threshold, 
	uns16 diff_pel_count_threshold, uns16 motion_mb_count_threshold, 
	uns16 motionless_frame_count_threshold)
{
	/* ch_id : channel ID
	 * sensitivity : sensitivity '0'(more sensitive) ~ '7'(less sensitive), default is '2'
	 * pel_diff_threshold : pixel difference threshold, '0' ~ '63', default is 32
	 * diff_pel_count_threshold : different pixel count threshold
	 *                            '0' ~ '127', default is '32'
	 * motion_mb_count_threshold : motion MB count threshold
	 *                            '0' ~ '255', default is '5'
	 * motionless_frame_count_threshold : motion-less frame count threshold
	 *                                    '0' ~ '255', default is '5'
	 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_MD_PARM, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &sensitivity);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &pel_diff_threshold);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &diff_pel_count_threshold);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &motion_mb_count_threshold);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &motionless_frame_count_threshold);
}

/* review */
/*
void motion_detection_area_bitmap(uns16 ch_id, uns16 bitmap)
{
}
*/

/* Encoder audio parameters */
void audio_encode_standard(uns16 standard)
{
	/* standard : '1' ADPCM, '2' MPEG-1 layer 2, '3' MPEG-1 layer 3
	 *            default is '1'
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_STD, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &standard);
}

void audio_input_channel_number(uns16 number)
{
	/* number : '1' ~ '16', default is '4'
	 *          Multi-channel encoding is supported only if the
	 *          encoding standard is ADPCM
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_CH_SIZE, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &number);
}

void audio_input_format(uns16 format, uns16 bits, uns16 delay_mode)
{
	/* format : audio input format
	 *          '0' I2S mode, '1' left justified mode, '2' PCM mode,
	 *          '3' stream mode, default is '0'
	 * bits : bits per sample x the number of the input channel
	 *        '0' 8-bit, '1' 16-bit, '4' 32-bit, '5' 64-bit,
	 *        '6' 128-bit, default is '0'
	 * delay_mode : delay mode, '0' no delay, '1' 1 bit delay, default is 0
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_FMT, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &format);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &bits);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &delay_mode);
}

void enc_audio_clock_inversion(uns16 type)
{
	/* type : '0' use input clock, '1' use inverted clock, default is '0'
	 *        This parameter is the same one that is in the audio decoder
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_CLK_INV, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &type);
}

void enc_audio_interface_mode(uns16 mode)
{
	/* mode : '0' master mode, '1' slave mode, default is '0'
	 *        This parameter is the same one that is in the audio decoder 
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_IF_MODE, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &mode);
}

void enc_audio_frame_sync_width(uns16 width)
{
	/* width : '0' ~ '1024', default is '0'
	 *         This parameter is the same one that is in the audio decoder 
	 */
        rx_id = RxID(GID_EA, 0x00, PID_EA_FSYNC_WIDTH, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &width);
}

/* Encoder audio channel parameters */
void audio_restart(uns16 ch_id)
{
        rx_id = RxID(GID_EAC, ch_id, PID_EAC_RESTART, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void audio_pause(uns16 ch_id)
{
        rx_id = RxID(GID_EAC, ch_id, PID_EAC_PAUSE, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
}

void audio_physical_chid_assign(uns16 ch_id, uns16 cid)
{
	/* ch_id : channel ID
	 * cid : physical channel ID, '0' ~ '15'
	 */
        rx_id = RxID(GID_EAC, ch_id, PID_EAC_PHY_CID, W_FLAG);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &rx_id);
        ioctl(at2042_fd, AT2041_RX_FIFO_ADDR, &cid);
}

/* decoder system parameters */
void video_decoder_start(unsigned short mode) 
{
	rx_id = RxID(GID_DEC, 0x00, PID_DEC_START, W_FLAG);
	write_parm(rx_id, mode);
	printf ("video_decoder_start : 0x%04x\n", mode);
}

void video_decoder_stop(unsigned short mode)