高分求解答，dspack采集无驱动摄像头视频压缩问题！！

[fan27]

我现在也做这个，我的压缩用的是xvid 压缩成mpeg-4，也够了，但是问题是，网上很多人做的都是320×240的，我想改成640×480 ，但是压缩没帧的时候出错，如果改为639×480可以出来视频，基本正常，但是问题压缩实时播放的图像最上边有跳黑边，我查了很多资料是不是无驱动的摄像头，采集不到640×480的图像，抓图没问题，就是压缩就不行。

[macchen1224]

你好，請檢查一下在轉換時是否有問題，謝謝，正常轉換不會有問題才對，謝謝。

[fan27]

就是压缩时出的问题，我用的晚上以为仁兄的代码，没做什么修改，之想把分辨率提高。一下是主要代码
unit main;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, DSUtil, StdCtrls, DSPack, DirectShow9, Menus, ExtCtrls,lib_xvid113;

type
TVideoForm = class(TForm)
FilterGraph: TFilterGraph;
VideoWindow: TVideoWindow;
MainMenu1: TMainMenu;
Devices: TMenuItem;
Filter: TFilter;
Image: TImage;
SampleGrabber: TSampleGrabber;
SnapShot: TButton;
CallBack: TCheckBox;
mmo1: TMemo;
lbl1: TLabel;
tmr1: TTimer;
ASFWriter1: TASFWriter;
procedure FormCreate(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure SnapShotClick(Sender: TObject);
procedure SampleGrabberBuffer(sender: TObject; SampleTime: Double;
pBuffer: Pointer; BufferLen: Integer);
procedure tmr1Timer(Sender: TObject);
private
// XVID ENCODER
xvid_gbl: xvid_gbl_init_t;
xvid_enc : xvid_enc_create_t;
xvid_encFrame: xvid_enc_frame_t;
xvid_encStats: xvid_enc_stats_t;

xVid_decode : xvid_dec_create_t;
xvid_decFrame: xvid_dec_frame_t;
xvid_decStats: xvid_dec_stats_t;
public
procedure OnSelectDevice(sender: TObject);
end;

var
VideoForm: TVideoForm;
SysDev: TSysDevEnum;
FrameBuf:array [0..640*480*3 ] of Byte;
FrameImg:array [0..640*480*3 ] of Byte;
FrameSequece : LongWord= 0;
spf:TFileStream;
xvid_Version:Integer;
FrameByteCount : LongWord = 0;
CurFrame: LongWord = 0;
bmpwidth : integer =640;
bmpheight : integer =480;
implementation

{$R *.dfm}

procedure TVideoForm.FormCreate(Sender: TObject);
var
i: integer;
Device: TMenuItem;
begin
xvid_Version :=XVID_MAKE_VERSION(1,1,0);
SysDev:= TSysDevEnum.Create(CLSID_VideoInputDeviceCategory);
if SysDev.CountFilters > 0 then
for i := 0 to SysDev.CountFilters - 1 do
begin
Device := TMenuItem.Create(Devices);
Device.Caption := SysDev.Filters[i].FriendlyName;
Device.Tag := i;
Device.OnClick := OnSelectDevice;
Devices.Add(Device);
end;
end;

procedure TVideoForm.OnSelectDevice(sender: TObject);
begin
Self.DoubleBuffered := True;
FilterGraph.ClearGraph;
FilterGraph.Active := false;
Filter.BaseFilter.Moniker := SysDev.GetMoniker(TMenuItem(Sender).tag);
FilterGraph.Active := true;
with FilterGraph as ICaptureGraphBuilder2 do
begin
RenderStream(@PIN_CATEGORY_PREVIEW, nil, Filter as IBaseFilter, SampleGrabber as IBaseFilter, VideoWindow as IbaseFilter);
end;
try
//XVID库初始化操作
xvid_gbl.version := xvid_Version; //Version:1.1.0
xvid_gbl.cpu_flags := Word(XVID_CPU_FORCE or XVID_CPU_ASM);//0:自动检查CPU，XVID_CPU_FORCE or XVID_CPU_ASM：强制使用ASM汇编优化
xvid_gbl.debug := 0; //调试级别

//初始化编解码
xvid_global(nil, XVID_GBL_INIT, @xvid_gbl, nil);

// XVID编码器初始化
xvid_enc.version := xvid_Version;
//编码器参数
xvid_enc.global := XVID_GLOBAL_PACKED; //全局标志
xvid_enc.width := bmpwidth; //压缩视频宽度
xvid_enc.height := bmpheight; //压缩视频高度
xvid_enc.fbase := 3; //基本帧率/每秒 = fbase * 10 = 30
xvid_enc.fincr := 1; //帧率增长步长，0：可变步长，>1实际增长步长
xvid_enc.profile := XVID_PROFILE_AS_L2; //压缩级别，MPEG4-ASP最高压缩级别
xvid_enc.max_key_interval := 0; //最大关键帧间隔
xvid_enc.frame_drop_ratio := 0; //丢帧率；0~100
xvid_enc.max_bframes := 0; //是否采用B帧，一般采用I，P帧，如果1=PB帧
xvid_enc.bquant_offset := -1;
xvid_enc.bquant_ratio := 0;

//创建编码器
xvid_encore(nil, XVID_ENC_CREATE, @xvid_enc, nil);
//初始化压缩数据帧结构
xvid_encFrame.version := xvid_Version;
// --- VOL FLAGS
xvid_encFrame.vol_flags := XVID_VOL_MPEGQUANT OR XVID_VOL_QUARTERPEL OR XVID_VOL_GMC;
// --- VOP FLAGS
xvid_encFrame.vop_flags := XVID_VOP_INTER4V or XVID_VOP_CHROMAOPT ;
xvid_encFrame.motion := XVID_ME_HALFPELREFINE16 or XVID_ME_CHROMA_PVOP or XVID_ME_ADVANCEDDIAMOND16; //运动估计
xvid_encFrame.quant := 4; //质量控制=量化参数，0~31，数值越小质量越高和码率成反比

xvid_encFrame.coding_type := XVID_TYPE_AUTO; //XVID_TYPE_AUTO=让编码器自动决定，I帧编码是关键帧，P帧编码是帧内预测

// XVID解码器初始化
xVid_decode.version := xvid_Version;
xVid_decode.width := bmpwidth;
xVid_decode.height := bmpheight;

//创建解码器
xvid_decore(nil,XVID_DEC_CREATE,@xVid_decode, nil);

spf := TFileStream.Create('c:\test.mp4',fmCreate or fmOpenReadWrite);
except
Exit;
end;
FilterGraph.Play;
end;

procedure TVideoForm.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
CallBack.Checked := False;
SysDev.Free;
FilterGraph.ClearGraph;
FilterGraph.Active := false;
//关闭编解码器
if Assigned(xvid_enc.handle) then
xvid_encore(xvid_enc.handle,XVID_ENC_DESTROY, @xvid_enc, nil);

if Assigned(xVid_decode.handle) then
xvid_decore(xVid_decode.handle,XVID_DEC_DESTROY,@xvid_decode,nil);
end;

procedure TVideoForm.SnapShotClick(Sender: TObject);
begin
SampleGrabber.GetBitmap(Image.Picture.Bitmap);
end;

procedure TVideoForm.SampleGrabberBuffer(sender: TObject;
SampleTime: Double; pBuffer: Pointer; BufferLen: Integer);
var
SpBmp:TBitmap;
yCount,uCount,vCount:Integer;
Row,Col:Integer;
Ret:Integer;
begin
if CallBack.Checked then
begin
tmr1.Enabled := True;
try
xvid_encFrame.bitstream := @FrameBuf[0];
xvid_encFrame.length := BufferLen;
xvid_encFrame.input.csp := XVID_CSP_BGR; //输入是rgb位图
xvid_encFrame.input.plane[0] := pBuffer; //RGB位图数据，每个像素有3个字节,(R,G,B)
xvid_encFrame.input.stride[0] := (bmpwidth-1)*3; //每行字节数

{
FillChar(xvid_encStats,SizeOf(xvid_encStats),0);
FillChar(xvid_decStats,SizeOf(xvid_decStats),0);
xvid_encStats.version := xvid_Version;
xvid_decStats.version := xvid_Version;
}

//开始压缩
//Ret := xvid_encore(xvid_enc.handle, XVID_ENC_ENCODE, @xvid_encFrame,@xvid_encStats); //返回编码之后的字节
Ret := xvid_encore(xvid_enc.handle, XVID_ENC_ENCODE, @xvid_encFrame,nil); //返回编码之后的字节
spf.Write(FrameBuf,Ret);
mmo1.Lines.Add('Codec_num=' + IntToStr(FrameSequece) + ' Len=' + IntToStr(Ret));
Inc(FrameSequece);

FrameByteCount := FrameByteCount + Ret;
//实时解码部分
if Ret > 0 then
begin
try
SpBmp := TBitmap.Create;
SpBmp.PixelFormat := pf24bit;

//初始化解码数据帧结构
xvid_decFrame.version := xvid_Version;
xvid_decFrame.general := 0;
xvid_decFrame.bitstream := @FrameBuf[0]; //输入解压的位流
xvid_decFrame.length := Ret; //输入位流长度
xvid_decFrame.output.csp := XVID_CSP_BGR; //色彩空间
xvid_decFrame.output.plane[0] := @FrameImg[0]; //解压后输出的缓冲区
xvid_decFrame.output.stride[0] := (bmpwidth-1)*3; //每行字节数
//ret := xvid_decore(xVid_decode.handle , XVID_DEC_DECODE, @xvid_decFrame, @xvid_decStats);
ret := xvid_decore(xVid_decode.handle , XVID_DEC_DECODE, @xvid_decFrame, nil);
if ret > 0 then
begin
image.Canvas.Lock;
try
SampleGrabber.GetBitmap(SpBmp, @FrameImg, bmpwidth*bmpheight*3); //从解码出来的RGB缓冲区中画出原始bmp位图
Image.Canvas.Draw(0,0,SpBmp);
except
end;
image.Canvas.Unlock;
end;
finally
SpBmp.Free;
end;
end else begin

end;

except

end;
end;
end;

procedure TVideoForm.tmr1Timer(Sender: TObject);
begin
CurFrame := FrameSequece - CurFrame;
lbl1.Caption := 'bytes=' + IntToStr( FrameByteCount div 1024) + ' k ' + IntToStr(CurFrame) + ' fps';
CurFrame := FrameSequece;
end;

end.


红色哪行执行过，如果是639×3=1917就没有问题，但是如果640×3=1920就在绿色哪行，就是开始压缩就出错了。

[fan27]

unit lib_xvid;

interface
uses
windows, SysUtils, math, forms, Contnrs;

// Bitstream Version
const
XVID_BS_VERSION = 34;

//****************************************************************************
// error codes
//****************************************************************************

// all functions return values <0 indicate error
const
XVID_ERR_FAIL = -1; // general fault
XVID_ERR_MEMORY = -2; // memory allocation error
XVID_ERR_FORMAT = -3; // file format error
XVID_ERR_VERSION = -4; // structure version not supported
XVID_ERR_END = -5; // encoder only; end of stream reached

//****************************************************************************
// xvid_image_t
//****************************************************************************

// colorspace values
const
XVID_CSP_PLANAR = (1 shl 0); // 4:2:0 planar (==I420, except for pointers/strides)
XVID_CSP_USER = XVID_CSP_PLANAR;
XVID_CSP_I420 = (1 shl 1); // 4:2:0 planar
XVID_CSP_YV12 = (1 shl 2); // 4:2:0 planar
XVID_CSP_YUY2 = (1 shl 3); // 4:2:2 packed
XVID_CSP_UYVY = (1 shl 4); // 4:2:2 packed
XVID_CSP_YVYU = (1 shl 5); // 4:2:2 packed
XVID_CSP_BGRA = (1 shl 6); // 32-bit bgra packed
XVID_CSP_ABGR = (1 shl 7); // 32-bit abgr packed
XVID_CSP_RGBA = (1 shl 8); // 32-bit rgba packed
XVID_CSP_ARGB = (1 shl 15); // 32-bit argb packed
XVID_CSP_BGR = (1 shl 9); // 24-bit bgr packed
XVID_CSP_RGB555 = (1 shl 10); // 16-bit rgb555 packed
XVID_CSP_RGB565 = (1 shl 11); // 16-bit rgb565 packed
XVID_CSP_SLICE = (1 shl 12); // decoder only: 4:2:0 planar, per slice rendering
XVID_CSP_INTERNAL = (1 shl 13); // decoder only: 4:2:0 planar, returns ptrs to internal buffers
XVID_CSP_NULL = (1 shl 14); // decoder only: dont output anything
XVID_CSP_VFLIP = (1 shl 31); // vertical flip mask

// xvid_image_t
type
xvid_image_t = packed record
csp: Integer; // [in] colorspace; or with XVID_CSP_VFLIP to perform vertical flip
plane: array[0..3] of Pointer; // [in] image plane ptrs
stride: array[0..3] of Integer; // [in] image stride; "bytes per row"
end;

// video-object-sequence profiles
const
XVID_PROFILE_S_L0 = $08; // simple
XVID_PROFILE_S_L1 = $01;
XVID_PROFILE_S_L2 = $02;
XVID_PROFILE_S_L3 = $03;
XVID_PROFILE_ARTS_L1 = $91; // advanced realtime simple
XVID_PROFILE_ARTS_L2 = $92;
XVID_PROFILE_ARTS_L3 = $93;
XVID_PROFILE_ARTS_L4 = $94;
XVID_PROFILE_AS_L0 = $F0; // advanced simple
XVID_PROFILE_AS_L1 = $F1;
XVID_PROFILE_AS_L2 = $F2;
XVID_PROFILE_AS_L3 = $F3;
XVID_PROFILE_AS_L4 = $F4;

// aspect ratios
const
XVID_PAR_11_VGA = 1; // 1:1 vga (square), default if supplied PAR is not a valid value
XVID_PAR_43_PAL = 2; // 4:3 pal (12:11 625-line)
XVID_PAR_43_NTSC = 3; // 4:3 ntsc (10:11 525-line)
XVID_PAR_169_PAL = 4; // 16:9 pal (16:11 625-line)
XVID_PAR_169_NTSC = 5; // 16:9 ntsc (40:33 525-line)
XVID_PAR_EXT = 15; // extended par; use par_width, par_height

// frame type flags
const
XVID_TYPE_VOL = -1; // decoder only: vol was decoded
XVID_TYPE_NOTHING = 0; // decoder only (encoder stats): nothing was decoded/encoded
XVID_TYPE_AUTO = 0; // encoder: automatically determine coding type
XVID_TYPE_IVOP = 1; // intra frame
XVID_TYPE_PVOP = 2; // predicted frame
XVID_TYPE_BVOP = 3; // bidirectionally encoded
XVID_TYPE_SVOP = 4; // predicted+sprite frame

//****************************************************************************
// xvid_global()
//****************************************************************************

// cpu_flags definitions (make sure to sync this with cpuid.asm for ia32)
const
XVID_CPU_FORCE = (1 shl 31); // force passed cpu flags
XVID_CPU_ASM = (1 shl 7); // native assembly
// ARCH_IS_IA32
XVID_CPU_MMX = (1 shl 0); // mmx : pentiumMMX,k6
XVID_CPU_MMXEXT = (1 shl 1); // mmx-ext : pentium2, athlon
XVID_CPU_SSE = (1 shl 2); // sse : pentium3, athlonXP
XVID_CPU_SSE2 = (1 shl 3); // sse2 : pentium4, athlon64
XVID_CPU_3DNOW = (1 shl 4); // 3dnow : k6-2
XVID_CPU_3DNOWEXT = (1 shl 5); // 3dnow-ext : athlon
XVID_CPU_TSC = (1 shl 6); // tsc : Pentium
// ARCH_IS_PPC
XVID_CPU_ALTIVEC = (1 shl 0); // altivec

XVID_DEBUG_ERROR = (1 shl 0);
XVID_DEBUG_STARTCODE = (1 shl 1);
XVID_DEBUG_HEADER = (1 shl 2);
XVID_DEBUG_TIMECODE = (1 shl 3);
XVID_DEBUG_MB = (1 shl 4);
XVID_DEBUG_COEFF = (1 shl 5);
XVID_DEBUG_MV = (1 shl 6);
XVID_DEBUG_RC = (1 shl 7);
XVID_DEBUG_DEBUG = (1 shl 31);

// XVID_GBL_INIT param1
type
xvid_gbl_init_t = packed record
version: Integer;
cpu_flags: Word; // [in:opt] zero = autodetect cpu; XVID_CPU_FORCE or {cpu features} = force cpu features
debug: Integer; // [in:opt] debug level
end;

// XVID_GBL_INFO param1
xvid_gbl_info_t = packed record
version: Integer;
actual_version: Integer; // [out] returns the actual xvidcore version
build: Pchar; // [out] if !null, points to description of this xvid core build
cpu_flags: Word; // [out] detected cpu features
num_threads: Integer; // [out] detected number of cpus/threads
end;

// XVID_GBL_CONVERT param1
xvid_gbl_convert_t = packed record
version: Integer;
input: XVID_IMAGE_T; // [in] input image and colorspace
output: XVID_IMAGE_T; // [in] output image and colorspace
width: Integer; // [in] width
height: Integer; // [in] height
interlacing: Integer; // [in] interlacing
end;

const
XVID_GBL_INIT = 0; // initialize xvidcore; must be called before using xvid_decore, or xvid_encore)
XVID_GBL_INFO = 1; // return some info about xvidcore, and the host computer
XVID_GBL_CONVERT = 2; // colorspace conversion utility

//type
//xvid_global = function(handle:Pointer;opt:Integer;param1:Pointer;param2: Pointer): Integer; cdecl;

//****************************************************************************
// xvid_decore()
//****************************************************************************
const
XVID_DEC_CREATE = 0; // create decore instance; return 0 on success
XVID_DEC_DESTROY = 1; // destroy decore instance: return 0 on success
XVID_DEC_DECODE = 2; // decode a frame: returns number of bytes consumed >= 0

{type
xvid_decore = function(handle: Pointer;
opt: Integer;
param1: Pointer;
param2: Pointer): Integer; cdecl;
}
// XVID_DEC_CREATE param 1
//-image width and height may be specified here when the dimensions are
//known in advance.

type
xvid_dec_create_t = packed record
version: Integer;
width: Integer; // [in:opt] image width
height: Integer; // [in:opt] image width
handle: Pointer; // [out] decore context handle
end;

// XVID_DEC_DECODE param1
// general flags
const
XVID_LOWDELAY = (1 shl 0); // lowdelay mode
XVID_DISCONTINUITY = (1 shl 1); // indicates break in stream
XVID_DEBLOCKY = (1 shl 2); // perform luma deblocking
XVID_DEBLOCKUV = (1 shl 3); // perform chroma deblocking
XVID_FILMEFFECT = (1 shl 4); // adds film grain

type
xvid_dec_frame_t = packed record
version: Integer;
general: Integer; // [in:opt] general flags
bitstream: Pointer; // [in] bitstream (read from)
length: Integer; // [in] bitstream length
output: XVID_IMAGE_T; // [in] output image (written to)
end;

// XVID_DEC_DECODE param2 :: optional
vop_t = packed record
version: Integer;
_type: Integer; // [out] output data type
// type>0 {XVID_TYPE_IVOP,XVID_TYPE_PVOP,XVID_TYPE_BVOP,XVID_TYPE_SVOP}
general: Integer; // [out] flags
time_base: Integer; // [out] time base
time_increment: Integer; // [out] time increment

// XXX: external deblocking stuff
qscale: PInteger; // [out] pointer to quantizer table
qscale_stride: Integer; // [out] quantizer scale stride
end;

vol_t = record // XVID_TYPE_VOL
general: Integer; // [out] flags
width: Integer; // [out] width
height: Integer; // [out] height
par: Integer; // [out] pixel aspect ratio (refer to XVID_PAR_xxx above)
par_width: Integer; // [out] aspect ratio width [1..255]
par_height: Integer; // [out] aspect ratio height [1..255]
end;

xvid_dec_stats_t = packed record
version: integer;
frametype: integer; // [out] output data type */
vop: vop_t;
vol: vol_t;
end;
const
XVID_ZONE_QUANT = (1 shl 0);
XVID_ZONE_WEIGHT = (1 shl 1);

type
Pxvid_enc_zone_t = ^xvid_enc_zone_t;
xvid_enc_zone_t = packed record
frame: Integer;
mode: Integer;
increment: Integer;
base: Integer;
end;

//----------------------------------------------------------------------------
// xvid_enc_stats_t structure
//
// Used in:
// - xvid_plg_data_t structure
// - optional parameter in xvid_encore() function
//
// .coding_type = XVID_TYPE_NOTHING if the stats are not given
//----------------------------------------------------------------------------

[fan27]

type
xvid_enc_stats_t = packed record
version: Integer; // encoding parameters
frame_type: Integer; // [out] coding type
quant: Integer; // [out] frame quantizer
vol_flags: Integer; // [out] vol flags (see above)
vop_flags: Integer; // [out] vop flags (see above)

// bitrate
length: Integer; // [out] frame length
hlength: Integer; // [out] header length (bytes)
kblks: Integer; // [out] number of blocks compressed as Intra
mblks: Integer; // [out] number of blocks compressed as Inter
ublks: Integer; // [out] number of blocks marked as not_coded

sse_y: Integer; // [out] Y plane's sse
sse_u: Integer; // [out] U plane's sse
sse_v: Integer; // [out] V plane's sse
end;

//****************************************************************************
{-xvid plugin system -- internals }

{-xvidcore will call XVID_PLG_INFO and XVID_PLG_CREATE during XVID_ENC_CREATE }
{-before encoding each frame xvidcore will call XVID_PLG_BEFORE }
{-after encoding each frame xvidcore will call XVID_PLG_AFTER }
{-xvidcore will call XVID_PLG_DESTROY during XVID_ENC_DESTROY }
//****************************************************************************

const
XVID_PLG_CREATE = (1 shl 0);
XVID_PLG_DESTROY = (1 shl 1);
XVID_PLG_INFO = (1 shl 2);
XVID_PLG_BEFORE = (1 shl 3);
XVID_PLG_FRAME = (1 shl 4);
XVID_PLG_AFTER = (1 shl 5);

// xvid_plg_info_t.flags*/ }
XVID_REQORIGINAL = (1 shl 0); // plugin requires a copy of the original (uncompressed) image
XVID_REQPSNR = (1 shl 1); // plugin requires psnr between the uncompressed and compressed image
XVID_REQDQUANTS = (1 shl 2); // plugin requires access to the dquant table

type
xvid_plg_info_t = packed record
version: Integer;
flags: Integer; // [in:opt] plugin flags
end;

xvid_plg_create_t = packed record
version: Integer;
num_zones: Integer; // [out]
zones: PXVID_ENC_ZONE_T; // [out]

width: Integer; // [out]
height: Integer; // [out]
mb_width: Integer; // [out]
mb_height: Integer; // [out]
fincr: Integer; // [out]
fbase: Integer; // [out]

param: Pointer; // [out]
end;

xvid_plg_destroy_t = packed record
version: Integer;
num_frames: Integer; // [out] total frame encoded
end;

xvid_plg_data_t = packed record
version: Integer;
zone: PXVID_ENC_ZONE_T; // [out] current zone

width: Integer; // [out]
height: Integer; // [out]
mb_width: Integer; // [out]
mb_height: Integer; // [out]
fincr: Integer; // [out]
fbase: Integer; // [out]

min_quant: array[0..3 - 1] of Integer; // [out]
max_quant: array[0..3 - 1] of Integer; // [out]

reference: XVID_IMAGE_T; // [out] -> [out]
current: XVID_IMAGE_T; // [out] -> [in,out]
original: XVID_IMAGE_T; // [out] after: points the original (uncompressed) copy of the current frame
frame_num: Integer; // [out] frame number

_type: Integer; // [in,out]
quant: Integer; // [in,out]

dquant: PInteger; // [in,out] pointer to diff quantizer table
dquant_stride: Integer; // [in,out] diff quantizer stride

vop_flags: Integer; // [in,out]
vol_flags: Integer; // [in,out]
motion_flags: Integer; // [in,out]

// Deprecated, use the stats field instead. }
// Will disapear before 1.0 }
length: Integer; // [out] after: length of encoded frame
kblks: Integer; // [out] number of blocks compressed as Intra
mblks: Integer; // [out] number of blocks compressed as Inter
ublks: Integer; // [out] number of blocks marked not_coded
sse_y: Integer; // [out] Y plane's sse
sse_u: Integer; // [out] U plane's sse
sse_v: Integer; // [out] V plane's sse
// End of duplicated data, kept only for binary compatibility*/ }

bquant_ratio: Integer; // [in]
bquant_offset: Integer; // [in]

stats: XVID_ENC_STATS_T; // [out] frame statistics
end;

//****************************************************************************
{-xvid plugin system -- external }

{-the application passes xvid an array of "xvid_plugin_t" at XVID_ENC_CREATE. the array }
{-indicates the plugin function pointer and plugin-specific data. }
{-xvidcore handles the rest. example: }

{-xvid_enc_create_t create; }
{-xvid_enc_plugin_t plugins[2]; }

{-plugins[0].func = xvid_psnr_func; }
{-plugins[0].param = NULL; }
{-plugins[1].func = xvid_cbr_func; }
{-plugins[1].param = and cbr_data; }

{-create.num_plugins = 2; }
{-create.plugins = plugins; }

//****************************************************************************

type
XVID_PLUGIN_FUNC = function(HANDLE: pointer; OPT: Integer; PARAM1, PARAM2: Pointer): Integer;

Pxvid_enc_plugin_t = ^xvid_enc_plugin_t;
xvid_enc_plugin_t = packed record
func: XVID_PLUGIN_FUNC;
param: Pointer;
end;

{ single-pass rate control }
{ two-pass rate control: first pass }
{ two-pass rate control: second pass }

{ lumimasking }

{ write psnr values to stdout }
{ dump before and after yuvpgms }

{ single pass rate control }
{ CBR and Constant quantizer modes }
type
xvid_plugin_single_t = packed record
version: Integer;
bitrate: Integer; // [in] bits per second
reaction_delay_factor: Integer; // [in]
averaging_period: Integer; // [in]
buffer: Integer; // [in]
end;

xvid_plugin_2pass1_t = packed record
version: Integer;
filename: PChar;
end;

const
XVID_PAYBACK_BIAS = 0; // payback with bias
XVID_PAYBACK_PROP = 1; // payback proportionally

type
xvid_plugin_2pass2_t = packed record
version: Integer;
bitrate: Integer; // [in] bits per second
filename: PChar; // [in] first pass stats filename

keyframe_boost: Integer; // [in] keyframe boost percentage: [0..100]
curve_compression_high: Integer; // [in] percentage of compression performed on the high part of the curve (above average) }
curve_compression_low: Integer; // [in] percentage of compression performed on the low part of the curve (below average) }
overflow_control_strength: Integer; // [in] Payback delay expressed in number of frames }
max_overflow_improvement: Integer; // [in] percentage of allowed range for a frame that gets bigger because of overflow bonus }
max_overflow_degradation: Integer; // [in] percentage of allowed range for a frame that gets smaller because of overflow penalty }

kfreduction: Integer; // [in] maximum bitrate reduction applied to an iframe under the kfthreshold distance limit }
kfthreshold: Integer; // [in] if an iframe is closer to the next iframe than this distance, a quantity of bits }
// is substracted from its bit allocation. The reduction is computed as multiples of
// kfreduction/kthreshold. It reaches kfreduction when the distance == kfthreshold,
// 0 for 1<distance<kfthreshold }

container_frame_overhead: Integer; // [in] How many bytes the controller has to compensate per frame due to container format overhead }
end;

[mjp1234airen4385]

强人。

[fan27]

没有看吗，虚心求解！

[LIUMAOZHIFU]

mark

[fan27]

本人qq号码 3853652 可以给所有源代码，共同研究！

[dd_zhouqian]

视频黑边问题有可能是标准有关，你查看下摄像机的说明书

[fan27]

就是普通的usb摄像头

[xuerishun]

我现在也做这个，经过多次测试，只有用640×480才会出错，改成更高的分辨优选法800×600都不会有问题，你可以试试！

[jasonke]

试试 XVID_PROFILE_AS_L4