skl_mpg4_enc.cpp

mpeg4编解码器

      else Reduced_VOP = -1;
    }
  }
}

void SKL_MP4_ENC_I::Setup_Frame_Params(SKL_MP4_FRAME *Frame)
{
  int Param;

    // we ask the analyzer for the final non-VOL params. 
    // It might have better hints than we do.

  Get_Analyzer()->Get_Param( "quant", &Frame->Quant );
  Get_Analyzer()->Get_Param( "fcode", &Frame->Fwd_Code );
  if (Frame->Coding==B_VOP)
    Get_Analyzer()->Get_Param( "fcode-bwd", &Frame->Bwd_Code );

  if (Frame->Reduced_VOP>=0) Frame->Reduced_VOP = 0;
  if (Frame->Coding != B_VOP && Frame->Coding != S_VOP) {
    int Reduc;
    if (Get_Analyzer()->Get_Param( "reduced-frame", &Reduc)) {
      if (Reduc>1) Reduc = 1;
      Frame->Reduced_VOP = Reduc;
    }
  }

  if (Frame->Coding==P_VOP || Frame->Coding==S_VOP) {
    if (!Get_Analyzer()->Get_Param( "rounding", &Frame->Rounding))
      Frame->Rounding ^= 1;
  }
  else {
    if (Frame->Coding==B_VOP)
      Frame->Rounding = 0;
  }

  if (Frame->Coding==S_VOP) {

    Get_Analyzer()->Get_Param( "gmc-mode", &Param );
    if (Param>0) {
      Frame->Coding = S_VOP;
      Sprite_Mode   = SPRITE_GMC;
      Get_Analyzer()->Get_Param( "gmc-pts", &Sprite_Nb_Pts);
      const int (*Warps)[2] = (int (*)[2])Get_Analyzer()->Get_Param( "gmc-warp-pts" );
      for(int n=0; n<Sprite_Nb_Pts; ++n) {
        S_Warp_Pts[n][0] = Warps[n][0];
        S_Warp_Pts[n][1] = Warps[n][1];
      }
    }
    else {
      Frame->Coding = P_VOP;
      Sprite_Mode = SPRITE_NONE;
    }
  }

  Get_Analyzer()->Get_Param( "inter-threshold", &_Inter_Coding_Threshold );
  
  Get_Analyzer()->Get_Param( "use-trellis", &Param );
  Set_Trellis_Usage(!!Param);

  Cur->Coding = Frame->Coding;


  /* TODO: DC_Thresh? Alt_Vert_Scan? ... */
}

//////////////////////////////////////////////////////////
// Main entry point
//////////////////////////////////////////////////////////

int SKL_MP4_ENC_I::Encode(SKL_BYTE *Buf, int Max_Len)
{
  SKL_ASSERT(Width!=0 && Height!=0 && Get_Analyzer()!=0);

  if (Last==0) {  // no user input. Check if we have a pending B-VOP in store...
    return 0;
  }
  SKL_MP4_FRAME *Frame = this;
  Cur = Last;                       // get Input frame
  Last = 0;                         // mark it consumed
  Frame->Time = Cur->Time_Ticks;    // set time
  Cur->Map = All_Maps[Cur_Map].Map; // assign analysis map
  Cur->MV  = All_Maps[Cur_Map].MV;  // assign analysis MV map
  if (++Cur_Map==Nb_Maps)
    Cur_Map = 0;

  Future->Map = 0;                  // sanity check
  Future->MV = 0;                   // ""

    // Analyze new frame -> decide: Coding, MB types, Quant, dQ, ...

      // 1rst pass: Motion analysis

  Frame->Coding = Get_Analyzer()->Analyze(this);

  if (Frame->Coding==I_VOP && _Key_VOL_Headers)
    _Need_VOL_Header = 1;

  Setup_VOL_Params();  // might trigger a _Need_VOL_Header

    // We, as encoder, have the final word about frame Coding type.

  if (_Need_VOL_Header)
  {
      // it's not a real scene change. Just a checkpoint: we must
      // insert an I-VOP after a VOL header) => Don't reset the MVs!
      // They might be useful for the next frame analysis.
    Frame->Coding = I_VOP;
  }

  if (Frame->Coding==B_VOP) {}
  else if (Frame->Coding==S_VOP) {}

    // 2nd pass for spatial analysis (dQ)

  Get_Analyzer()->Analyze_dQ(this, Frame->Coding==B_VOP);

    // Frame params are now ready => code bitstream syntax

  Setup_Frame_Params(Frame);
  Code_Frame(Buf, Max_Len, this);

    // send some stats to the analyzer

  Get_Analyzer()->Post_Coding_Update( this );
  Frame_Number++;

    // display debug infos

  if (Debug_Level) {
    if (Debug_Level==4) Dump_Map(Cur, 0);
    else if (Debug_Level==5) Dump_Map(Cur, 1);
    else if (Debug_Level==6) Dump_Map(Cur, 2);
  }

    // reorder frames if needed

  int Ticks;    // save current time first, before swapping
  Get_Analyzer()->Get_Param( "frame-ticks", &Ticks );
  SKL_UINT64 Next_Time_Ticks = Cur->Time_Ticks + Ticks;

  if (Frame->Coding!=B_VOP) {
    Aux    = Past;
    Past   = Cur;
    Cur    = Future;
    Future = Aux;
    Aux    = Cur;
    Time_Last_Coded = Past->Time_Ticks;
    Time_Ref = Past->Time_Ticks / Time_Frequency;   // sync-point

#if 0
       // secure tickers every 65k-ticks, to avoid overflows
    if (Time_Last_Coded>0x10000) {
      Time_Ref -= 0x10000;
      Time_Last_Coded -= 0x10000;
      Next_Time_Ticks -= 0x10000 * Time_Frequency;
    }
#endif
  }

    // setup time of next-to-be-encoded frame, just in
    // case the user forgets to (or doesn't care doing so).

  Aux->Time_Ticks = Next_Time_Ticks;
  Aux->Time = (double)(SKL_INT64)Next_Time_Ticks / (double)(SKL_INT64)Time_Frequency;

  Aux->Map = 0; // sanity check
  Aux->MV  = 0; // ""
  Aux->Coding = -1; // sanity check

  return Coded_Bits/8;
}

