vdecoder.cc

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

}


void VideoDecoder::MC_Frame_FrameBased(const Macroblock& mb,uint16 mb_mode)
{
  struct MotionCompensation_SglMB::MCData mcdata;
  MotionCompensation_SglMB::MCompFunc*const* mclum_func;
  MotionCompensation_SglMB::MCompFunc*const* mcchr_func;

  mcdata.bytesperline_lum = lineskip_lum;
  mcdata.bytesperline_chr = lineskip_chr;
  mcdata.blkheight=16;
  mcdata.blkheight_chr=mb_chr_h;
                    
  mcdata.currimg.y  = dp_y;
  mcdata.currimg.cr = dp_cr;
  mcdata.currimg.cb = dp_cb;

  int offs_y  = dp_y  - sp_curr_y;
  int offs_cr = dp_cr - sp_curr_cr;
  int offs_cb = dp_cb - sp_curr_cb;
  Assert(offs_cr==offs_cb);

  if ((mb_mode & (MBMODE_MVFWD|MBMODE_MVBKW))==(MBMODE_MVFWD|MBMODE_MVBKW))
    {
      mcdata.lastimg.y  = offs_y  + sp_last_y[0];
      mcdata.lastimg.cr = offs_cr + sp_last_cr[0];
      mcdata.lastimg.cb = offs_cb + sp_last_cb[0];
                        
      mcdata.nextimg.y  = offs_y  + sp_next_y[0];
      mcdata.nextimg.cr = offs_cr + sp_next_cr[0];
      mcdata.nextimg.cb = offs_cb + sp_next_cb[0];

      SetReferencePtrsFrm(mcdata.lastimg,mb.m_forward1);
      SetReferencePtrsFrm(mcdata.nextimg,mb.m_backward1);

      SetHalfPelFlags2(mcdata,mb.m_forward1,mb.m_backward1);

      mclum_func = d_motcomp->AskMCompFunc_Dbl_Luma();
      mcchr_func = d_motcomp->AskMCompFunc_Dbl_Chroma(CHROMA_420);
    }
  else
    {
      const MotionVector* mv;
      if (mb.m_HasMotionForward)
	{
	  mv = &mb.m_forward1;

	  mcdata.lastimg.y  = offs_y  + sp_last_y[0];
	  mcdata.lastimg.cr = offs_cr + sp_last_cr[0];
	  mcdata.lastimg.cb = offs_cb + sp_last_cb[0];
	}
      else
	{
	  mv = &mb.m_backward1;

	  mcdata.lastimg.y  = offs_y  + sp_next_y[0];
	  mcdata.lastimg.cr = offs_cr + sp_next_cr[0];
	  mcdata.lastimg.cb = offs_cb + sp_next_cb[0];
	}
                        
      mcdata.nextimg.y  = mcdata.nextimg.cr = mcdata.nextimg.cb = NULL;

      SetReferencePtrsFrm(mcdata.lastimg,*mv);
      SetHalfPelFlags1(mcdata,*mv);

      mclum_func = d_motcomp->AskMCompFunc_Sgl_Luma();
      mcchr_func = d_motcomp->AskMCompFunc_Sgl_Chroma(CHROMA_420);
    }

  (*(mclum_func[mcdata.LumaHalfFlags  ]))(&mcdata);
  (*(mcchr_func[mcdata.ChromaHalfFlags]))(&mcdata);
}


