Videowindow: directshow播放画面刷新问题,

开始播放后画面会出来，一切正常。现在的问题是

当别的未最大化的窗口半遮或全遮住视频窗口，画面不都能正常刷新, 只有拖动一下dialog画面才会出来

但是:当此dialog最小化，再恢复时, 能正常刷新

我出现的问题,和下列问题都不相同,导致处理方法也不相同.

大多数刷新问题,都可以从下面这个帖子,去解决.

http://blog.csdn.net/arthurlee/archive/2008/10/09/3043977.aspx

http://www.qqgb.com/Program/VC/VCJQ/Program_176331.html

pVidWin-> put_Owner((OAHWND)GetDlgItem(IDC_VW_FRAME)-> GetSafeHwnd());  
2、GetDlgItem(IDC_VW_FRAME)-> ModifyStyle(0,       WS_CLIPCHILDREN);  
3、OnPaint       不用动  
4、OnEraseBkgnd       加如下代码  
           
            RECT       rect;  
            GetDlgItem(IDC_VW_FRAME)-> GetWindowRect(&rect);  
            ScreenToClient(&rect);  
            pDC->   ExcludeClipRect(&rect);  
            return       CDialog::OnEraseBkgnd(pDC);  

可是我的窗口不要上面这四条,只要把窗口属性设置成