//////////////////////////////////////////////////////////
// class SKL_MP4_ENC_I
//////////////////////////////////////////////////////////

SKL_MP4_ENC_I::SKL_MP4_ENC_I(SKL_MEM_I *Mem)
  : SKL_MP4_I(Mem)
  , SKL_MP4_ENC()
  , _Dflt_Analyzer(Skl_MP4_Get_Default_Analyzer(Mem))
{
  _Buf_Size     = 0;
  _Buf          = 0;
  _Buf_Len      = 0;
  
  _In_Pic = 0;

  _Need_VOL_Header = 1;
  _Key_VOL_Headers = 0;
   _Emit_SEQ_Codes = 0;
  _Analyzer = 0;
  _Use_Trellis = -1;
  Set_Trellis_Usage(1);
  Init_VOL(0);
  Set_Analyzer( _Dflt_Analyzer );
  Clear_Aux();
}

SKL_MP4_ENC_I::~SKL_MP4_ENC_I()
{
  Clear_Aux();
  Clear_Buf();
  if (_Analyzer!=0) _Analyzer->Shut_Down();
  _Analyzer = 0;
  Skl_MP4_Destroy_Default_Analyzer( _Dflt_Analyzer );
}

SKL_MP4_ANALYZER *SKL_MP4_ENC_I::Set_Analyzer(SKL_MP4_ANALYZER *Anl)
{
  SKL_MP4_ANALYZER *Previous = _Analyzer;
  if (_Analyzer!=0) _Analyzer->Shut_Down();
  _Analyzer = (Anl==0) ? _Dflt_Analyzer : Anl;
  _Analyzer->Wake_Up(Previous);
  return Previous;
}

SKL_MP4_ANALYZER *SKL_MP4_ENC_I::Get_Analyzer() const
{
  return _Analyzer;
}

void SKL_MP4_ENC_I::Set_Slicer(SKL_MP4_SLICER Slicer, SKL_ANY Slicer_Data) {
  SKL_MP4_I::Set_Slicer(Slicer, Slicer_Data);
}

SKL_MEM_I *SKL_MP4_ENC_I::Set_Memory_Manager(SKL_MEM_I *Mem)
{
  return SKL_MP4_I::Set_Memory_Manager(Mem);
}

void SKL_MP4_ENC_I::Set_Custom_Matrix(int Intra, const SKL_BYTE *M) {
  if (Set_Matrix(Intra, M))
    _Need_VOL_Header = 1;
}

int SKL_MP4_ENC_I::Ioctl(SKL_CST_STRING Param)
{
  if (Param==0) return -1;
  if (!strcmp(Param, "emit-key-headers")) {
    _Key_VOL_Headers = 1;
    return 1;
  }
  else if (!strcmp(Param, "no-emit-key-headers")) {
    _Key_VOL_Headers = 0;
    return 1;
  }
  else if (!strcmp(Param, "emit-sequence-codes")) {
    _Emit_SEQ_Codes = 1;
    return 1;
  }
  else if (!strcmp(Param, "no-emit-sequence-codes")) {
    _Emit_SEQ_Codes = 0;
    return 1;
  }

  return 0;
}

//////////////////////////////////////////////////////////

void SKL_MP4_ENC_I::Alloc_Aux() { /* nothing more needed, for now */ }
void SKL_MP4_ENC_I::Clear_Aux() { /* nothing more needed, for now */ }