void VideoDecoder::MC_Frame_FieldBased(const Macroblock& mb,uint16 mb_mode)
{
  struct MotionCompensation_SglMB::MCData mcdata;
  MotionCompensation_SglMB::MCompFunc*const* mclum_func;
  MotionCompensation_SglMB::MCompFunc*const* mcchr_func;

  int offs_y  = dp_y  - sp_curr_y;
  int offs_cr = dp_cr - sp_curr_cr;
  int offs_cb = dp_cb - sp_curr_cb;
  Assert(offs_cr==offs_cb);

  for (int i=0;i<2;i++)
    {
      const MotionVector* mvfwd;
      const MotionVector* mvbkw;
      if (i==0)
	{
	  mcdata.currimg.y  = dp_y;
	  mcdata.currimg.cr = dp_cr;
	  mcdata.currimg.cb = dp_cb;
	  mvfwd = &mb.m_forward1;
	  mvbkw = &mb.m_backward1;
	}
      else
	{
	  mcdata.currimg.y  = dp_y +lineskip_lum;
	  mcdata.currimg.cr = dp_cr+lineskip_chr;
	  mcdata.currimg.cb = dp_cb+lineskip_chr;
	  mvfwd = &mb.m_forward2;
	  mvbkw = &mb.m_backward2;
	}

      if ((mb_mode & (MBMODE_MVFWD|MBMODE_MVBKW))==(MBMODE_MVFWD|MBMODE_MVBKW))
	{
	  if (mvfwd->m_vertical_field_select)
	    {
	      mcdata.lastimg.y  = offs_y  + sp_last_y[0]  + lineskip_lum;
	      mcdata.lastimg.cr = offs_cr + sp_last_cr[0] + lineskip_chr;
	      mcdata.lastimg.cb = offs_cb + sp_last_cb[0] + lineskip_chr;
	    }
	  else
	    {
	      mcdata.lastimg.y  = offs_y  + sp_last_y[0];
	      mcdata.lastimg.cr = offs_cr + sp_last_cr[0];
	      mcdata.lastimg.cb = offs_cb + sp_last_cb[0];
	    }

	  if (mvbkw->m_vertical_field_select)
	    {
	      mcdata.nextimg.y  = offs_y  + sp_next_y[0]  + lineskip_lum;
	      mcdata.nextimg.cr = offs_cr + sp_next_cr[0] + lineskip_chr;
	      mcdata.nextimg.cb = offs_cb + sp_next_cb[0] + lineskip_chr;
	    }
	  else
	    {
	      mcdata.nextimg.y  = offs_y  + sp_next_y[0];
	      mcdata.nextimg.cr = offs_cr + sp_next_cr[0];
	      mcdata.nextimg.cb = offs_cb + sp_next_cb[0];
	    }

	  SetReferencePtrsFld(mcdata.lastimg,*mvfwd);
	  SetReferencePtrsFld(mcdata.nextimg,*mvbkw);

	  SetHalfPelFlags2(mcdata,*mvfwd,*mvbkw);
                            
	  mclum_func = d_motcomp->AskMCompFunc_Dbl_Luma();
	  mcchr_func = d_motcomp->AskMCompFunc_Dbl_Chroma(CHROMA_420);
	}
      else
	{
	  const MotionVector* mv;
	  if (mb.m_HasMotionForward)
	    {
	      mv = mvfwd;
                                
	      if (mvfwd->m_vertical_field_select)
		{
		  mcdata.lastimg.y  = offs_y  + sp_last_y[0]  + lineskip_lum;
		  mcdata.lastimg.cr = offs_cr + sp_last_cr[0] + lineskip_chr;
		  mcdata.lastimg.cb = offs_cb + sp_last_cb[0] + lineskip_chr;
		}
	      else
		{
		  mcdata.lastimg.y  = offs_y  + sp_last_y[0];
		  mcdata.lastimg.cr = offs_cr + sp_last_cr[0];
		  mcdata.lastimg.cb = offs_cb + sp_last_cb[0];
		}
	    }
	  else
	    {
	      mv = mvbkw;
                                
	      if (mvbkw->m_vertical_field_select)
		{
		  mcdata.lastimg.y  = offs_y  + sp_next_y[0]  + lineskip_lum;
		  mcdata.lastimg.cr = offs_cr + sp_next_cr[0] + lineskip_chr;
		  mcdata.lastimg.cb = offs_cb + sp_next_cb[0] + lineskip_chr;
		}
	      else
		{
		  mcdata.lastimg.y  = offs_y  + sp_next_y[0];
		  mcdata.lastimg.cr = offs_cr + sp_next_cr[0];
		  mcdata.lastimg.cb = offs_cb + sp_next_cb[0];
		}
	    }
                            
	  SetReferencePtrsFld(mcdata.lastimg,*mv);
	  SetHalfPelFlags1(mcdata,*mv);
                            
	  mclum_func = d_motcomp->AskMCompFunc_Sgl_Luma();
	  mcchr_func = d_motcomp->AskMCompFunc_Sgl_Chroma(CHROMA_420);
	}

      mcdata.bytesperline_lum = lineskip_lum*2;
      mcdata.bytesperline_chr = lineskip_chr*2;
      mcdata.blkheight=8;
      mcdata.blkheight_chr=mb_chr_h/2;

      (*(mclum_func[mcdata.LumaHalfFlags]))(&mcdata);
      (*(mcchr_func[mcdata.ChromaHalfFlags]))(&mcdata);
    }
}