DWORD m_dwExStyle=WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR| WS_EX_WINDOWEDGE;

     m_pPlayWnd->CreateEx(m_dwExStyle,

         oClassName,_T("Play"),

         WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN| WS_CLIPSIBLINGS|WS_POPUP,

我的程序是这样的：一个dialog里面 new CPlaybackwnd

class CPlaybackwnd : public CWnd

在CPlaybackwnd这个里面, 增加,m_pVW->put_WindowStyle ,,

m_pVW->put_Owner((OAHWND)(GetSafeHwnd()));

但是,当把playbackwnd的属性,设置成dialog的WS_POPUP, WS_CHILD后,窗口移动时位置就不对了,

我在dialog里面增加了,

void CDialog::OnWindowPosChanged(WINDOWPOS* lpwndpos)

{

     __super::OnWindowPosChanged(lpwndpos);

     if (m_pPlayWnd)

     {

         int x = m_nWnd_x + lpwndpos->x;

         int y = m_nWnd_y + lpwndpos->y;

         int cx = m_nWnd_cx;

         int cy = m_nWnd_cy;

         m_pPlayWnd->MoveWindow(x,y,cx,cy);

     }

}

但是,这个程序在win2000下会出现问题,其它操作系统是好的.

在win2000下,窗口坐标是乱了, 即dialog和playbackwnd的相对位置错误了,目前还没有解决.

MXF class列举:

class CMXFDataStruct
{
public:
 CMXFDataStruct(void);
 ~CMXFDataStruct(void);

 BYTE *pGeneraltion_UID;
 BYTE *pInstance_ID;

 CMarkup _ElementXML;
 CString _strElementName;
 CString _strTypeBase;
};
typedef std::list< CMXFDataStruct *> MXFDATASTRUCTLIST;

typedef struct MPCDeviceTag
{
 char  szDeviceName[16];  /*device host name for load balance.*/
 int  nType;      /*device type for reserved.*/
 char szVersion[16];  /*reserved for device version. 4.2.35.6*/
 BYTE    bPDVersion;                 /* PD Version*/
 BYTE    bVixVersion;                /* Vix Version*/
 DWORD  nIndex;
}MPCDEVICE;
#define MPC_DEVICE_TOTAL_COUNT 4
typedef std::list< MPCDEVICE > MPCDEVICELIST;

//mxf packet header(16 BYTES)
typedef struct MXF_PACKETHEADTAG_
{
 unsigned char sync1;
 unsigned char sync2;
 unsigned char sync3;
 unsigned char sync4;

 unsigned char content[9];
 unsigned char PackKind;
 unsigned char State;
 unsigned char reserver;
 unsigned char BER_size;//the length
 unsigned char len[3];//the length = packet length(16) + payload length
}MXF_PACKETHEAD, *PMXF_PACKETHEAD;

//mxf Partition packet (16 BYTES)
typedef struct MXF_PARTITIONTAG_
{
 unsigned char Major_ver[2];
 unsigned char Min_ver[2];
 unsigned char KAG_size[4];
 unsigned char This_Partition[8];

 unsigned char Pre_Partition[8];
 unsigned char Foot_Partition[8];
 unsigned char HeadByteCount[8];
 BYTE IndexByteCount[8];
 BYTE indexSID[4];
 BYTE BodyOffset[8];
 BYTE BodySID[4];
 BYTE Operational[16];

}MXF_PARTITION, *PMXF_PARTITION;

//mxf Partition packet (16 BYTES)
typedef struct MXF_Local_TAG_
{ 
 BYTE LocalNumber[4];
 BYTE LocalSize[4];
 BYTE Guid[16];
}MXF_Local_TAG, *PMXF_Local_TAG;

//mxf Partition packet (16 BYTES)
typedef struct MXF_Local_TAG2_
{ 
 BYTE Local_tag[2];
 BYTE Guid[16];
}MXF_Local_TAG2, *PMXF_Local_TAG2;

enum Find_condition_mxf
{
 g_nFind_Identification = 1,
 g_nFind_pack,
 g_nFind_track,
 g_nFind_sequence,
 g_nFind_SourceClip,
 g_nFind_multipl_desc,
 g_nFind_sub_descriptor,
 g_nFind_Essence_container_data
};

typedef struct MXF_RP224_TAG_ // for Sequence
{ 
 BYTE CheckPart;
 BYTE Smpte_Index;
 LPTSTR lpContent;// Content[51];
 LPTSTR lpDescribe;// Describe[51]; // 16 * 3 + 1
}MXF_RP224_TAG, *PMXF_RP224_TAG;

class CMXF_SourceClip :public CMXFDataStruct // for SourceClip
{
public: 
 CMXF_SourceClip();
 ~CMXF_SourceClip();

 BYTE *pSourcePackageID;
 BYTE ElementType;
 DWORD Source_trackID;
};

typedef std::list< CMXF_SourceClip *> MXF_SOURCECLIP_LIST;

class CMXF_Sequence:public CMXFDataStruct // for Sequence
{
public: 
 CMXF_Sequence();
 ~CMXF_Sequence();  
 BYTE Seq_Type;
 MXF_SOURCECLIP_LIST ListSourceClip;
};

typedef std::list< CMXF_Sequence *> MXF_SEQUENCE_LIST;

class CMXF_Track :public CMXFDataStruct // for track
{
public: 
 CMXF_Track();
 ~CMXF_Track();
 CMXF_Sequence *pSequence; 
 DWORD Track_Number;
 BYTE  Track_Type; // 0=UNKNOWN, 3= timecode trick , 4= picture, 5= sound, 6= data,
   DWORD Track_ID;
};

typedef std::list< CMXF_Track *> MXF_TRACK_LIST;

class CMXF_Base_Descriptor :public CMXFDataStruct // Base_Descriptor
{ 
public:
 CMXF_Base_Descriptor();
 ~CMXF_Base_Descriptor();
 BYTE *pEsssence_Container;
 BYTE Smpte_Index;
};
class CMXF_Sub_descriptor:public CMXF_Base_Descriptor //Material_pack or source pack
{
public: 
 CMXF_Sub_descriptor();
 ~CMXF_Sub_descriptor();
 DWORD Link_Track_ID;
};

typedef std::list< CMXF_Sub_descriptor *> MXF_SUB_DESCRIPTOR_LIST;

class CMXF_Multiple_desc :public CMXF_Base_Descriptor //Multiple descriptor
{ 
public:
 CMXF_Multiple_desc();
 ~CMXF_Multiple_desc();
 MXF_SUB_DESCRIPTOR_LIST ListSubDesc;
 };

class CMXF_Package :public CMXFDataStruct //Material_pack or source pack
{ 
public:
 CMXF_Package();
 ~CMXF_Package();

 CMXF_Multiple_desc *pMultiple_desc;
 BYTE *pPackageUID;

 MXF_TRACK_LIST Listtrack;
 BYTE IsMaterial_pack; //0_unknow ,1_Material package, 2_ source package.
}; 
class CMXF_SourcePackage_ :public CMXF_Package // source pack
{ 
public:
 CMXF_SourcePackage_();
 ~CMXF_SourcePackage_();
};

class CMXF_Material_Package_ :public CMXF_Package //Material_pack
{ 
public:
 CMXF_Material_Package_();
 ~CMXF_Material_Package_(); 
};

typedef std::list< CMXF_Package *> MXF_PACK_LIST;

class CMXF_EssenceContainerData :public CMXFDataStruct//EssenceContainerData
{
public:
 CMXF_EssenceContainerData();
 ~CMXF_EssenceContainerData();     

 DWORD BodySID;
 DWORD IndexSID;
 BYTE *pLinkedPackageUID;

};
             
typedef std::list< CMXF_EssenceContainerData *> MXF_ESSENCECONTAINERDATA_LIST;

class CMXF_Content_storage :public CMXFDataStruct //Content_storage
{ 
public:
 CMXF_Content_storage();
 ~CMXF_Content_storage();

 MXF_PACK_LIST listPackage;                            
 MXF_ESSENCECONTAINERDATA_LIST listEssenceContainerData;
};

class CMXF_Identification :public CMXFDataStruct//Identification
{
public:
 CMXF_Identification();
 ~CMXF_Identification();     
};

typedef std::list< CMXF_Identification *> MXF_IDENTIFICATION_LIST;

class CMXF_Preface :public CMXFDataStruct//Material_pack or source pack
{
public:
 CMXF_Preface();
 ~CMXF_Preface();

 MXF_IDENTIFICATION_LIST listIdentification;
 CMXF_Content_storage Content_storage;
};

class CMXF_Production_Framework :public CMXFDataStruct//CMXF_Production_Framework
{
public:
 CMXF_Production_Framework();
 ~CMXF_Production_Framework();

};

class CMXFBaseTable :
    public CMXFBaseFun
{
public:
    CMXFBaseTable(void);
    ~CMXFBaseTable(void);
    BOOL Init();

    int Prase_Identification(BYTE *pBuf,DWORD PayloadLen);
    int Prase_Preface(BYTE *pBuf,DWORD PayloadLen);
    int Prase_sequence(BYTE *pBuf,DWORD PayloadLen);
    int Prase_RealData(BYTE *pBuf,DWORD PayloadLen);
    int Prase_SourceClip(BYTE *pBuf,DWORD PayloadLen);
    int Prase_TimeCode_Component(BYTE *pBuf,DWORD PayloadLen);
    int Prase_Content_storage(BYTE *pBuf,DWORD PayloadLen);
    int Prase_Material_pack(BYTE *pBuf,DWORD PayloadLen);
    int Prase_Track(BYTE *pBuf,DWORD PayloadLen,CString strPackageName);
    int PraseEssence_Container_data(BYTE *pBuf,DWORD PayloadLen);
    int PraseMetadata_CDCI_Essence_Desc(BYTE *pBuf,DWORD PayloadLen,BYTE nMpeg_desc = 0);
    int Prase_SourcePack(BYTE *pBuf,DWORD PayloadLen);
    int PraseSound_Essence_desc(BYTE *pBuf,DWORD PayloadLen,BYTE nIsPbuf47 = 0);
    int Prase_Multiple_desc(BYTE *pBuf,DWORD PayloadLen);
    int Prase_Generic_pack(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL ISMaterial_pack);
    int Prase_File_Descriptor(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,CMXF_Base_Descriptor *pMulti_desc,BOOL bDefaultIsError = TRUE);
    int Prase_Generic_Picture(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL bDefaultIsError = TRUE);
    int CDCIEssenceDescriptorType(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL bDefaultIsError = TRUE);
    int Prase_Generic_Sound(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL bDefaultIsError = TRUE);

    int Prase_Unknow_Sound(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL bDefaultIsError = TRUE);
    int Mpeg_Video_Descriptor(BYTE *pBuf,DWORD PayloadLen,CString strPackageName,DWORD &CurOffset,BOOL bDefaultIsErro = TRUE);

    int Prase_DM_Segment(BYTE *pBuf,DWORD PayloadLen);
    int Prase_DM_SourceClip(BYTE *pBuf,DWORD PayloadLen);

    void Release_all_list();
public:
    
    TracksMap *m_pTracksMap;
protected:
    CMXF_Preface *m_pPreface;

    //For previous package,It is not parsed.
    MXF_SEQUENCE_LIST m_Unknow_seqList;

    //For previous package,Its ID not found.
    MXF_SOURCECLIP_LIST m_Unknow_SourClipList;

    MXF_SUB_DESCRIPTOR_LIST m_Unknow_SubDescList;

private:
    int    CheckGeneration_UID(CString strLogName,BYTE *pBuf,DWORD PayloadLen);

source仿照系统的asyncflt。cpp。.h ：

 问题出在elecard的demux上面，
 首先，elecard公司写demux filter的时候，肯定只是基于文件的--->  to h264来说，

to, mpeg2来说，都是可以的，
 原因如下： 如果是mpeg2, demux filter 先读取一段数据去parse,找psi，如果找到了，就可以connect了，

因为是读文件的，读了一些数据为了connect， 所以connect 以后，必需调用 SetFilePointer(*g_pHFile,0,NULL,FILE_BEGIN);
 要不然，开头的那一段就无法播放了

但是： 如果是h264， 他先读取一段数据去parse,找psi，就算找到了，也不connect： 如果找到了，而且也是文件末尾了，那就connect

成功， 奶奶的，可是我的这个是网络数据流，那有文件末尾，

他有个 set position的函数，connect 后，就 set 0 了

 建立完整个 graph 之后继续播放，不在乎之前的那点数据的－－－你知道， 前面的那个数据是多大呢16M

 DVB 标清的话，用不了多少就可以搜完台，用不了 16MB

关键是我怎么知道它到底读多少数据就 parse完了呢，难道让我一直等么？，

最早，标清我只要3M的数据，就必需建立graph了，现在h264,高清的，4M，根本不够了，

于是，我的code这样写了，呵呵：HRESULT SetPointer(LONGLONG llPos)
 {
  
   if (g_bIsConnect == 0)
   {
    if (llPos >= (1024 * 1024 * 14))
    {
     //DbgLog((LOG_TRACE, 1, TEXT("\n--Set File Pointer = ld"),llPos));
     return S_FALSE;
    }
 如果connect成功： SetPointer就 永远返回ok
 这样就可以播放了，
 不过，浪费了我14M的数据，唉，
code如后：

if (SUCCEEDED(hr)) 
  hr = CoCreateInstance(CLSID_CEleCardMpegMultiplexer, NULL, CLSCTX_INPROC,
  IID_IBaseFilter, (LPVOID *)&pMPG2Splitter) ;

 if (SUCCEEDED(hr)) 
  hr = m_pGraph->AddFilter(pMPG2Splitter,L"EleCard Mpeg2 DeMultiplexer");

 pPinInTSSplitter = xMyFindPin(pMPG2Splitter,L"Input",0,CLSID_NULL_USER1);

 if (SUCCEEDED(hr)) 
  hr = m_pGraph->Connect(pPinOutSTWrapper,pPinInTSSplitter);

 if (strcmp(m_strFileFormat,"H264") == 0)
 {
  pPinOutTSSplitter_V= xMyFindPin(pMPG2Splitter,L"264",1,MEDIATYPE_Video);
 }
 else
 {  
  pPinOutTSSplitter_V= xMyFindPin(pMPG2Splitter,L"Video",1,MEDIATYPE_Video);
 }

if (strcmp(m_strFileFormat,"H264") == 0)
 {
  if (SUCCEEDED(hr))
   hr = CoCreateInstance(CLSID_CH264VideoDecoder, NULL, CLSCTX_INPROC,    

IID_IBaseFilter, (LPVOID *)&pFIDVDVideoDecorder) ;
  if (SUCCEEDED(hr)) 
   hr = m_pGraph->AddFilter(pFIDVDVideoDecorder,L"EleCard MPEG2 Video Decoder");

  if (SUCCEEDED(hr)) 
   pIDVDVideoDecorderInpin = xMyFindPin(pFIDVDVideoDecorder,L"In",0,MEDIATYPE_Video);

  if(pIDVDVideoDecorderInpin)
   hr = m_pGraph->Connect(pPinOutTSSplitter_V,pIDVDVideoDecorderInpin);

  if (SUCCEEDED(hr)) 
   pIDVDVideoDecorderOutpin = xMyFindPin(pFIDVDVideoDecorder,L"Out",1,MEDIATYPE_Video);
 }
 else
 {
  if (SUCCEEDED(hr))  
   hr = CoCreateInstance(CLSID_CEleCardVideoDec, NULL, CLSCTX_INPROC,
   IID_IBaseFilter, (LPVOID *)&pFIDVDVideoDecorder) ;
  if (SUCCEEDED(hr)) 
   hr = m_pGraph->AddFilter(pFIDVDVideoDecorder,L"EleCard MPEG2 Video Decoder");

  if (SUCCEEDED(hr)) 
   pIDVDVideoDecorderInpin = xMyFindPin(pFIDVDVideoDecorder,L"MPEG In",0,MEDIATYPE_Video);

  if(pIDVDVideoDecorderInpin)
   hr = m_pGraph->Connect(pPinOutTSSplitter_V,pIDVDVideoDecorderInpin);

  if (SUCCEEDED(hr)) 
   pIDVDVideoDecorderOutpin = xMyFindPin(pFIDVDVideoDecorder,L"Video Out",1,MEDIATYPE_Video);

 }

static const GUID CLSID_CEleCardMpegMultiplexer =
{0x136DCBF5,0x3874,0x4B70,0xAE,0x3E,0x15,0x99,0x7d,0x63,0x34,0xf7};
 //  136DCBF5-  3874 - 4B70 - AE   3E - 15   99   7D   63   34   F7

static const GUID CLSID_CEleCardVideoDec=
{0xf50b3f13,0x19c4,0x11cf,0xaa,0x9a,0x02,0x60,0x8c,0x9b,0xab,0xa2};
//{F50B3F13-19C4-11CF-  AA9A-         02   60   8C   9B   AB   A2}

static const GUID CLSID_CMoonlightAudioDec=
{0xe32c3b01,0xc81b,0x4d01,0x8a,0xd4,0x2b,0x93,0xf7,0xfa,0x54,0x4c};

static const GUID CLSID_CH264VideoDecoder=
{0x6A270473,0x9994,0x4aeb,0x80,0x1f,0xbb,0x2c,0x4e,0x56,0xee,0x38};
// 6A270473-  9994-  4AEB-  80   1F-  BB   2C   4E   56   EE   38}

code如下： 如果用下列函数，调用系统自带的File Source，就无需 调用 m_pGraph->RemoveFilter，只要

调用 pFIFileSource->release();就可以了。

但是，如果不是系统的，必需用m_pGraphBuilder->RemoveFilter（），否则，filter的析构函数不会被调

用。

if (SUCCEEDED(hr)) 
  hr = CoCreateInstance(CLSID_AsyncSample, NULL, CLSCTX_INPROC,
        IID_IBaseFilter, (LPVOID *)

&pFIFileSource) ;
 if (SUCCEEDED(hr))
  hr = m_pGraphBuilder->AddFilter(pFIFileSource,L"Sample File Source");

 IFileSourceFilter *pAVIFileSource = NULL;

 if (SUCCEEDED(hr)) 
  hr = pFIFileSource->QueryInterface(IID_IFileSourceFilter,(void **)

&pAVIFileSource);

同样：
if (SUCCEEDED(hr)) 
  hr = CoCreateInstance(CLSID_MYSocketSource, NULL, CLSCTX_INPROC,
        IID_IBaseFilter, (LPVOID *)

&pFIFileSource) ;
 if (SUCCEEDED(hr))
  hr = m_pGraphBuilder->AddFilter(pFIFileSource,L"MY Socket Source");

...
最后必需用m_pGraphBuilder->RemoveFilter（），否则，filter的析构函数不会被调用。否则有很大的内

存泄露。

不知道是什么原因：

因为  www.directshow.cn： 这个网址不行了，所以贴出下列code，请大家分享。


HRESULT ConnectPins( IGraphBuilder* pGraphBuilder,
     IBaseFilter* pOutput,
     IBaseFilter* pInput,
     int nOutIndex,
     int nInIndex)
{
 HRESULT hr = NOERROR;
 ULONG cFetched = 0;
 IEnumPins* pEnumPins = 0;
 IPin* pPinOutput = 0;
 IPin* pPinInput = 0;

 //enum output filter pins.
 hr = pOutput->EnumPins(&pEnumPins);
 if(FAILED(hr))
 {
  return hr;
 }
 //if the pin to connect is not the first one, we must skip nOutIndex-1 pins.
 if(nOutIndex>1)
 {
  hr = pEnumPins->Skip(nOutIndex-1);
  if(FAILED(hr))
  {
   pEnumPins->Release();
   return hr;
  }
 }
 //now we can get the output pin we wanted.
 hr = pEnumPins->Next(1,&pPinOutput,&cFetched);
 if(FAILED(hr))
 {
  pEnumPins->Release();
  return hr;
 }
 pEnumPins->Release();

 //enum input filter pins.
 hr = pInput->EnumPins(&pEnumPins);
 if(FAILED(hr))
 {
  pPinOutput->Release();
  return hr;
 }
 //if input pin is not the first to connect, we must skip nInIndex-1 pins.
 if(nInIndex>1)
 {
  hr = pEnumPins->Skip(nInIndex-1);
  if( FAILED(hr) )
  {
   pPinOutput->Release();
   pEnumPins->Release();
   return hr;
  }
 }
 //now we can get the input pin we wanted.
 hr = pEnumPins->Next(1,&pPinInput,&cFetched);
 if(FAILED(hr))
 {
  pPinOutput->Release();
  pEnumPins->Release();
  return hr;
 }
 pEnumPins->Release();

 //now connect from output pin to input pin.
 hr = pGraphBuilder->Connect(pPinOutput,pPinInput);
 pPinOutput->Release();
 pPinInput->Release();
 return hr;
}
IPin* xMyFindPin(IBaseFilter *pFilter, const WCHAR achName[])
{
 BOOL       bFound = FALSE;
 IEnumPins  *pEnum;
 IPin       *pPin;
 PIN_INFO pininfo;

 if(pFilter==NULL)
  return NULL;
 pFilter->EnumPins(&pEnum);
 while(pEnum->Next(1, &pPin, 0) == S_OK)
 {
  pPin->QueryPinInfo(&pininfo);
  pininfo.pFilter->Release();
  if (bFound = (0 == wcscmp(pininfo.achName,achName)))
   break;
  pPin->Release();
 }
 pEnum->Release();
 return (bFound ? pPin : 0); 
}
static const GUID  CLSID_NULL_USER1=
{0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

HRESULT GetUnconnectedPin( IBaseFilter *pFilter,
        PIN_DIRECTION PinDir,
        IPin **ppPin,GUID gMajortype,WCHAR *achName)
{
 *ppPin = 0;
 IEnumPins *pEnum = 0;
 IPin *pPin = 0;
 HRESULT hr = pFilter->EnumPins( &pEnum );
 if( FAILED( hr ) )
 {
  return hr;
 }
 while( pEnum->Next( 1, &pPin, NULL ) == S_OK )
 {
  PIN_DIRECTION ThisPinDir;
  pPin->QueryDirection( &ThisPinDir );
  if( ThisPinDir == PinDir )
  {
   IPin *pTmp = 0;
   hr = pPin->ConnectedTo( &pTmp );
   if( SUCCEEDED( hr ) )
   {
    pTmp->Release( );
   }
   else
   {    
    PIN_INFO pininfo;
    pPin->QueryPinInfo(&pininfo);
    pininfo.pFilter->Release();
    if(achName && (wcslen(achName)>= wcslen(pininfo.achName)))
     wcscpy(achName,pininfo.achName);

    if(gMajortype==CLSID_NULL_USER1)
    {
     pEnum->Release( );
     *ppPin = pPin;
     return S_OK;
    }
    else
    {
     IEnumMediaTypes* pTypeEnum;
     hr = pPin->EnumMediaTypes (&pTypeEnum);

     hr =pTypeEnum->Reset();
     AM_MEDIA_TYPE* pMediaType;
     ULONG            ul ;

     do
     {
      hr = pTypeEnum->Next(1, &pMediaType, &ul) ;
      if (FAILED(hr) || 0 == ul)
      {
       pTypeEnum->Release();
       //pEnum->Release( );
       if(pTmp)
        pTmp->Release();
       break ;
      }

      if (pMediaType->majortype == gMajortype)
      // ||       pMediaType->subtype == MEDIASUBTYPE_DVSD)
      { pTypeEnum->Release();
       pEnum->Release( );
       *ppPin = pPin;
       return S_OK;
      }
     }while (1) ;   

    }
   }
   if(pTmp)
    pTmp->Release();
  }
  pPin->Release( );
 }
 pEnum->Release( );

 return E_FAIL;
}

i_object_type; char *psz_object_type; char *psz_object_name; /** Just a reminder so that people don't cast garbage */ int

be_sure_to_add_VLC_COMMON_MEMBERS_to_struct; /**@}*/
　　#define VLC_OBJECT( x ) \
　　((vlc_object_t *)(x))+
　　0*(x)- be_sure_to_add_VLC_COMMON_MEMBERS_to_struct
　　struct vlc_object_t
　　{
　　 VLC_COMMON_MEMBERS
　　};//定义一个结构来使用宏定义的公共成员
　　4．定义导出函数
　　#ifndef __PLUGIN__
　　# define VLC_EXPORT( type, name, args ) type name args
　　#else
　　# define VLC_EXPORT( type, name, args ) struct _u_n_u_s_e_d_
　　 extern module_symbols_t* p_symbols;
　　#endif
　　5．定义回调函数
　　typedef int ( * vlc_callback_t ) ( vlc_object_t *, /* variable's object */
　　 char const *, /* variable name */
　　 vlc_value_t, /* old value */
　　 vlc_value_t, /* new value */
　　 void * ); /* callback data */
　　6．函数作为参数的定义方式
　　 Int Fun(int n,int (*pf)(int ,int),char *pstr)
　　{ int j =10;
　　pf(n,j);
　　}
　　7．回调函数的声明
　　必须声明为global，或者static
　　Int vlc_callback_t (int ,int)
　　{。。。。。。。。。。。}
　　
　　8．回调函数的使用
　　 Fun(0, vlc_callback_t,”test”);
　　9．函数表达式
　　#define input_BuffersInit(a) __input_BuffersInit(VLC_OBJECT(a))
　　void * __input_BuffersInit( vlc_object_t * );
　　#define module_Need(a,b,c,d) __module_Need(VLC_OBJECT(a),b,c,d)
　　VLC_EXPORT( module_t *, __module_Need, ( vlc_object_t *, const char *, const char *, vlc_bool_t ) );
　　10．定义函数
　　 /* Dynamic array handling: realloc array, move data, increment position */
　　#define INSERT_ELEM( p_ar, i_oldsize, i_pos, elem ) do { if( i_oldsize ) { (p_ar) = realloc( p_ar, ((i_oldsize) + 1) * sizeof( *(p_ar) )

); } else { (p_ar) = malloc( ((i_oldsize) + 1) * sizeof( *(p_ar) ) ); } if( (i_oldsize) - (i_pos) ) { memmove( (p_ar) + (i_pos) + 1, (p_ar) +

(i_pos), ((i_oldsize) - (i_pos)) * sizeof( *(p_ar) ) ); } (p_ar)[i_pos] = elem; (i_oldsize)++; } while( 0 )
　　应用为：
　　 INSERT_ELEM( p_new- p_libvlc- pp_objects,
　　 p_new- p_libvlc- i_objects,
　　 p_new- p_libvlc- i_objects,
　　 p_new );
　　11．改变地址的方式传递其值
　　stream_t *input_StreamNew( input_thread_t *p_input )
　　{ stream_t *s = vlc_object_create( p_input, sizeof( stream_t ) );
　　 input_stream_sys_t *p_sys;
　　 if( s )
　　 {
　　 s- p_sys = malloc( sizeof( input_stream_sys_t ) );
　　 p_sys = (input_stream_sys_t*)s- p_sys;
　　 p_sys- p_input = p_input;
　　 }
　　return s;//注解：s- p_sys改变了
　　}
　　 第二部分 程序框架实现
　　1．播放列表文件src/playlist/playlist.c的线程
　　playlist_t * __playlist_Create ( vlc_object_t *p_parent )函数中创建的线程，线程函数为
　　static void RunThread ( playlist_t *p_playlist )
　　 线程思路分析：
　　 在RunThread里面执行循环，如果没有任务执行，则适当的延迟，如果接到p_playlist- i_status != PLAYLIST_STOPPED的条件，则调用PlayItem(

p_playlist )函数，在PlayItem( p_playlist )函数中从新创建输入线程。
　　通过void playlist_Command( playlist_t * p_playlist, playlist_command_t i_command,int i_arg )接收来自GUI界面的各种命令，然后设置p_playlist-

i_status的状态，由该状态改变该播放列表文件主循环线程的执行。
　　2．输入文件SRC/INPUT/INPUT.C的输入线程
　　 input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
　　 input_item_t *p_item )函数中创建的线程，线程函数为
　　static int RunThread( input_thread_t *p_input )
　　 线程思路分析：
　　由 input_thread_t结构的成员分析是接收文件流还是网络流，如果是文件流，则调用file module 的读函数(pf_read)和打开函数(--).如果是network 则打

开network module 的打开函数和读函数（pf_read)。
　　 在 RunThread线程函数中接收数据和调用demux 或者decode etc处理。
　　一旦产生新的输入，则在播放列表线程中会首先结束该输入线程，然后从新创建新的输入线程。
　　3．视频输出文件src/video_output/ video_output.c的线程
　　vout_thread_t * __vout_Create( vlc_object_t *p_parent,
　　 unsigned int i_width, unsigned int i_height,
　　 vlc_fourcc_t i_chroma, unsigned int i_aspect )函数中创建的线程，线程函数为
　　static void RunThread( vout_thread_t *p_vout)
　　线程思路分析：
　　 在RunThread里面执行循环，任务是显示视频。
　　4．在modules\gui\wxwindows\wxwindows.cpp中的GUI线程
　　static void Run( intf_thread_t *p_intf ) 函数中创建的线程，线程函数为
　　 static void Init( intf_thread_t *p_intf )
　　线程思路分析：
　　 在Init( intf_thread_t *p_intf )里面执行循环，创建新的GUI实例。Instance-》OnInit()（CreateDialogsProvider）-》DialogsProvider为运行的对话

