lib_xvid.~pas

xvid库调用来压缩视频编码实例

  end;

  TxvidDecodeException = class(Exception)
  end;

  TxvidEncoder = class;
  TxvidDecoder = class;

  TxvidCore = class(TObject)
  private
    _xvidInited: boolean;
    _xvidHandle: THandle;
    //_globalProc: xvid_global;
    //_encodeProc: xvid_encore;
    //_decodeProc: xvid_decore;

    _encparam: xvid_enc_create_t;
    _decparam: xvid_dec_create_t;

    _encoders: TObjectList;
    _decoders: TObjectList;
  public
    XVID_VERSION: integer;
    XVID_API: Integer;
    constructor create();
    destructor Destroy(); override;
//    procedure init();
    //编码函数
    function encode(handle: Pointer; opt: Integer; param1: Pointer;
      param2: Pointer): integer;
    //解码函数
    function decode(handle: Pointer; opt: Integer; param1: Pointer;
      param2: Pointer): Integer;

    function CreateEncoder: TxvidEncoder;
    procedure RemoveEncoder(encoder: TxvidEncoder);

    function CreateDecoder: TxvidDecoder;
    procedure RemoveDecoder(decoder: TxvidDecoder);

  end;

  TxvidEncoder = class(TObject)
  private
    _xvidcore: Txvidcore;
    _encodeHandle: Pointer;
    _encparam: xvid_enc_create_t;
    _outbuf: array[0..352 * 288 * 3 - 1] of byte; // *
    _tmpBuf: array[0..352 * 288 * 3 - 1] of byte; // *
  public
    constructor create(xvidcore: TxvidCore);
    destructor Destroy(); override;

    procedure init(width: Integer; height: Integer; rate: Integer);
    procedure reset(width: Integer; height: Integer; rate: Integer);
    function encode(opt: Integer; param1,
      param2: Pointer): integer;
  end;

  TxvidDecoder = class(TObject)
  private
    _decodeHandle: Pointer;
    _xvidcore: Txvidcore;
    _decparam: xvid_dec_create_t;
    _decBuf: array[0..352 * 288 * 3 - 1] of byte; // -
    _tmpBuf: array[0..352 * 288 * 3 - 1] of byte; // -
  public
    constructor create(xvidcore: TxvidCore);
    destructor Destroy(); override;

    procedure init(width: Integer; height: Integer; rate: Integer);
    function decode: integer;
  end;

function XVID_MAKE_VERSION(a, b, c: Integer): Integer;
function XVID_VERSION_MAJOR(a: Integer): Byte;
function XVID_VERSION_MINOR(a: Integer): Byte;
function XVID_VERSION_PATCH(a: Integer): Byte;

function XVID_MAKE_API(a, b: Integer): Integer;
function XVID_API_MAJOR(a: Integer): Integer;
function XVID_API_MINOR(a: Integer): Integer;

function xvid_global(hnd: pointer; opt: integer; param1: pointer; param2: pointer): integer; cdecl; external XviDCoreDll;
function xvid_decore(hnd: pointer; opt: integer; param1: pointer; param2: pointer): integer; cdecl; external XviDCoreDll;
function xvid_encore(hnd: pointer; opt: integer; param1: pointer; param2: pointer): integer; cdecl; external XviDCoreDll;

implementation



{ TxvidCore }

function TxvidCore.CreateDecoder: TxvidDecoder;
begin

end;

function TxvidCore.CreateEncoder: TxvidEncoder;
begin

end;

constructor TxvidCore.create;
begin
  _encoders := TObjectList.Create();
  _decoders := TObjectList.Create();


  XVID_VERSION := XVID_MAKE_VERSION(1, 0, 0);
  XVID_API := XVID_MAKE_API(4, 0);
  //_encodeProc := nil;
  //_DecodeProc := nil;
 // _xvidHandle := 0;
end;

function TxvidCore.decode(handle: Pointer; opt: Integer; param1,
  param2: Pointer): Integer;
begin
  //if assigned(_decodeProc) then
  //  result := _decodeProc(handle, opt, param1, param2)
 // else
 //   raise Exception.Create('endcodeproc not exists');
end;

procedure TxvidCore.RemoveDecoder(decoder: TxvidDecoder);
begin
  _decoders.Remove(decoder);
end;

procedure TxvidCore.RemoveEncoder(encoder: TxvidEncoder);
begin
  _encoders.Remove(encoder);
end;

destructor TxvidCore.destroy;
begin
  if _xvidHandle > 0 then
    FreeLibrary(_xvidHandle);
  _encoders.Free;
  _decoders.Free;
  inherited;
end;

function TxvidCore.encode(handle: Pointer; opt: Integer; param1,
  param2: Pointer): integer;
begin
 // if assigned(_encodeProc) then
 //   result := _encodeProc(handle, opt, param1, param2)
 // else
 //   raise Exception.Create('endcodeproc not exists');

end;
{
procedure TxvidCore.init;
var
  xinit: xvid_gbl_init_t;

begin
  if _xvidInited then
    exit;

  if _xvidHandle <= 0 then
    _xvidHandle := LoadLibrary(pchar(ExtractFilePath(Application.ExeName) + XviDCoreDll));

  if _xvidHandle <= 0 then
    raise TXviDInitException.Create('未发现视频编解码器');

  _globalProc := GetProcAddress(_xvidHandle, 'xvid_global');
  _encodeProc := GetProcAddress(_xvidHandle, 'xvid_encore');
  _decodeProc := GetProcAddress(_xvidHandle, 'xvid_decore');

  xinit.version := XVID_VERSION;
  xinit.cpu_flags := 0;
  xinit.debug := 0;
  try
    _xvidInited := _globalProc(nil, 0, @xinit, nil) = 0;
  except
    TXviDInitException.Create('编解码器初始化失败');
    _xvidInited := false;
  end;
end;
}
{ TxvidEncoder }