SKL_MP4_PIC *SKL_MP4_ENC_I::Prepare_For_Input(int W, int H)
{
  if (W<=0 || W>2048 || H<=0 || H>2048)
    return 0;

  if (Width!=W || Height!=H)
  {
    Init_Pics(W, H, 3, 2);  // will store new W/H
    Alloc_Aux();            // init our own rest
    _Need_VOL_Header = 1;      
  }

   // user input is always 'Aux'
   // Time_Ticks should be ok from last encoding
  Last = Aux;
  return Last;
}

void SKL_MP4_ENC_I::Set_CPU( SKL_CPU_FEATURE Cpu )
{
  SKL_MP4_I::Set_CPU(Cpu);
  Set_Trellis_Usage(_Use_Trellis);
}

void SKL_MP4_ENC_I::Set_Trellis_Usage(const int Do_It)
{
  _Use_Trellis = Do_It;
}

//////////////////////////////////////////////////////////
// Interface Wrappers

void SKL_MP4_ENC_I::Set_Debug_Level(int Level) {
  SKL_MP4_I::Set_Debug_Level( Level );
}

const SKL_MP4_PIC *
SKL_MP4_ENC_I::Prepare_Next_Frame(int Width, int Height)
{
  _In_Pic = Prepare_For_Input(Width, Height);
  return _In_Pic;
}

const SKL_MP4_PIC *SKL_MP4_ENC_I::Get_Next_Frame() const
{
  return _In_Pic;
}

const SKL_MP4_PIC *SKL_MP4_ENC_I::Get_Last_Coded_Frame() const
{
  return Past;   // TODO: this is wrong for B-vop
}

void SKL_MP4_ENC_I::Get_All_Frames(SKL_MP4_PIC *Pic) const
{
  SKL_MP4_I::Get_All_Frames(Pic);
}

int SKL_MP4_ENC_I::Encode()
{
  size_t Needed_Size = (_In_Pic->Width*_In_Pic->Height)*2; // TODO: safety factor?

  int Buf_Size_Max = 0;
  if (Get_Analyzer()->Get_Param("buffer-size", &Buf_Size_Max))
    if (Buf_Size_Max>0 && Needed_Size>(size_t)Buf_Size_Max)
      Needed_Size = Buf_Size_Max;

  if (Needed_Size<4096) Needed_Size = 4096;
  Check_Buf_Size( Needed_Size );

  _Buf_Len = Encode(_Buf, _Buf_Len);
  return _Buf_Len;
}

int SKL_MP4_ENC_I::Finish_Encoding()
{
  // TODO: Check for a pending B-VOP...
  // TODO: should we emit a SEQ_END code?
  
  if (_Emit_SEQ_Codes) {
    SKL_FBB Bits(_Buf);
    Bits.Put_DWord(SEQ_END_CODE);
    _Buf_Len = 4;
    return 4;
  }
  return 0;
}

const SKL_BYTE *SKL_MP4_ENC_I::Get_Bits() const {
  return _Buf;
}

int SKL_MP4_ENC_I::Get_Bits_Length() const {
  return _Buf_Len;
}

void SKL_MP4_ENC_I::Check_Buf_Size(const size_t Needed_Size)
{
  if (Needed_Size>_Buf_Size)
  {
    SKL_BYTE *New_Buf = (Mem!=0) ? (SKL_BYTE*)Mem->New( Needed_Size )
                                 : (SKL_BYTE*)malloc( Needed_Size );
    if (New_Buf==0)
      Skl_Throw( SKL_MEM_EXCEPTION("Byte buffer", Needed_Size) );
    if (_Buf_Len>0)
      SKL_MEMCPY(New_Buf, _Buf, _Buf_Len);
    Clear_Buf();
    _Buf      = New_Buf;
    _Buf_Size = Needed_Size;
  }
  else {
    // TODO: shrink the _Buf from time to time?
  }
}

void SKL_MP4_ENC_I::Clear_Buf() {
  if (_Buf_Size>0) {
    if (Mem) Mem->Delete( _Buf, _Buf_Size );
    else free( _Buf );
  }
  _Buf_Size = 0;
  _Buf = 0;
  /* Don't touch _Len, here. We might just be swapping buffers.. */
}


//////////////////////////////////////////////////////////
// SKL_MP4_ENC
//////////////////////////////////////////////////////////

SKL_MP4_ENC::SKL_MP4_ENC() {}
SKL_MP4_ENC::~SKL_MP4_ENC() {}

//////////////////////////////////////////////////////////
// C factory

extern "C" {

SKL_EXPORT
SKL_MP4_ENC *Skl_MP4_New_Encoder() { 
  return (SKL_MP4_ENC*)::new SKL_MP4_ENC_I((SKL_MEM_I*)0);
}


SKL_EXPORT
void Skl_MP4_Delete_Encoder(SKL_MP4_ENC *Enc) { ::delete (SKL_MP4_ENC_I*)Enc; }

} // extern "C"

//////////////////////////////////////////////////////////