框。
　　 接收网络文件的步骤
　　OnOpenNet( wxCommandEvent& event )打开网络文件的步骤。打开OpenDialog对话框，点击Ok后调用OpenDialog::OnOk( wxCommandEvent& WXUNUSED(event)

)函数，调用playlist_Command函数改变播放列表线程的状态。
　　 激活线程分析：
　　 在wxwindow.cpp中的消息映射中 set_callbacks( OpenDialogs, Close ); 则设置了module_t- pf_activate= OpenDialogs函数，
　　 在module.c 的__module_Need( vlc_object_t *p_this, const char *psz_capability,
　　 const char *psz_name, vlc_bool_t b_strict )
　　函数中用到了pf_activate激活GUI对话框；
　　 在video_output.c 的static void RunThread( vout_thread_t *p_vout)线程中，也用到了pf_activate激活GUI对话框；
　　5．开始所有module 的精髓
　　 消息映射宏
　　 vlc_module_begin();
　　 set_callbacks( NetOpen, NULL );
　　vlc_module_end();
　　然后设置模块结构的成员函数为：
　　#define set_callbacks( activate, deactivate ) p_submodule- pf_activate = activate; p_submodule- pf_deactivate = deactivate
　　在__module_Need函数中启动pf_activate 激活相应的module。