constructor TxvidEncoder.create(xvidcore: TxvidCore);
begin
  _encodeHandle := nil;
  _xvidCore := xvidcore;

end;

procedure TxvidEncoder.init(width, height, rate: Integer);
begin
  FillMemory(@_encparam, sizeof(_encparam), 0);
  _encparam.version := _xvidcore.XVID_VERSION;
  _encparam.profile := XVID_PROFILE_ARTS_L1;
  _encparam.width := width;
  _encparam.height := height;
  _encparam.max_key_interval := 300;
  if _xvidcore.encode(nil, XVID_ENC_CREATE, @_encparam, nil) <> 0 then
    raise TxvidEncodeException.Create('编码器初始化失败');
  _encodeHandle := _encparam.handle;

end;

procedure TxvidEncoder.reset(width, height, rate: Integer);
begin

  _xvidcore.encode(_encodeHandle, XVID_ENC_DESTROY, nil, nil);
  FillMemory(@_encparam, sizeof(_encparam), 0);
  _encparam.version := _xvidcore.XVID_VERSION;
  _encparam.profile := XVID_PROFILE_ARTS_L1;
  _encparam.width := width;
  _encparam.height := height;
  _encparam.max_key_interval := 300;

  if _xvidcore.encode(nil, XVID_ENC_CREATE, @_encparam, nil) <> 0 then
    raise TxvidEncodeException.Create('编码器初始化失败');
  _encodeHandle := _encparam.handle;

end;

destructor TxvidEncoder.Destroy;
begin
  if _encodeHandle <> nil then
    _xvidCore.decode(_encodeHandle, XVID_ENC_DESTROY, nil, nil);

  _xvidcore.RemoveEncoder(self);
  inherited;
end;

function TxvidEncoder.encode(opt: Integer; param1,
  param2: Pointer): integer;
var
  FRAME: xvid_enc_frame_t;
  Eimg_t: xvid_image_t;
begin
  {
    FillMemory(@Eimg_t, Sizeof(Eimg_t), 0);
    Eimg_t.csp := XVID_CSP_BGR or XVID_CSP_VFLIP;
    Eimg_t.plane[0] := lpData;
    Eimg_t.stride[0] := 352 * 3;

    FillMemory(@FRAME, sizeof(FRAME), 0);
    FRAME.version := _xvidCore.XVID_VERSION;
    FRAME.vol_flags := XVID_VOL_QUARTERPEL;
    FRAME.quant_intra_matrix := nil;
    FRAME.quant_inter_matrix := nil;
    FRAME.vop_flags := XVID_VOP_HALFPEL or XVID_VOP_CHROMAOPT or XVID_VOP_TRELLISQUANT; //or XVID_VOP_DEBUG;
    FRAME.motion := XVID_ME_QUARTERPELREFINE16 or XVID_ME_CHROMA_BVOP;
    FRAME.input := Eimg_t;
    FRAME._type := XVID_TYPE_AUTO;
    FRAME.bitstream := @_outbuf[0];

    if VPos < 3 then
      FRAME._type := 1;

    FRAME.quant := 3;

    FRAME.length := 0;

    FRAME.length := _xviDCore.encode(_encodehandle, XVID_ENC_ENCODE, @FRAME, nil);
  }
  result := _xviDCore.encode(_encodehandle, opt, param1,  param2);

end;

{ TxvidDecoder }

constructor TxvidDecoder.create(xvidcore: TxvidCore);
begin
  _decodeHandle := nil;
  _xvidCore := xvidcore;
end;

procedure TxvidDecoder.init(width, height, rate: Integer);
begin
  FillMemory(@_decparam, sizeof(_decparam), 0);
  _decparam.version := _xvidcore.XVID_VERSION;

  if _xvidcore.decode(nil, XVID_DEC_CREATE, @_decparam, nil) <> 0 then
  begin
    _decodeHandle := nil;
    raise TxvidDecodeException.Create('编码器初始化失败');
  end;
  _decodehandle := _decparam.handle;

end;

function TxvidDecoder.decode: integer;
begin

end;


destructor TxvidDecoder.Destroy;
begin
  if _decodeHandle <> nil then
    _xvidCore.decode(_decodeHandle, XVID_DEC_DESTROY, nil, nil);
  _xvidCore.RemoveDecoder(self);
  inherited;
end;

{public function}

function XVID_MAKE_VERSION(a, b, c: Integer): Integer;
begin
  Result := ((a and $FF) shl 16) or ((b and $FF) shl 8) or (c and $FF);
end;

function XVID_VERSION_MAJOR(a: Integer): Byte;
begin
  result := (a shr 16) and $FF;
end;

function XVID_VERSION_MINOR(a: Integer): Byte;
begin
  result := (a shr 8) and $FF;
end;

function XVID_VERSION_PATCH(a: Integer): Byte;
begin
  result := (a shr 0) and $FF;
end;

function XVID_MAKE_API(a, b: Integer): Integer;
begin
  result := ((a and $FF) shl 16) or ((b and $FF) shl 0);
end;

function XVID_API_MAJOR(a: Integer): Integer;
begin
  result := (a shr 16) and $FF;
end;

function XVID_API_MINOR(a: Integer): Integer;
begin
  result := (a shr 0) and $FF;
end;

end.