void VideoDecoder::MC_Field_FieldBased(const Macroblock& mb,uint16 mb_mode)
{
  struct MotionCompensation_SglMB::MCData mcdata;
  MotionCompensation_SglMB::MCompFunc*const* mclum_func;
  MotionCompensation_SglMB::MCompFunc*const* mcchr_func;

  mcdata.currimg.y  = dp_y;
  mcdata.currimg.cr = dp_cr;
  mcdata.currimg.cb = dp_cb;

  mcdata.bytesperline_lum = lineskip_lum;
  mcdata.bytesperline_chr = lineskip_chr;
  mcdata.blkheight=16;
  mcdata.blkheight_chr=mb_chr_h;

  int offs_y  = dp_y  - sp_curr_y;
  int offs_cr = dp_cr - sp_curr_cr;
  int offs_cb = dp_cb - sp_curr_cb;
  Assert(offs_cr==offs_cb);

  if ((mb_mode & (MBMODE_MVFWD|MBMODE_MVBKW))==(MBMODE_MVFWD|MBMODE_MVBKW))
    {
      mcdata.lastimg.y  = offs_y  + sp_last_y [mb.m_forward1.m_vertical_field_select];
      mcdata.lastimg.cr = offs_cr + sp_last_cr[mb.m_forward1.m_vertical_field_select];
      mcdata.lastimg.cb = offs_cb + sp_last_cb[mb.m_forward1.m_vertical_field_select];
                        
      mcdata.nextimg.y  = offs_y  + sp_next_y [mb.m_backward1.m_vertical_field_select];
      mcdata.nextimg.cr = offs_cr + sp_next_cr[mb.m_backward1.m_vertical_field_select];
      mcdata.nextimg.cb = offs_cb + sp_next_cb[mb.m_backward1.m_vertical_field_select];
                        
      SetReferencePtrsFrm(mcdata.lastimg,mb.m_forward1);
      SetReferencePtrsFrm(mcdata.nextimg,mb.m_backward1);
                        
      SetHalfPelFlags2(mcdata,mb.m_forward1,mb.m_backward1);
                        
      mclum_func = d_motcomp->AskMCompFunc_Dbl_Luma();
      mcchr_func = d_motcomp->AskMCompFunc_Dbl_Chroma(CHROMA_420);
    }
  else
    {
      const MotionVector* mv;
      if (mb.m_HasMotionForward)
	{
	  mv = &mb.m_forward1;
                            
	  mcdata.lastimg.y  = offs_y +sp_last_y [mb.m_forward1.m_vertical_field_select];
	  mcdata.lastimg.cr = offs_cr+sp_last_cr[mb.m_forward1.m_vertical_field_select];
	  mcdata.lastimg.cb = offs_cb+sp_last_cb[mb.m_forward1.m_vertical_field_select];
	}
      else
	{
	  mv = &mb.m_backward1;
                            
	  mcdata.lastimg.y  =offs_y +sp_next_y [mb.m_backward1.m_vertical_field_select];
	  mcdata.lastimg.cr =offs_cr+sp_next_cr[mb.m_backward1.m_vertical_field_select];
	  mcdata.lastimg.cb =offs_cb+sp_next_cb[mb.m_backward1.m_vertical_field_select];
	}
                        
      SetReferencePtrsFrm(mcdata.lastimg,*mv);
      SetHalfPelFlags1(mcdata,*mv);
                        
      mclum_func = d_motcomp->AskMCompFunc_Sgl_Luma();
      mcchr_func = d_motcomp->AskMCompFunc_Sgl_Chroma(CHROMA_420);
    }
                    
  (*(mclum_func[mcdata.LumaHalfFlags]))(&mcdata);
  (*(mcchr_func[mcdata.ChromaHalfFlags]))(&mcdata);
}