网络数据流接收处理分析
　　1、在input.c(src\input)文件中的主线程循环
　　 Thread in charge of processing the network packets and demultiplexing
　　RunThread( input_thread_t *p_input )
　　{
　　 InitThread( p_input ) ；
　　…………………………………………………….
　　 input_SelectES( p_input, p_input->stream.p_newly_selected_es );
　　 …………………………………………………….
　　 /* Read and demultiplex some data. */
　　 i_count = p_input->pf_demux( p_input );
　　}
　　2、在下列函数中：
　　分离出access , demux , name字符串 ;
　　根据分离出的access 字符串通过module_Need函数找到acess 指针模块；
　　根据分离出的demux 字符串通过module_Need函数找到demux 指针模块；
　　static int InitThread( input_thread_t * p_input )
　　{
　　 msg_Dbg( p_input, "access `%s', demux `%s', name `%s'",
　　 p_input->psz_access, p_input->psz_demux, p_input->psz_name );
　　 /* Find and open appropriate access module */
　　 p_input->p_access = module_Need( p_input, "access",
　　 p_input->psz_access, VLC_TRUE );
　　…………………………………………………….
　　 while( !input_FillBuffer( p_input ) )
　　 …………………………………………………….
　　 /* Find and open appropriate demux module */
　　 p_input->p_demux =
　　 module_Need( p_input, "demux",
　　 (p_input->psz_demux && *p_input->psz_demux) ?
　　 p_input->psz_demux : "$demux",
　　 (p_input->psz_demux && *p_input->psz_demux) ?
　　 VLC_TRUE : VLC_FALSE );
　　…………………………………………………….
　　}
　　3、在ps.c (module\demux\mpeg)文件中
　　a.通过消息映射宏赋值启动函数Activate；
　　b.通过函数Activate赋值p_input->pf_demux = Demux;
　　c. 通过函数module_Need( p_input, "mpeg-system", NULL, 0 ) 激活p_input->p_demux_data->mpeg.pf_read_ps( p_input, &p_data )函数（pf_read_ps）

;
　　d.在InitThread函数中激活；
　　 static int Activate( vlc_object_t * p_this )
　　{
　　 /* Set the demux function */
　　p_input->pf_demux = Demux;
　　p_input->p_private = (void*)&p_demux->mpeg;
　　 p_demux->p_module = module_Need( p_input, "mpeg-system", NULL, 0 );
　　}
　　4、在system.c (module\demux\mpeg)文件中
　　 赋值解码模块mpeg_demux_t的成员函数；
　　 static int Activate ( vlc_object_t *p_this )
　　{
　　 static mpeg_demux_t mpeg_demux =
　　 { NULL, ReadPS, ParsePS, DemuxPS, ReadTS, DemuxTS };
　　 mpeg_demux.cur_scr_time = -1;
　　 memcpy( p_this->p_private, &mpeg_demux, sizeof( mpeg_demux ) );
　　 return VLC_SUCCESS;
　　}
　　并且申明函数static ssize_t ReadPS( input_thread_t * p_input, data_packet_t ** pp_data )；
　　5、在ps.c (module\demux\mpeg)文件中
　　Demux( input_thread_t * p_input )
　　{
　　i_result = p_input->p_demux_data->mpeg.pf_read_ps( p_input, &p_data );
　　 p_input->p_demux_data->mpeg.pf_demux_ps( p_input, p_data );
　　}
　　进行读取数据和分离工作；
　　6、在system.c (module\demux\mpeg)文件中
　　数据走向图如下
　　ReadPS-> PEEK-> input_Peek(src\input\input_ext-plugins.c)-> input_FillBuffert 通过 i_ret = p_input->pf_read( p_input,
　　 (byte_t *)p_buf + sizeof(data_buffer_t)
　　 + i_remains,
　　 p_input->i_bufsize );
　　input_thread_t结构的pf_read函数成员如果是为udp.c(modules\access)的RTPChoose函数
　　则在开启access（UDP 模块）时通过module_need 激活；
　　激活网络读数据模块 RTPChoose（modules\access\ udp.c)->Read->net_Read(src\misc\net.c)；
　　7、在input_programs.c(src\input)文件中
　　 运行解码器对ES流解码
　　 int input_SelectES( input_thread_t * p_input, es_descriptor_t * p_es )
　　{
　　 p_es->p_dec = input_RunDecoder( p_input, p_es );
　　
　　}
　　input_SelectES（src\input\input_programs.c）->input_RunDecoder（src \input\input_dec.c）->DecoderThread->DecoderDecode -

>vout_DisplayPicture

从接收到数据流到播放视频的过程分析

   从网络接收到流->对数据流进行视频和音频分离->对视频用解码器解码->显示解码后的视频流

    视频显示部分走势线：分离->解码->新的VOUT缓冲区->VOUT线程

Demux(modules\demux\mpeg\ps.c)->DemuxPs(modules\demux\mpeg\system.c)-> ParsePS->input_SelectES(src\input\input_programs.c)->input_RunDecoder

(src\input\input_dec.c)->CreateDecoder->

vout_new_buffer->vout_Request(src\video_output\video_output.c)->vout_Create->RunThread->vout_RenderPicture(src\video_output\vout_pictures.c)-

>pf_display

注意：p_dec->pf_vout_buffer_new = vout_new_buffer的pf_vout_buffer_new在ffmpeg_NewPictBuf（modules\codec\ffmpeg\video.c）函数中激活

   解码部分走势线：

Demux(modules\demux\mpeg\ps.c)->DemuxPs(modules\demux\mpeg\system.c)-> ParsePS->input_SelectES(src\input\input_programs.c)->input_RunDecoder

(src\input\input_dec.c)->CreateDecoder->

DecoderThread

  注意：在解码线程中对数据流（AUDIO 或者VIDEO）进行解码

详细资料 http://developers.videolan.org/vlc/    VLC API documentation  或者VLC developer documentation

 
Chapter 5.  The video output layer
Data structures and main loop

Important data structures are defined in include/video.h and include/video_output.h. The main data structure is picture_t, which describes

everything a video decoder thread needs. Please refer to this file for more information. Typically, p_data will be a pointer to YUV planar

picture.

Note also the subpicture_t structure. In fact the VLC SPU decoder only parses the SPU header, and converts the SPU graphical data to an

internal format which can be rendered much faster. So a part of the "real" SPU decoder lies in src/video_output/video_spu.c.

The vout_thread_t structure is much more complex, but you needn't understand everything. Basically the video output thread manages a heap of

pictures and subpictures (5 by default). Every picture has a status (displayed, destroyed, empty...) and eventually a presentation time. The

