hw_at2041_api.c

1、基于韩国at2041芯片开发的Linux环境的DVR代码。 2、以原来代码进行了修改。 3、主要修改网络通讯出现异常问题处理 4、硬盘覆盖录像不起作用

void output_stream_format(UNS16 form)
{
        /* form : '0' ES, '1' PES, '2' PS, '3' TS, default is PES */
        rx_id = RxID(GID_ENC, 0x00, PID_ENC_STR_FMT, W_FLAG);
        write_parm(rx_id, form);
}

void set_max_output_data_size(UNS16 size)
{
        /* if the output data size is lager than the size,
         * output data will be splitted.
         * size : maximum data size (KByte unit)
         *        default is 64KByte
         */
        rx_id = RxID(GID_ENC, 0x00, PID_ENC_DMAX, W_FLAG);
        write_parm(rx_id, size);
}

void set_data_ready_ack_mode(UNS16 data)
{
	rx_id= RxID(GID_ENC, 0x00, PID_ENC_DATA_RDY_ACK_MODE, W_FLAG);
	write_parm(rx_id, data);
}

/* Encoder video parameters */
void set_input_video_parameter(UNS16 hsize, UNS16 vsize, UNS16 rate, UNS16 field)
{
        /* hsize : horizontal size (32 ~ 720)
         * vsize : vertical size (16 ~ 576)
         * rate  : video input rate code, it's not frame_rate_code of MPEG standard
         *         '0' forbidden, '1' 24000/1001, '2' 24, '3' 25, '4' 30000/1001,
         *         '5' 30, '6' 50, '7' 60000/1001, '8' 60, '9' 100, '10' 120000/1001
         *         '11' 120
         * field : '0' frame mode input (interlaced)
         *         '1' field mode input (progressive)
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_FMT, W_FLAG);

        /* horizontal size setting */
        rx_data = hsize & 0x3ff;
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_data);

        /* vertical size setting */
        rx_data = vsize & 0x3ff;
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_data);


	 // changed by swpark
	 rx_data = (rate & 0x0f);
	 ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_data);

	 rx_data= (field & 0x01);
	 ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_data);

       ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void set_input_video_clock_inversion(UNS16 mode)
{
        /* mode : '0' use input clock, '1' use inverted input clock, default is 0 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_CLK_INV, W_FLAG);
        write_parm(rx_id, mode);
}

void set_input_video_sync_mode(UNS16 sync)
{
        /* sync : '0' embedded sync
         *        '1' BT embedded sync mode, regards the data of '0x00' as invalid data
         *        '2' external sync
         *         default is external sync
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_SYNC_M, W_FLAG);
        write_parm(rx_id, sync);
}

void enc_vertical_offset_mode(UNS16 mode)
{
        /* This is valid only if input video sync mode = 0
         * mode : '0' don't care the vertical offset value
         *        '1' use the verical offset value
         *        default is 1
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_VOFF_M, W_FLAG);
        write_parm(rx_id, mode);
}

void enc_vertical_offset(UNS16 voff_e, UNS16 voff_o)
{
        /* voff_e : vertical offset for even field from FSYNC, default is 19
         * voff_o : vertical offset for odd field from FSYNC, default is 18
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_VOFF_V, W_FLAG);

        /* vertical offset for even field */
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &voff_e);

        /* vertical offset for odd field */
        ioctl(fd_at2041, WRITE_Rx_FIFO, &voff_o);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void set_field_sync_mode(UNS16 mode)
{
        /* mode : '0' generate field sync using the 'first field decision parameter'
         *        '1' use the input field sync
         *        default is 0
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_FSYNC_M, W_FLAG);
        write_parm(rx_id, mode);
}

void set_first_field_decision_parameter(UNS16 value)
{
        /* This is valid only if the field sync mode is 0
         * if the number of clock cycles between the start of vertical sync
         * and the start of horizontal sync falling is less than or equal
         * to this value, the next field is the first field.
         * default is 128
         */
        rx_id = RxID(GID_EV, 0x00, PID_EV_FSYNC_P, W_FLAG);
        write_parm(rx_id, value);
}

void set_video_input_sync_polarity(UNS16 hvalid_polarity, UNS16 hsync_polarity, 
	UNS16 vvalid_polarity, UNS16 vsync_polarity, UNS16 fsync_first_field)
{
        /* hvalid_polarity : '0' active low, '1' active high, default is 1
         * hsync_polarity : '0' active high, '1' active low, default is 1
         * vvalid_polarity : '0' active low, '1' active high, default is 1
         * vsync_polarity : '0' active high, '1' active low, default is 1
         * fsync_first_field : field sync value of the first field, default is 0
	 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_SYNC_POL, W_FLAG);
        rx_data = (fsync_first_field << 4) | (vsync_polarity << 3) | (vvalid_polarity << 2) | 
		  (hsync_polarity << 1) | (hvalid_polarity);
        write_parm(rx_id, rx_data);
}

void input_video_data_saturation_value(UNS16 min_luma, UNS16 max_luma, 
	UNS16 min_chroma, UNS16 max_chroma)
{
        /* 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);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &min_luma);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &max_luma);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &min_chroma);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &max_chroma);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

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);
}

// pentamicro 2006.01.11
void watermark_key(UNS16 key)
{
        /* key : 0 ~ 15, default is 0 */
        rx_id = RxID(GID_EV, 0x00, PID_EV_WM_KEY, W_FLAG);
        write_parm(rx_id, 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(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        
        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void reference_picture_select(UNS16 mode)
{
        /* mode 0: Last I/P-picture reference mode (ISO standard)
			   1: Last I-picture reference mode (non ISO standard) */
		
        rx_id = RxID(GID_EV, 0x00, PID_EV_RP_SELECT, W_FLAG);
        write_parm(rx_id, mode);
}
void set_time_code(UNS16 hour, UNS16 minute, UNS16 second)
{
        rx_id = RxID(GID_EV, 0x00, PID_EV_TC, W_FLAG);

        /* set hour */
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &hour);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &minute);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &second);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}


/* Encoder video channel parameters */
void enc_restart(UNS16 ch_id, UNS16 restart)
{
	// restart : pause(0), restart(1)
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_RESTART, W_FLAG);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
	 ioctl(fd_at2041, WRITE_Rx_FIFO, &restart);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

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, '2' closed GOP type 2default 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(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &closed_gop);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &gop_nm);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &gop_m);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

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(fd_at2041, WRITE_Rx_FIFO, &rx_id);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

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(fd_at2041, WRITE_Rx_FIFO, &rx_id);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

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(fd_at2041, WRITE_Rx_FIFO, &rx_id);

        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void input_video_scale_mode(UNS16 ch_id, UNS16 hscale_mode, UNS16 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'
	 * vscale_mode : vertical scale mode
	 *                  '0' 1, '1' 1/2
	 */
        rx_id = RxID(GID_EVC, ch_id, PID_EVC_VSCL_M, W_FLAG);

        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);