void VideoDecoder::MC_Field_16x8(const Macroblock& mb,uint16 mb_mode)
{
  struct MotionCompensation_SglMB::MCData mcdata;
  MotionCompensation_SglMB::MCompFunc*const* mclum_func;
  MotionCompensation_SglMB::MCompFunc*const* mcchr_func;

  mcdata.currimg.y  = dp_y;
  mcdata.currimg.cr = dp_cr;
  mcdata.currimg.cb = dp_cb;

  mcdata.bytesperline_lum = lineskip_lum;
  mcdata.bytesperline_chr = lineskip_chr;
  mcdata.blkheight=8;
  mcdata.blkheight_chr=mb_chr_h/2;

  int offs_y  = dp_y  - sp_curr_y;
  int offs_cr = dp_cr - sp_curr_cr;
  int offs_cb = dp_cb - sp_curr_cb;
  Assert(offs_cr==offs_cb);

  for (int v=0;v<2;v++)
    {
      if ((mb_mode & (MBMODE_MVFWD|MBMODE_MVBKW))==(MBMODE_MVFWD|MBMODE_MVBKW))
	{
	  mcdata.lastimg.y  = offs_y  + sp_last_y [mb.m_vector[v][0].m_vertical_field_select];
	  mcdata.lastimg.cr = offs_cr + sp_last_cr[mb.m_vector[v][0].m_vertical_field_select];
	  mcdata.lastimg.cb = offs_cb + sp_last_cb[mb.m_vector[v][0].m_vertical_field_select];
                        
	  mcdata.nextimg.y  = offs_y  + sp_next_y [mb.m_vector[v][1].m_vertical_field_select];
	  mcdata.nextimg.cr = offs_cr + sp_next_cr[mb.m_vector[v][1].m_vertical_field_select];
	  mcdata.nextimg.cb = offs_cb + sp_next_cb[mb.m_vector[v][1].m_vertical_field_select];
                        
	  SetReferencePtrsFrm(mcdata.lastimg,mb.m_vector[v][0]);
	  SetReferencePtrsFrm(mcdata.nextimg,mb.m_vector[v][1]);
                        
	  SetHalfPelFlags2(mcdata,mb.m_vector[v][0],mb.m_vector[v][1]);
                        
	  mclum_func = d_motcomp->AskMCompFunc_Dbl_Luma();
	  mcchr_func = d_motcomp->AskMCompFunc_Dbl_Chroma(CHROMA_420);
	}
      else
	{
	  const MotionVector* mv;
	  if (mb.m_HasMotionForward)
	    {
	      mv = &mb.m_vector[v][0];
                            
	      mcdata.lastimg.y  = offs_y +sp_last_y [mb.m_vector[v][0].m_vertical_field_select];
	      mcdata.lastimg.cr = offs_cr+sp_last_cr[mb.m_vector[v][0].m_vertical_field_select];
	      mcdata.lastimg.cb = offs_cb+sp_last_cb[mb.m_vector[v][0].m_vertical_field_select];
	    }
	  else
	    {
	      mv = &mb.m_vector[v][1];
                            
	      mcdata.lastimg.y  =offs_y +sp_next_y [mb.m_vector[v][1].m_vertical_field_select];
	      mcdata.lastimg.cr =offs_cr+sp_next_cr[mb.m_vector[v][1].m_vertical_field_select];
	      mcdata.lastimg.cb =offs_cb+sp_next_cb[mb.m_vector[v][1].m_vertical_field_select];
	    }
                        
	  SetReferencePtrsFrm(mcdata.lastimg,*mv);
	  SetHalfPelFlags1(mcdata,*mv);
                        
	  mclum_func = d_motcomp->AskMCompFunc_Sgl_Luma();
	  mcchr_func = d_motcomp->AskMCompFunc_Sgl_Chroma(CHROMA_420);
	}
                    
      (*(mclum_func[mcdata.LumaHalfFlags]))(&mcdata);
      (*(mcchr_func[mcdata.ChromaHalfFlags]))(&mcdata);

      mcdata.currimg.y  += lineskip_lum*8;
      mcdata.currimg.cb += lineskip_chr*mb_chr_h/2;
      mcdata.currimg.cr += lineskip_chr*mb_chr_h/2;

      offs_y  += lineskip_lum*8;
      offs_cr += lineskip_chr*mb_chr_h/2;
      offs_cb += lineskip_chr*mb_chr_h/2;
    }
}

static bool cbblks[12] =
{ false,false,false,false,
  true, false,true, false,
  true, false,true, false
};


static int blk_xoffs[12] = { 0,8,0,8, 0,0,0,0, 8,8,8,8 };
static int blk_yoffs[12] = { 0,0,8,8, 0,0,8,8, 0,0,8,8 };