main job of the video output is an infinite loop to : [this is subject to change in the near future]

   1.

      Find the next picture to display in the heap.
   2.

      Find the current subpicture to display.
   3.

      Render the picture (if the video output plug-in doesn't support YUV overlay). Rendering will call an optimized YUV plug-in, which will

also do the scaling, add subtitles and an optional picture information field.
   4.

      Sleep until the specified date.
   5.

      Display the picture (plug-in function). For outputs which display RGB data, it is often accomplished with a buffer switching. p_vout-

>p_buffer is an array of two buffers where the YUV transform takes place, and p_vout->i_buffer_index indicates the currently displayed buffer.
   6.

      Manage events.

Methods used by video decoders

The video output exports a bunch of functions so that decoders can send their decoded data. The most important function is vout_CreatePicture

which allocates the picture buffer to the size indicated by the video decoder. It then just needs to feed (void *) p_picture->p_data with the

decoded data, and call vout_DisplayPicture and vout_DatePicture upon necessary.

    *

      picture_t * vout_CreatePicture ( vout_thread_t *p_vout, int i_type, int i_width, int i_height ) : Returns an allocated picture buffer.

i_type will be for instance YUV_420_PICTURE, and i_width and i_height are in pixels.
      Warning

      If no picture is available in the heap, vout_CreatePicture will return NULL.
    *

      vout_LinkPicture ( vout_thread_t *p_vout, picture_t *p_pic ) : Increases the refcount of the picture, so that it doesn't get accidently

freed while the decoder still needs it. For instance, an I or P picture can still be needed after displaying to decode interleaved B pictures.
    *

      vout_UnlinkPicture ( vout_thread_t *p_vout, picture_t *p_pic ) : Decreases the refcount of the picture. An unlink must be done for every

link previously made.
    *

      vout_DatePicture ( vout_thread_t *p_vout, picture_t *p_pic ) : Gives the picture a presentation date. You can start working on a picture

before knowing precisely at what time it will be displayed. For instance to date an I or P picture, you must wait until you have decoded all

previous B pictures (which are indeed placed after - decoding order != presentation order).
    *

      vout_DisplayPicture ( vout_thread_t *p_vout, picture_t *p_pic ) : Tells the video output that a picture has been completely decoded and

is ready to be rendered. It can be called before or after vout_DatePicture.
    *

      vout_DestroyPicture ( vout_thread_t *p_vout, picture_t *p_pic ) : Marks the picture as empty (useful in case of a stream parsing error).
    *

      subpicture_t * vout_CreateSubPicture ( vout_thread_t *p_vout, int i_channel, int i_type ) : Returns an allocated subpicture buffer.

i_channel is the ID of the subpicture channel, i_type is DVD_SUBPICTURE or TEXT_SUBPICTURE, i_size is the length in bytes of the packet.
    *

      vout_DisplaySubPicture ( vout_thread_t *p_vout, subpicture_t *p_subpic ) : Tells the video output that a subpicture has been completely

decoded. It obsoletes the previous subpicture.
    *

      vout_DestroySubPicture ( vout_thread_t *p_vout, subpicture_t *p_subpic ) : Marks the subpicture as empty.

VLC（五） 视频播放的基本原理

    当初Roger看VLC代码花了不少时间，其中很大的原因是不太了解视频播放的基本原理。现在看来，几乎所有的视频播放器，如VLC、MPlayer、 Xine，包括

DirectShow，在播放视频的原理和架构上都是非常相似的，理解这个对理解VLC的源码会有事半功倍的效果。

    大致的来说，播放一个视频分为4个步骤：

    1.  acess 访问，或者理解为接收、获取、得到

    2. demux 解复用，就是把通常合在一起的音频和视频分离(还有可能的字幕)  

    3. decode 解码，包括音频和视频的解码

    4. output 输出，也分为音频和视频的输出（aout和vout）

    拿播放一个UDP组播的MPEG TS流来说吧，access部分负责从网络接收组播流，放到VLC的内存缓冲区中，access模块关注IP协议，如是否IPv6、组播地址、组

播协议、端口等信息；如果检测出来是RTP协议（RTP协议在UDP头部简单得加上了固定12个字节的信息），还要分析RTP头部信息。这部分可以参看VLC源码

/modules/access/udp.c 。在同目录下还可以看到大量的access模块，如file、http、dvd、ftp、smb、tcp、dshow、mms、v4l…等等

    而demux部分首先要解析TS流的信息。TS格式是MPEG2协议的一部分，概括地说，TS通常是固定188字节的一个packet，一个TS流可以包含多个program（节目）

，一个program又可以包含多个视频、音频、和文字信息的ES流；每个ES流会有不同的PID标示。而又为了可以分析这些ES流，TS有一些固定的PID用来间隔发送

program和es流信息的表格：PAT和PMT表。关于TS格式的详细信息可以去google一下。

    VLC专门做了一个独立的库libdvbpsi来解析和编码TS流，而调用它的代码可以参见VLC源码 /modules/demux/ts.c。

    其实之所以需要demux，是因为音视频在制作的时候实际上都是独立编码的，得到的是分开的数据，为了传输方便必须要用某种方式合起来，这就有了各种封

装格式也就有了demux。

    demux分解出来的音频和视频流分别送往音频解码器和视频解码器。因为原始的音视频都是占用大量空间，而且冗余度较高的数据，通常在制作的时候就会进

行某种压缩。这就是我们熟知的音视频编码格式，包括MPEG1（VCD）、MPEG2（DVD）、MPEG4、H.264、rmvb等等。音视频解码器的作用就是把这些压缩了的数据还

原成原始的音视频数据。VLC解码MPEG2使用了一个独立的库libmpeg2，调用它的源文件是 /modules/codec/libmpeg2.c。VLC关于编解码的模块都放

在/modules/codec目录下，其中包括著名的庞大的 ffmpeg。

    解码器，例如视频解码器输出的是一张一张的类似位图格式的图像，但是要让人从屏幕看得到，还需要一个视频输出的模块。当然可以像一个Win32窗口程序

那样直接把图像画到窗口DC上——VLC的一个输出模块WinGDI就是这么干的，但是通常这太慢了，而且消耗大量的CPU。在Windows下比较好的办法是用DirectX的接

口，会自动调用显卡的加速功能。

    这样的功能分解使得模块化更容易一点，每个模块住需要专注于自己的事；从整体来说功能强大而且灵活。

    但是事情总是不会那么简单。就拿access来说，媒体的访问是分层的，如RTSP就涉及到IPv4、TCP、UDP、RTCP、RTSP等多个层次的协议。有些视频格式包括了

传输、封装格式和编辑码格式如MPEG系列，有些封装格式是独立的容器，但是很多人会误解它是编解码格式，如mkv、avi这些。

    音频和视频在demux之后就是独立的，但是需要有一套机制把它们同步起来。同时我们需要有一套机制来控制速度、暂停、停止、跳进，获取各种媒体信息，

这些都是很复杂而又很重要的事情。

    另外也许需要在某个地方插入一些修改，来实现某种效果。如音频的EQ，视频的亮度调整之类的，VLC专门设计了access_filter、audio_filter和

video_filter类型的模块来做这一类事情。

    VLC比较独特的地方是集成了原来的VLS的功能，这依赖于VLC中stream_output类型的模块，它们可以把正在播放的视频以某种方式重新转码和发送出去，如

http、UDP、文件等等。

    MPlayer的结构与此是类似的，如/stream目录对应的是access的功能，/mpdemux对应的demux功能，/libmpcodecs是解码器，/libvo和/libao2分别是视频和音

频的输出。

    DirectShow也是类似的，不过分类更多一些更复杂一点。DirectShow里面的模块叫做“filter”，filter之间通过”pin”来连接。access的模块对应于

DirectShow中的Source FIlter，这一类Filter只有输出pin没有输入pin。demux模块对应于splitter filter，这种filter有一个输入pin，多个输出pin。解码模

块是一类transform filter，有一个输入pin、一个输出pin，输出模块对应于readering filter，有一个输入pin，没有输出pin。当然transform filter不一定是

解码器，也可能是某种其他的处理。

    回到VLC的话题。每一类的模块数量都很多，那么在打开某一个视频时，VLC如何决定采用哪一个呢？哈哈，这个以后再说 ^_^

    另外给出一个VLC的API Document，有点老了不过挺值得一看的，在VLC wiki上找不到了，就贴出来：http://rogerfd.cn/doc/vlcapi.htm

————————————————————————

作者： roger

Blog： http://rogerfd.cn

Email：roger99707@163.com

本文欢迎转载和引用，请保留本说明并注明出处

channels, digital terrestial television channels and live videos on the network in unicast or

multicast.
　　1.VLC 在REDHAT 下的安装
　　从下面的链接中下载 vlc的包和包所需要的库,把他们都放在同一个目录.
　　http://www.videolan.org/vlc/download-redhat.html
　　
　　 源代码安装:
　　 源代码安装需要的库如下:
　　 libdvbpsi (compulsory) ,
　　 mpeg2dec (compulsory) ,
　　 libdvdcss if you want to be able to read encrypted DVDs ,
　　 libdvdplay if you want to have DVD menu navigation ,
　　 a52dec if you want to be able to decode the AC3 (i.e. A52) sound format often used in

DVDs ,
　　 ffmpeg, libmad, faad2 if you want to read MPEG 4 / DivX files ,
　　 libogg & libvorbis if you want to read Ogg Vorbis files .
　　2.VLC在命令行下接收流
　　Receive an unicast stream
　　% vlc -vvv udp:
　　Receive a multicast stream
　　% vlc -vvv udp:@239.255.12.42
　　where 239.255.12.42 is the multicast IP address you want to join.
　　Receive an HTTP/FTP/MMS stream
　　Use one of the following command lines:
　　% vlc -vvv http://example/stream.xyz
　　where http://example/stream.xyz is the HTTP address of the stream;
　　% vlc -vvv ftp://example/stream.xyz
　　where ftp://example/stream.xyz is the FTP address of the stream;
　　% vlc -vvv ms://viptvr.yacast.fr/encoderfranceinfo
　　where mms://viptvr.yacast.fr/encoderfranceinfo is the MMS address of the stream.
　　Receive a RTP stream available through RTSP
　　% vlc -vvv rtsp://www.hardradio.com/tonbeme.mov
　　where rtsp://www.hardradio.com/tonbeme.mov is the address of the stream.
　　Receive a stream described by an SDP file
　　% vlc -vvv http://server.example.org/stream.sdp
　　3.VLC在命令行下发送流
　　% vlc -vvv video1.xyz --sout udp:192.168.0.42 --ttl 12
　　where:
　　 *video1.xyz is the file you want to stream,
　　 *192.168.0.42 is either:
　　 o the IP address of the machine you want to unicast to;
　　 o or the DNS name the machine you want to unicast to;
　　 o or a multicast IP address.
　　 *12 is the value of the TTL (Time To Live) of your IP packets (which means that the

stream will be able to cross 11 routers).
　　If you want to stream the file continuously, add the --loop option.
　　4.VLC 高级应用(VLC's stream output (transcoding, multiple streaming, etc...))
　　 语法: Please refer to the" command line interface" chapter of the "VLC user guide "to

learn the syntax of VLC's stream output.
　　 例子:
　　 ----编码方面的例子
　　Transcode the input stream and send it to a multicast IP address with the associated SAP

announce:
　　% vlc -vvv input_stream --sout '#transcode

{vcodec=mp4v,acodec=mpga,vb=800,ab=128,deinterlace}:
　　standard{access=udp,mux=ts,url=239.255.12.42,sap,name="TestStream"}'
　　Display the input stream, transcode it and send it to a multicast IP address with the

associated SAP announce:
　　% vlc -vvv input_stream --sout '#duplicate{dst=display,dst=
　　"transcode{vcodec=mp4v,acodec=mpga,vb=800,ab=128,deinterlace}:
　　standard{access=udp,mux=ts,url=239.255.12.42,sap,name="TestStream"}"}'
　　Transcode the input stream, display the transcoded stream and send it to a multicast IP

address with the associated SAP announce:
　　% vlc -vvv input_stream --sout '#transcode

{vcodec=mp4v,acodec=mpga,vb=800,ab=128,deinterlace}:
　　duplicate{dst=display,dst=standard

{access=udp,mux=ts,url=239.255.12.42,sap,name="TestStream"}}'
　　--多种流的例子
　　Send a stream to a multicast IP address and a unicast IP address:
　　% vlc -vvv input_stream --sout '#duplicate{dst=
　　standard{access=udp,mux=ts,url=239.255.12.42,sap,name="TestStream"},
　　dst=standard{access=udp,mux=ts,url=192.168.1.2}}'
　　Display the stream and send it to two unicast IP addresses:
　　% vlc -vvv input_stream --sout '#duplicate{dst=display,dst=
　　standard{access=udp,mux=ts,url=192.168.1.12},
　　dst=standard{access=udp,mux=ts,url=192.168.1.42}}'
　　Send parts of a multiple program input stream:
　　% vlc -vvv multiple_program_input_stream
　　--sout '#duplicate{dst=standard

{access=udp,mux=ts,url=239.255.12.42},select="program=12345",
　　dst=standard{access=udp,mux=ts,url=239.255.12.43}, select="video,program=1234-2345"}'
　　This command sends the program of the input stream which id is 12345 to 239.255.12.42 and

all video programs with id between 1234 and 2345 to 239.255.12.43.
　　Transcoding and multiple streaming
　　Transcode the input stream, display the transcoded stream and send it to a multicast IP

address with the associated SAP announce and an unicast IP address:
　　% vlc -vvv input_stream --sout '#transcode

{vcodec=mp4v,acodec=mpga,vb=800,ab=128,deinterlace}:
　　duplicate{dst=display,dst=standard

{access=udp,mux=ts,url=239.255.12.42,sap,name="TestStream"},
　　dst=standard{access=udp,mux=ts,url=192.168.1.2}}'
　　Display the input stream, transcode it and send it to two unicast IP addresses:
　　% vlc -vvv input_stream --sout '#duplicate{dst=display,
　　dst="transcode{vcodec=mp4v,acodec=mpga,vb=800,ab=128}:
　　duplicate{dst=standard{access=udp,mux=ts,url=192.168.1.2},
　　dst=standard{access=udp,mux=ts,url=192.168.1.12}"}'
　　Send the input stream to a multicast IP address and the transcoded stream to another

multicast IP address with the associated SAP announces:
　　% vlc -vvv input_stream --sout '#duplicate{dst=
　　standard{access=udp,mux=ts,url=239.255.1.2,sap,name="OriginalStream"},
　　dst="transcode{vcodec=mp4v,acodec=mpga,vb=800,ab=128}:
　　standard{access=udp,mux=ts,url=239.255.1.3,sap,name="TranscodedStream"}"}'
 
此文章为转载，原文出处为，http://www.wangchao.net.cn/bbsdetail_58052.html

 
.1.在RH9上的安装需要
　　 1).RH9的升级包.
　　 2).FC2的RPM包
　　 详细说明清参见:http://www.videolan.org/vlc/download-redhat.html
　　 以上VLC 版本为:0.7.2
　　2.下载RH9的升级包
　　 http://download.videolan.org/pub/videolan/vlc/0.7.2/rpm/redhat/rh9/
　　3.下载FC2的RPM包
　　 http://download.videolan.org/pub/videolan/vlc/0.7.2/rpm/fedora/fc2/
　　 二进制包为: vlc-binary.tar.gz
　　4.将RH9的升级包和 vlc-binary.tar.gz放在同一个目录.
　　 ~#tar -zxvf vlc-binary.tar.gz
　　 ~#tar -zxvf redhat9-updates.tar.gz
　　5.安装
　　 ~#rpm -Uv vlc/* --force --nodeps
　　6.使用
　　 1) 在REDHAT->AUDIO AND VIDEO->VLAN MEDIA PLAYER 可以打开
　　 2)或者在BASH 中打开vlc,使用命令行选项直接启动,参见videolan-how-to-en.
　　7.未测试出的功能
　　 在局域网内的同一网段内的两台PC上不能用MULTICAST 进行VIDEO
　　 传输.

一．rm格式的播放器：
　　下载地址：http://www.real.com/linux/?src=020923home_cn_cn
　　安装方式：~#./realplayer.bin
　　 打开方式：
　　命令行：~#realplay
　　 ＧＵＩ：redhat->audio and video->other app->realplayer
　　二．mp3 播放器：xmms-1.2.8.tar.gz
　　 安装方式：./configure & make &make install
　　三． 经验:从源码编译安装Mplayer 1.0pre5
　　来自：http://yangchengkai.blogchina.com/blog/refer.177855.html
　　Mplayer/gmplayer是目前Linux下广范使用的媒体播放器,一个字--强!但由于它一般以Tarball的格式

发布,安装比较BT,许多朋友都在找rpm的版本,但来源不同的rpm版本往往无法自己定制许多特性,比如中文

支持等,而且容易造成rpm包的依赖问题,所以有不少朋友最终对 Mplayer又爱又恨...-_-!!
　　其实自己编译mplayer并不是什么太难的事,只是过程比较麻烦,但基本还是遵循tarball的安装步骤,有

关这个的文章Sir里已经有了不少,自己这篇就不打算往Sir里贴了,且留在这里和大家分享...:)
　　首先是下载最新的mplayer的tarball,即1.0pre5:
　　http://www4.mplayerhq.hu/homepage/design7/dload.html
　　接下来是下载解码器包,一般只要下载Essential Codes就足够了,要放rmvb需要reallib的解码器,我一

般用xine放rmvb:
　　http://www4.mplayerhq.hu/homepage/design7/codecs.html
　　还有mplayer的字体文件:
　　http://www4.mplayerhq.hu/homepage/design7/dload.html
　　这里大家不用到"其他字体"里下载中文字体,待会可以用simsun.ttf替代.
　　当然,还要下载Skin文件给gmplayer用:
　　http://ftp5.mplayerhq.hu/mplayer/Skin/
　　建议用default blue或者neutron,当然,你也可以下载其他的Skin.
　　我们先把下载的所有文件cp到/opt/目录下,然后开始具体安装步骤.
　　1.首先安装解码器:
　　tar -jxvf essential-20040916.tar.bz2
　　tar -jxvf rp9codecs-20040626.tar.bz2
　　cp -rf rp9codecs-20040626/* essential-20040916/
　　mv essential-20040916 /usr/lib/codes
　　以上命令把解码器包安装到了/usr/lib/codes,其实就是把解压后的目录ren&mv了过去.
　　2.编译安装mplayer:
　　tar -jxvf MPlayer-1.0pre5.tar.bz2
　　cd MPlayer-1.0pre5
　　./configure --enable-gui --with-codecsdir=/usr/lib/codecs --with-

win32libdir=/usr/lib/codecs --with-reallibdir=/usr/lib/codecs --language=zh_CN
　　以上几个参数解释一下:
　　--enable-gui:打开图形界面支持,就是gmplayer
　　--with-codecsdir=/usr/lib/codecs:指明解码器的目录
　　--with-win32libdir=/usr/lib/codecs:指明windows的媒体文件解码器目录位置
　　--with-reallibdir=/usr/lib/codecs:指明real媒体文件的解码器目录位置,要用gmplayer放rmvb必须

指定这条.
　　--language=zh_CN:设定系统界面语言为中文
　　在configure之前可以运行./configure --help查看支持的特性设定,可以根据自己需求选择,以上只是

最基本的啦.
　　make
　　make install
　　3.安装字体文件:
　　tar -jxvf font-arial-iso-8859-1.tar.bz2
　　mv font-arial-iso-8859-1/ /usr/local/share/mplayer/font/
　　cd /usr/local/share/mplayer/font/
　　如果你的系统用simsun美化过,则直接
　　ln -s ***/simsun.ttf subfont.ttf
　　注意,这里的***是指simsun的具体位置,为了保险起见,建议在~/.mplayer/里也做同样的链接.
　　要是系统没有美化过,试试
　　ln -s /usr/share/fonts/zh_CN/TrueType/gbsn001p.ttf subfont.ttf
　　这样中文字幕就搞定了.
　　4.安装Skin:
　　超级简单,把skin包解压后mv到/usr/local/share/mplayer/Skin就可以了,注意一定要有一个skin叫做

default,不然gmplayer无法运行.
　　OK,目前为止所有工作结束,运行gmplayer/mplayer看看,Enjoy it!:)
　　PS:要是你用xine,在setup里可以把codes的目录指定同mplayer一样,这样可以节省点空间^_^
　　５.nvidia driver 驱动安装：

结果在windows任务管理器里面，直接杀进程都杀不死，

这个程序大致运作如下： 因为一台机器上有多个网卡， 比如一快网卡联内网，另一快网卡联外网，所有，输出数据的时候必需绑定某个网卡的ip，网线松了，ip没有了，程序就死机了， 请大家帮我，

结果我用下列的例子，也没有成功。

哥伦布编码的解析过程

golomb 编码主要是针对整数进行编码，减少整数使用的空间位数
在golomb编码时，有一个可以变化的参数m

本人的算法如下，很简便的！
 

int My_get_se_golomb_31()

{

     int b = 0;

     int nValue = 0;

     b = My_get_ue_golomb_31();

     nValue = b / 2;

     if (b > 1 && b%2 ==0)

     {

         nValue = nValue * (-1);

     }

     return nValue;

}

int  My_get_ue_golomb_31()

{

     int b = 0;

     int i = 0;

     do

     {

         i ++;

         if (i <32)

              b = Bitstream_get(i,FALSE);

         else

         {

              outlog("SPS: nreserved should is zero.");

              break;

         }       

     } while(!b);

     Bitstream_get(i);

     b = (1 <<(i - 1)) -1 + Bitstream_get(i-1);    

     return b;

}

http://ludajun.blog.sohu.com/

 例如：取m = 1, 对整数x = ４进行编码, 算法如下
b = 2的ｍ次方
q = int((x-1)/ b)
r = x - qb - 1

由此计算出 q = 1, r = 1
二进制编码为q 个　１，　１　个０，　然后是r的二进制编码
所以编码为：101

解码思路：
先算出所给整数的位数n
然后从高位--〉低位找到第一个０所在的位置i，这样就能 q = n - i, r = ｘ的第０位到第ｉ－１位所表示的数字（由低位－－〉高位）
最终解码结果为qb + 1 + r

python 实现的　算法：
from math import log

m = 1