static int blk_xoffs_field[12] = { 0,8,0,8, 0,0,0,0, 8,8,8,8 };
static int blk_yoffs_field[12] = { 0,0,1,1, 0,0,1,1, 0,0,1,1 };


inline void VideoDecoder::AdvancePtrsMB()
{
  dp_y  += 16;
  dp_cr +=  mb_chr_w;
  dp_cb += mb_chr_w;
}

inline void VideoDecoder::AdvancePtrsMBRow()
{
  dp_y  += 15*lineskip_lum;
  int cskip = 7*lineskip_chr + bytesperline_chr-d_MBWidth*mb_chr_w;
  dp_cr += cskip;
  dp_cb += cskip;
}


void VideoDecoder::FlushBSlice(int mbrow)
{
#ifndef SEND_FULL_BFRAMES
  d_curr->m_may_modify = true;
  d_curr->m_src_y_start = d_field_offset;

  if (d_pichdr.m_picture_structure == PICSTRUCT_FramePicture)
    { d_curr->m_src_y_end   = 15;                d_curr->m_field_lines=false; }
  else 
    { d_curr->m_src_y_end   = 30+d_field_offset; d_curr->m_field_lines=true; }

  switch (d_pichdr.m_picture_structure)
    {
    case PICSTRUCT_FramePicture: d_curr->m_dst_y_start = mbrow*16;   break;
    case PICSTRUCT_TopField:     d_curr->m_dst_y_start = mbrow*32;   break;
    case PICSTRUCT_BottomField:  d_curr->m_dst_y_start = mbrow*32+1; break;
    }

  int end_line = d_curr->m_dst_y_start + (d_curr->m_src_y_end-d_curr->m_src_y_start);
  if (end_line >= d_seqdata.m_Height)
    {
      end_line = d_seqdata.m_Height-1;
      d_curr->m_src_y_end = end_line  + d_curr->m_src_y_start - d_curr->m_dst_y_start;
    }
      
  d_sink->ShowMBRows(d_curr);  // Show image

  const int nRows = ((d_pichdr.m_picture_structure == PICSTRUCT_FramePicture) ? 1 : 2);

  for (int n=0;n<2;n++)
    {
      sp_last_y[n]  += nRows*bytesperline_lum*16;
      sp_last_cr[n] += nRows*bytesperline_chr*mb_chr_h;
      sp_last_cb[n] += nRows*bytesperline_chr*mb_chr_h;

      sp_next_y[n]  += nRows*bytesperline_lum*16;
      sp_next_cr[n] += nRows*bytesperline_chr*mb_chr_h;
      sp_next_cb[n] += nRows*bytesperline_chr*mb_chr_h;
    }      

  dp_y  = ptr_y [0];
  dp_cr = ptr_cr[0];
  dp_cb = ptr_cb[0];
#endif
}

void VideoDecoder::DecodeSlice(class FastBitBuf& bs)
{
  try
    {
      if (d_skip_this_frame)
	return;

      const bool IsBPicture = (d_pichdr.m_picture_coding_type == PICTYPE_B);

      int startcode = bs.GetBits(24);
      Assert(startcode==0x000001);

      struct
      {
	uint16 vpos;
	uint8  priority_breakpoint;
	uint5  quantiser_scale_code;
	bool   intra_slice;
      } slicehdr; 

      slicehdr.intra_slice=false;


      // *** decode slice header ***
      slicehdr.vpos = bs.GetBits(8)-1;


      struct MotionCompensation_SglMB::MCData mcdata;
      MotionCompensation_SglMB::MCompFunc*const* mclum_func;
      MotionCompensation_SglMB::MCompFunc*const* mcchr_func;


      int PMV [2 /* f/s */] [2 /* fw/bw */] [2 /* h/v */];

#ifndef SEND_FULL_BFRAMES
      if (IsBPicture)
	{
	  // reuse the same lines every time

	  dp_y  = ptr_y [0]-16;
	  dp_cr = ptr_cr[0]-mb_chr_w;
	  dp_cb = ptr_cb[0]-mb_chr_w;
	}
      else
#endif
	{
	  dp_y  = ptr_y [slicehdr.vpos*16]-16;
	  dp_cr = ptr_cr[slicehdr.vpos*mb_chr_h]-mb_chr_w;