def compress(x):
    q = (x - 1) >> m
    r = x - (q << m) - 1
    result = ((((1 << q) - 1) << 1) << m) | r
    return result

def uncompress(x):
    if x == 0:
        return 1
    #计算x的位数
    n = int(log(x, 2))
    if n == 0:
        return x + 1
    for i in range(n, -1, -1):
        if (x & (1 << i)) == 0:
            q = n - i
            r = x & (1 << i - 1)
            return r + 1 + (q << m)

其中的Mpeg-1处理的是标准图像交换格式（standard interchange format,SIF）或者称为源输入格式（Source Input Format,SIF）的电视，将模拟的图像信息，通过编码成为数字图像信息，原始输入可以是NTSC制式352pixels * 240lines * 30frames/second, PAL制352pixels * 288lines*25frames/second，压缩后的数字图像信息的速率为1.5Mb/s.这个标注是1992年正是的发布的，是针对当时具有这种数据传输速率的CD-ROM和网络而开发的，用于在CD-ROM上存储数字影视和在网络上传输数字影视。
MPEG-1的标准号为ISO/IEC 11172,标准名：“信息技术——用于数据速率大约高达1.5Mb/s的数字存储替的电视图像和伴音编码”
本文主要是对Mpeg-1Video数据流的结构进行分析，并将怎样得到Mpeg-1流中的数据部分进行的阐述。ISO/IEC 11172-2

2．Mpeg-1数据流分析
编码后的视频序列是一个如同计算机网络的OSI模型下的数据序列一样，数据被分成很多层的概念。

视频序列层－画面组层－画面层－片层－宏块层－块层
层次的关系很明显，越往后越是底层，越接近实际的数据。

2.1视频序列层（VideoStream）
视频序列是以一个序列标题开始，之后可以跟着一个或者多个画面组。最后以Sequence_end_code结束。紧挨着每一个画面组之前可以有一个序列标题。也就是说每个画面组，都可以有一个自己的序列标题。
序列标题是一个以sequence_header_code开始，后跟着一系列数据元素的结构。是视频流中用来解码的重要的参数之一。其中定义了量化矩阵（load_intra_quantizer_matrix和 load_non_intra_quantizer_matrix以及可选的intra_quantizer_matrix和non_intra_quantizer_ matrix）以及其它的一些重要的数据元素，其中量化矩阵是可以在视频流中重复的量化矩阵中变化的，并且在每次变化后，量化矩阵重新定义。其它的元素必须与第一个序列标题中的值相同。
整个视频序列的结构可以用下面的代码表示：
Video_Stream{
unsigned int h_size;                         /* Horiz. size in pixels.     */
  unsigned int v_size;                         /* Vert. size in pixels.      */
  unsigned int mb_height;                      /* Vert. size in mblocks.     */
  unsigned int mb_width;                       /* Horiz. size in mblocks.    */
  unsigned char aspect_ratio;                  /* Code for aspect ratio.     */
  unsigned char picture_rate;                  /* Code for picture rate.     */
  unsigned int bit_rate;                       /* Bit rate.                  */
  unsigned int vbv_buffer_size;                /* Minimum buffer size.       */
  BOOLEAN const_param_flag;                    /* Contrained parameter flag. */
  unsigned char intra_quant_matrix[8][8];      /* Quantization matrix for
  intracoded frames.         */
  unsigned char non_intra_quant_matrix[8][8];  /* Quanitization matrix for
  non intracoded frames.     */
  char *ext_data;                              /* Extension data.            */
  char *user_data;                             /* User data.                 */
  GoP group;                                   /* Current group of pict.     */
  Pict picture;                                /* Current picture.           */
  Slice slice;                                 /* Current slice.             */
  Macroblock mblock;                           /* Current macroblock.        */
  Block block;                                 /* Current block.             */
  int state;                                   /* State of decoding.         */
  int bit_offset;                              /* Bit offset in stream.      */
  unsigned int *buffer;                        /* Pointer to next byte in
  buffer.                    */
  int buf_length;                              /* Length of remaining buffer.*/
  unsigned int *buf_start;                     /* Pointer to buffer start.   */
  int max_buf_length;                          /* Max lenght of buffer.      */
  PictImage *past;                             /* Past predictive frame.     */
  PictImage *future;                           /* Future predictive frame.   */
  PictImage *current;                          /* Current frame.             */
  PictImage *ring[RING_BUF_SIZE];              /* Ring buffer of frames.     */
} Video_Stream;  
具体的序列标题的结构的部分是这样的：
序列
sequence_header{
SEQ_START_CODE 0x000001b3;  /* 常量 ,作用使用来定位视频序列的序列头 */  
unsigned int h_size;                         /* Horiz. size in pixels.     */
  unsigned int v_size;                         /* Vert. size in pixels.      */
  unsigned int mb_height;                      /* Vert. size in mblocks.     */
  unsigned int mb_width;                       /* Horiz. size in mblocks.    */
  unsigned char aspect_ratio;                  /* Code for aspect ratio.     */
  unsigned char picture_rate;                  /* Code for picture rate.     */
  unsigned int bit_rate;                       /* Bit rate.                  */
  unsigned int vbv_buffer_size;                /* Minimum buffer size.       */
  BOOLEAN const_param_flag;                    /* Contrained parameter flag. */
  unsigned char load_intra_quantizer_matrix;
unsigned char intra_quant_matrix[8][8];      /* Quantization matrix for intracoded frames.         这个结构是可选的，要看load_intra_quantizer_matrix的值，为真则有这个部分，否则没有，因为
intra_quant_matrix是量化表的值，而Sequence_header结构在视频序列中是可重复的，即在每个画面组之前都有可能再次给出一个sequence_header,并且可以在新的sequence_header 中重新定义量化表*/
unsigned char load_non_intra_quantizer_matrix;
  unsigned char non_intra_quant_matrix[8][8];  /* Quanitization matrix for non intracoded frames. 也是可选。愿意于intra_quant_matrix可选的原因相同。当load_non_intra_quant_matrix的值为真的时候需要定义。    */
  char *ext_data;                              /* Extension data.            */
  char *user_data;                             /* User data.                 */
 
}

由上面的分析，可以看出来的是：
video_sequence(){
next_start_code()
do{
sequence_header();
do{
group_of_pictures() ;画面组
}while (nextbits()==GROUP_START_CODE)
}while(nextbits()==SEQUENCE_HEADER_CODE)
SEQUENCE_END_CODE
};

正是由于视频序列中存在很多开始码，或者称之为定位码、同步码。用来告诉解码器目前数据的区域信息，所以解码器才可以正确的处理各个数据区的数据，下面就是视频序列中的开始码的罗列：
#define SEQ_END_CODE 0x000001b7
#define SEQ_START_CODE 0x000001b3
#define GOP_START_CODE 0x000001b8
#define PICTURE_START_CODE 0x00000100
#define SLICE_MIN_START_CODE 0x00000101
#define SLICE_MAX_START_CODE 0x000001af
#define EXT_START_CODE 0x000001b5
#define USER_START_CODE 0x000001b2
这些开始码都是一些特殊的32bits的比特序列，在视频码流中不会出现的。他们的起着标志的作用，具体可以从名称上面看出来。
其中EXT_START_CODE和USER_START_CODE在每个层里面都会出现，用来标志扩展数据区和用户数据区，用来添加任意的数据，直到下一个开始码结束。
2.2画面组层（GOP）
在软件xmplay1.1中的定义
typedef struct GoP {
  BOOLEAN drop_flag;                     /* Flag indicating dropped frame. */
  unsigned int tc_hours;                 /* Hour component of time code.   */
  unsigned int tc_minutes;               /* Minute component of time code. */
  unsigned int tc_seconds;               /* Second component of time code. */
  unsigned int tc_pictures;              /* Picture counter of time code.  */
  BOOLEAN closed_gop;                    /* Indicates no pred. vectors to
    previous group of pictures.    */
  BOOLEAN broken_link;                   /* B frame unable to be decoded.  */
  char *ext_data;                        /* Extension data.                */
  char *user_data;                       /* User data.                     */
} GoP;

当然每个画面组层都是开始与标志码：GOP_START_CODE
该层次语法上的定义是
group_of_pictures{
GOP_START_CODE
Time_code; tc_hours,tc_minutes,tc_seconds,tc_pictures
Closed_gop;
Broken_link;
Next_start_code;
If(nextbits==extension_start_code){
Extension_start_code;
While(nextbits()==”0000 0000 0000 0000 0000 0001”){
Group_extension_data;
}
next_start_code()
}
if(nextbits==user_data_start_code){
user_data_start_code
while(nextbits()!=’0000 0000 0000 0000 0000 0001’){
user_data;
}
next_start_code()
}
do{
picture()
}while(nextbits==picture_start_code)
}

Mpeg流最终显示出来是一系列的画面，而画面组是mpeg流中可以独立编码的最小的单位，每个画面组由一个标题和一系列画面组成。GOP标题包含了时间和编辑的信息。
Mpeg画面组中必须至少有一个I帧画面，可以有数目可变的B帧和P帧画面，也可以没有P和B帧。画面组的第一幅编码画面是I画面，该画面之后跟随着任意数目的I或P画面，每对I、P画面之间可以插入任意数目的B画面。
画面组是画面的集合，每幅画面按照显示的顺序相邻。
画面组中的画面有两种排列顺序：
1．按比特流顺序 必须以I帧开头，后面可按任何的次序，跟上任意数目的I，P或B画面。
2．按显示顺序必须以I或B画面打头，且以I或P画面结束，最小的画面组由一个I画面组成。

从编码角度，可以精确的陈述的是，画面组以一个画面组标题开始，以最先出现的下一个画面组标题或者下一个序列标题或者序列结束码结束。

Mepg流中的标志码也就是开始码，对正确的分割和识别码流的成分起到了至关重要的作用。

2.3画面层（Pictures）
画面组层中的一幅幅画面就是画面层的数据了。包含了一幅画面的所有编码信息。一幅画面同样始于画面的标题。标题以画面开始码（PICTURE_START_CODE 0x00000100）打头。
解析画面单元的语法结构：
picture(){
picture_start_code
temprol_reference     /*时序编号，通常一组画面的编号都在1024以内，如果超过那么在1025幅画面出复位为0，重新计数。*/                                   
picture_coding_type                        
vbv_delay/*对于固定比特率的视频流，vbv_delay用与解码过程开始和随机存取之后，以保证在第一幅画面被显示之前，解码器已经读到正确数目的比特数。*/
if((picture_coding_type==2) || picture_coding_type==3){
full_pel_foward_vector /*全象素前向矢量，给定前向矢量的精度，在P和B画面的标题中出现*/
forward_f_code
}
if(picture_coding_type==3){
full_pel_backward_vector
back_f_code
}
while(nextbits()==’1’){
extra_bit_picture
extra_information_picture
}
extra_bit_picture
next_start_code

if(nextbits()==extension_start_code){
extension_start_code
while(nextbits()!=’0000 0000 0000 0000 0000 0001’){
picture_extension_data
}
next_start_code()
}
if(nextbits()==user_data_start_code){
user_data_start_code
while(nextbits()!=’0000 0000 0000 0000 0000 0001’){
user_data
}
next_start_code()
}
do {
slice()
}while(nextbits()==slice_start_code)
}

整个画面单元结构是这样的：
typedef struct pict {
  unsigned int temp_ref;                 /* Temporal reference.             */
  unsigned int code_type;                /* Frame type: P, B, I             */
  unsigned int vbv_delay;                /* Buffer delay.                   */
  BOOLEAN full_pel_forw_vector;          /* Forw. vectors specified in full
    pixel values flag.              */
  unsigned int forw_r_size;              /* Used for vector decoding.       */
  unsigned int forw_f;                   /* Used for vector decoding.       */
  BOOLEAN full_pel_back_vector;          /* Back vectors specified in full
    pixel values flag.              */
  unsigned int back_r_size;              /* Used in decoding.               */
  unsigned int back_f;                   /* Used in decoding.               */
  char *extra_info;                      /* Extra bit picture info.         */
  char *ext_data;                        /* Extension data.                 */
  char *user_data;                       /* User data.                      */
} Pict;

可以看出整个pictures层的bit流结构中由标题和pictures数据组成。
标题中提供了必要的画面信息数据和运动矢量的信息。

2.4片层(Slice)
片是任意数目宏块组成的序列，其中宏块必须从画面的左上位置开始，按照光栅扫描的方向从左到右，从上到下排列。片中至少包涵一个宏块，片与片之间没有重叠，也没有间隙。

片层的解析语法：
首先给出识别出Slice层数据的头标slice_start_code
『
#define SLICE_MIN_START_CODE 0x00000101
#define SLICE_MAX_START_CODE 0x000001af
』
slice{
slice_start_code /*从中可以计算出slice_vertical_position  片中第一个宏块，以宏块为单位的垂直位置*/
quantizer_scale       /*设置量化步长尺寸。1－31*/
while(nextbits()==’1’){
extra_bit_slice                       ‘1’
extra_information_slice
}
extra_bit_scale                            ‘0’
do{
macroblock()
}while(nextbits()!=’0000 0000 0000 0000 0000 0000’)
next_start_code()
}

typedef struct slice {
  unsigned int vert_pos;                 /* Vertical position of slice. */
  unsigned int quant_scale;              /* Quantization scale.         */
  char *extra_info;                      /* Extra bit slice info.       */
} Slice;

[此贴子已经被作者于2008-7-19 17:51:53编辑过]
--  作者：cdmalcl
--  发布时间：2008-7-19 17:49:34
-- 
每个片由一个开始码开始，开始后DC系数和矢量解码的预测值都被复位，片开始部位的位置的水平位置由片中第一个宏块的宏块地址决定。这些措施使得在一幅画面内任何一片都可以单独编码而不需要前一片的信息。当解码是出现错误，即可以从后继的片重新开始。
所以，当数据在无错的环境中，可以一幅画面就作为一片，但是如果是有错的环境，则每行宏块作为一片会更加合理。

表2  256×192画面内的片划分（每行宏块作为一个片，每个片的高度都是16pixels）
1开始                                                                                1结束
2开始                                                                                2结束
3开始                                                                                3结束
4开始                                                                                4结束
5开始                                                                                5结束
6开始                                                                                6结束
7开始                                                                                7结束
8开始                                                                                8结束
9开始                                                                                9结束
10开始                                                                              10结束
11开始                                                                              11结束
12开始                                                                              12结束
13开始                                                                              13结束
实际情况中片不宜太多，因为片标题，以及新片所需要尽心重新编码花费的开销很大。
片始于片标题，片标题又始于片开始码，片开始码是可以在一个范围中取得得，这个范围就是
#define SLICE_MIN_START_CODE 0x00000101
#define SLICE_MAX_START_CODE 0x000001af
片开始码得最后8为可以给出片得垂直位置，即以宏块为单位从画面顶部位置为1开始算起，片中第一个宏块的垂直位置。宏块有一个行号可以作为它得定位数据，这个行号的计算方法是：片垂直位置－1
宏块的垂直位置最大为175。片中第一个宏块的水平位置，可以由该宏块的地址偏移计算出来，所以不需要依赖画面内的任何其他的宏块的信息。
--  作者：cdmalcl
--  发布时间：2008-7-19 17:49:59
-- 
2.5宏块层(Macroblock)
宏块是包含16pixels*16lines的亮度分量部分，以及在空间位置上对应的两个8pixels*8lines的色度分量部分，一个宏块有4个亮度块和2个色度块。宏块可以指源图像或者重构图像的数据，或者是量化后的DCT系数。
宏块中块的顺序如下：
表1  宏块中块的排列

01
23

4

5

Y分量Cb分量Cr分量

宏块的数据分析语法描述：

macroblock(){
while(nextbits()==’0000 0001 111’){
macroblock_stuffing /*宏块填料，为了防止下溢出，由编码器填入的数据，有它固定的11位bit格式就是’0000 0001 111’,当然解决下溢出的方法还有很多，编码器可以在标题之前就加入填料位，或者可以减小quant_scale获得更多的编码系数等等*/
}
while(nextbits()==’0000 0001 000’){
macroblock_escape  /*固定模式的bit串，当macroblock_address与previous_macroblock_address的差大于33时将用到该码。使得后继的macroblock_increment所表示的值加33。
}
macroblock_address_increment   /*用于表示macroblock_address和previous_macorblock_ address之间的差值。 最大值为33，当前两者差大于33时用macroblock_escape补充。 Macroblock_address表示的是宏块在画面中的绝对位置，最左上角的宏块的macroblock_address为0，previous_macroblock_address指示片中最后一个非跳空宏块的位置。
macroblock_type 
if(macroblock_motion_forward){
motion_horizontal_forward_code
if((forward_f!=1) && (motion_horizontal_forward_code!=0))
motion_horizontal_forward_r
motion_vertical_forward_code
if((forward_f!=1) && (motion_vertical_forward_code!=0))
motion_vertical_forward_r
}
if(macroblock_motion_backward){
motion_horizontal_backward_code
if((backward_f!=1) && (motion_horizontal_backward_code!=0))
motion_horizontal_backward_r
motion_vertical_backward_code
if((backward_f!=1) && (motion_vertical_backward_code!=0))
motion_vertical_backward_r
}
if(macroblock_pattern)
coded_block_pattern /*可以得到宏块宏块的pattern_code[i](i=0:5)，从而确定该宏块接收到的块的种类有哪些。*/
for(i=0;i<6;i++)
block(i)
if(picture_coding_type==4)
end_of_marcoblock
}
片被分为16pixels*16lines的象素宏块。每个宏块都有它的标题。包含了宏块的地址、类型、量化器标尺信息等等。标题之后是该宏块的6个块的数据。

在Xmplay代码中给出的macrblock的定义：
typedef struct macroblock {
  int mb_address;                        /* Macroblock address.              */
  int past_mb_addr;                      /* Previous mblock address.         */
  int motion_h_forw_code;                /* Forw. horiz. motion vector code. */
  unsigned int motion_h_forw_r;          /* Used in decoding vectors.        */
  int motion_v_forw_code;                /* Forw. vert. motion vector code.  */
  unsigned int motion_v_forw_r;          /* Used in decdoinge vectors.       */
  int motion_h_back_code;                /* Back horiz. motion vector code.  */
  unsigned int motion_h_back_r;          /* Used in decoding vectors.        */
  int motion_v_back_code;                /* Back vert. motion vector code.   */
  unsigned int motion_v_back_r;          /* Used in decoding vectors.        */
  unsigned int cbp;                      /* Coded block pattern.             */
  BOOLEAN mb_intra;                      /* Intracoded mblock flag.          */
  BOOLEAN bpict_past_forw;               /* Past B frame forw. vector flag.  */
  BOOLEAN bpict_past_back;               /* Past B frame back vector flag.   */
  int past_intra_addr;                   /* Addr of last intracoded mblock.  */
  int recon_right_for_prev;              /* Past right forw. vector.         */
  int recon_down_for_prev;               /* Past down forw. vector.          */
  int recon_right_back_prev;             /* Past right back vector.          */
  int recon_down_back_prev;              /* Past down back vector.           */
} Macroblock;
2.6块层(Block)
块是一个正交的8pixels*8lines的亮度或者色度分量，块可以指源画面数据或者相应的编码数据元素。
8*8单位象素的源画面数据经过DCT变换后的成为了相应的DCT系数块。
块的具体结构为（xmplay源码中的结构定义）：
typedef struct block {
  short int dct_recon[8][8];             /* Reconstructed dct coeff matrix. */
  short int dct_dc_y_past;               /* Past lum. dc dct coefficient.   */
  short int dct_dc_cr_past;              /* Past cr dc dct coefficient.     */
  short int dct_dc_cb_past;              /* Past cb dc dct coefficient.     */
} Block;

解析块的语法结构是：
block(i){
if(pattern_code[i]){
if(macroblock_intra){
if(i<4){
dct_dc_size_luminance
if(dc_size_luminance!=0)
dct_dc_differential
}
else{
dct_dc_size_chrominance
if(dc_size_chrominance!=0)
dct_dc_differential
}
}
else{
dct_coeff_first
}
if(picture_coding_type!=4){
while(nextbits()!=’10’)
dct_coeff_next
end_of_block
}
}
http://www.ds0101.net/bbs/TopicOther.asp?t=5&BoardID=19&id=889 , 引用的原址。