avireader.cpp

播放被H264_AAC所压缩的avi文件的播放器。

      if(dwRead!=8) ERR_EXIT(AVI_ERR_READ)
      if( strncmp((const char*)data,(const char*)m_pAviFile->idx[i],4)==0 && Str2ULong((BYTE*)data+4)==len )
      {
         idx_type = 1; /* Index from start of file */
      }
      else
      {
		 SetFilePointer(m_pAviFile->fDes, pos+m_pAviFile->movi_start-4, NULL, FILE_BEGIN);
		 ReadFile(m_pAviFile->fDes, data, 8, &dwRead, NULL);
         if(dwRead!=8) ERR_EXIT(AVI_ERR_READ)
         if( strncmp((const char*)data,(const char*)m_pAviFile->idx[i],4)==0 && Str2ULong((BYTE*)data+4)==len )
         {
            idx_type = 2; /* Index from start of movi list */
         }
      }
      /* idx_type remains 0 if neither of the two tests above succeeds */
   }

   if(idx_type == 0)
   {
      /* we must search through the file to get the index */
	  SetFilePointer(m_pAviFile->fDes, m_pAviFile->movi_start, NULL, FILE_BEGIN);

      m_pAviFile->n_idx = 0;

      while(1)
      {
		 ReadFile(m_pAviFile->fDes, data, 8, &dwRead, NULL);
         if( dwRead != 8 ) break;
         n = Str2ULong((BYTE*)data+4);

         /* The movi list may contain sub-lists, ignore them */

         if(strncmp(data,"LIST",4)==0)
         {
			SetFilePointer(m_pAviFile->fDes, 4, NULL, FILE_CURRENT);
            continue;
         }

         /* Check if we got a tag ##db, ##dc or ##wb */

         if( ( (data[2]=='d' || data[2]=='D') &&
               (data[3]=='b' || data[3]=='B' || data[3]=='c' || data[3]=='C') )
          || ( (data[2]=='w' || data[2]=='W') &&
               (data[3]=='b' || data[3]=='B') ) )
         {
            AddIndexEntry((BYTE*)data,0,SetFilePointer(m_pAviFile->fDes, 0, NULL, FILE_CURRENT)-8,n);
         }

		 SetFilePointer(m_pAviFile->fDes, PAD_EVEN(n), NULL, FILE_CURRENT);
      }
      idx_type = 1;
   }

   /* Now generate the video index and audio index arrays */

   nvi = 0;
   nai = 0;

   for(i=0;i<m_pAviFile->n_idx;i++)
   {
      if(strncmp((const char*)m_pAviFile->idx[i],m_pAviFile->video_tag,3) == 0) nvi++;
      if(strncmp((const char*)m_pAviFile->idx[i],m_pAviFile->audio_tag,4) == 0) nai++;
   }

   m_pAviFile->video_frames = nvi;
   m_pAviFile->audio_chunks = nai;

   if(m_pAviFile->video_frames==0) ERR_EXIT(AVI_ERR_NO_VIDS)
   m_pAviFile->hvideo_index = GlobalAlloc(GMEM_MOVEABLE, sizeof(video_index_entry) * nvi);
   if(m_pAviFile->hvideo_index==0) ERR_EXIT(AVI_ERR_NO_MEM)
   if(m_pAviFile->audio_chunks)
   {
	  m_pAviFile->haudio_index = GlobalAlloc(GMEM_MOVEABLE, sizeof(audio_index_entry) * nai);
      if(m_pAviFile->haudio_index==0) ERR_EXIT(AVI_ERR_NO_MEM)
   }

   nvi = 0;
   nai = 0;
   audtot = 0;
   vidtot = 0;
   ioff = idx_type == 1 ? 8 : m_pAviFile->movi_start+4;

   m_pAviFile->lpvideo_index = (pvideo_index_entry)GlobalLock(m_pAviFile->hvideo_index);
   m_pAviFile->lpaudio_index = (paudio_index_entry)GlobalLock(m_pAviFile->haudio_index);
   for(i=0;i<m_pAviFile->n_idx;i++)
   {
      if(strncmp((const char*)m_pAviFile->idx[i],m_pAviFile->video_tag,3) == 0)
      {
		 m_pAviFile->lpvideo_index[nvi].sign = Str2ULong(m_pAviFile->idx[i]);
         m_pAviFile->lpvideo_index[nvi].pos = Str2ULong(m_pAviFile->idx[i]+ 8)+ioff;
         m_pAviFile->lpvideo_index[nvi].len = Str2ULong(m_pAviFile->idx[i]+12);
		 vidtot += m_pAviFile->lpvideo_index[nvi].len;
         nvi++;
      }
      if(strncmp((const char*)m_pAviFile->idx[i],m_pAviFile->audio_tag,4) == 0)
      {
         m_pAviFile->lpaudio_index[nai].pos = Str2ULong(m_pAviFile->idx[i]+ 8)+ioff;
         m_pAviFile->lpaudio_index[nai].len = Str2ULong(m_pAviFile->idx[i]+12);
         m_pAviFile->lpaudio_index[nai].tot = audtot;
         audtot += m_pAviFile->lpaudio_index[nai].len;
         nai++;
      }
   }

   GlobalUnlock(m_pAviFile->hvideo_index);
   GlobalUnlock(m_pAviFile->haudio_index);

   m_pAviFile->audio_bytes = audtot;
   m_pAviFile->video_bytes = vidtot;

   /* Reposition the file */

   SetFilePointer(m_pAviFile->fDes, m_pAviFile->movi_start, NULL, FILE_BEGIN);

   m_pAviFile->video_pos = 0;
   m_pAviFile->audio_posc = 0;

   m_pAviFile->filesize = GetFileSize(m_pAviFile->fDes, NULL);

   return 0;
}

//##ModelId=4753BE280277
int CAviReader::SetVideoPosition(LONG nFrame, DWORD *nFrameLen)
{
	if( !m_pAviFile->lpvideo_index )         
	{ 
		m_nAviErrNo = AVI_ERR_NO_IDX;   
		return -1; 
	}
	if( nFrame >= m_pAviFile->video_frames - 1 ) 
		return 0;

	m_pAviFile->video_pos = nFrame;
	m_nCurVideoPos = nFrame;
	if ( nFrameLen != NULL )
		*nFrameLen = m_pAviFile->lpvideo_index[nFrame].len;
	
	return 0;
}

//##ModelId=4753BE280263
int CAviReader::ReadVideo(BYTE **lpVideo, DWORD &nTimeStamp)
{
	DWORD nVideoLen, dwRead;

	if( !m_pAviFile->lpvideo_index )         
	{ 
		m_nAviErrNo = AVI_ERR_NO_IDX;   
		return -1; 
	}

	if(m_pAviFile->video_pos < 0 || m_pAviFile->video_pos >= m_pAviFile->video_frames ) 
		return 0;

	nVideoLen = m_pAviFile->lpvideo_index[m_pAviFile->video_pos].len;
	
	SetFilePointer(m_pAviFile->fDes, m_pAviFile->lpvideo_index[m_pAviFile->video_pos].pos, NULL, FILE_BEGIN);
	if( ReadFile(m_pAviFile->fDes, m_pVideoBuf, nVideoLen, &dwRead, NULL) == FALSE )
	{
		m_nAviErrNo = AVI_ERR_READ;
		return -1;
	}
	*lpVideo = m_pVideoBuf;
	nTimeStamp = (DWORD)((float)m_pAviFile->video_pos * 1000.0/ (float)m_pAviFile->fps + 0.5);
	m_pAviFile->video_pos ++;
	m_nCurVideoPos = m_pAviFile->video_pos;
	return nVideoLen;
}

//##ModelId=4753BE280281
int CAviReader::SetAudioFrame(LONG nFrame, DWORD *nFrameLen)
{
	if( nFrame >= m_pAviFile->audio_chunks - 1 ) 
		return -1;

	m_pAviFile->audio_posc = nFrame;
	m_pAviFile->audio_posb = 0;
	m_nCurAudioPos = nFrame;
	if( nFrameLen != NULL )
		*nFrameLen = m_pAviFile->lpaudio_index[nFrame].len;
	return 0;	
}

//##ModelId=4753BE280266
int CAviReader::ReadAudioFrame(BYTE **lpAudio, DWORD &nTimeStamp)
{
   DWORD nAudioLen, dwRead;

	if( !m_pAviFile->lpaudio_index )
	{ 
		m_nAviErrNo = AVI_ERR_NO_IDX;   
		return -1; 
	}

	if( m_pAviFile->audio_posc < 0 || m_pAviFile->audio_posc >= m_pAviFile->audio_chunks ) 
		return 0;

	nAudioLen = m_pAviFile->lpaudio_index[m_pAviFile->audio_posc].len;

	SetFilePointer(m_pAviFile->fDes, m_pAviFile->lpaudio_index[m_pAviFile->audio_posc].pos, NULL, FILE_BEGIN);
	if( ReadFile(m_pAviFile->fDes, m_pAudioBuf, nAudioLen, &dwRead, NULL) == FALSE )
	{
		m_nAviErrNo = AVI_ERR_READ;
		return -1;
	}
	*lpAudio = m_pAudioBuf;
	nTimeStamp = (DWORD)((float)m_pAviFile->audio_posc * 1024000.0/(float)m_pAviFile->a_rate + 0.5);
	m_pAviFile->audio_posc++;
	m_nCurAudioPos = m_pAviFile->audio_posc;
	return nAudioLen;
}
//##ModelId=4753BE280271
BOOL CAviReader::SetAviReaderPos(float fStartPlayTime)
{
	LONG nVideoPos, nAudioPos;
	LONG nCurIdx;

	nCurIdx = (LONG)(fStartPlayTime * m_pAviFile->fps);
	m_fStartPlayTime = fStartPlayTime;

	if( !SearchVideoPos(nCurIdx, nVideoPos, nAudioPos) )	
		return FALSE;
	
	SetVideoPosition(nVideoPos, NULL);
	SetAudioFrame(nAudioPos, NULL);
	return TRUE;
}

//##ModelId=4753BE280274
void CAviReader::GetAviReaderPos(LONG &nVideoPos, LONG &nAudioPos)
{
	nVideoPos = m_pAviFile->video_pos;
	nAudioPos = m_pAviFile->audio_posc;
}
//##ModelId=4753BE280290
BOOL CAviReader::IsEndRead()
{
	if( m_pAviFile->audio_posc >= m_pAviFile->audio_chunks && m_pAviFile->video_pos >= m_pAviFile->video_frames )
		return TRUE;
	return FALSE;
}
//##ModelId=4753BE280251
int CAviReader::CloseAviFile()
{
   int ret;

   ret = 0;

   /* Even if there happened a error, we first clean up */
   if(m_pAviFile == NULL)
	   return 0;
   
   if(!m_pAviFile->fDes)
		CloseHandle(m_pAviFile->fDes);
   
   if(m_pAviFile->idx) free(m_pAviFile->idx);
   if(m_pAviFile->hvideo_index) GlobalFree(m_pAviFile->hvideo_index);
   if(m_pAviFile->haudio_index) GlobalFree(m_pAviFile->haudio_index);

   return ret;
}

//##ModelId=4753BE280291
BOOL CAviReader::SearchVideoPos(LONG nCurIdx, LONG &nVideoPos, LONG &nAudioPos)
{
	int	iSeekPos = 1;
	int nIdx = nCurIdx;

	m_pAviFile->lpvideo_index = (pvideo_index_entry)GlobalLock(m_pAviFile->hvideo_index);

	while( (nIdx <= m_pAviFile->video_frames) && (nIdx >= 0) ) 
	{
		if(m_pAviFile->lpvideo_index[nIdx].sign == I_FRAME)
		{
			nVideoPos = nIdx;
			//nAudioPos = (LONG)((double)nIdx * ((double)m_pAviFile->audio_chunks / (double)m_pAviFile->video_frames));
			nAudioPos = (LONG)(m_pAviFile->acps * nVideoPos/m_pAviFile->fps + 0.5);
			GlobalUnlock(m_pAviFile->hvideo_index);
			return TRUE;
		}
		nIdx += iSeekPos;
	}

	GlobalUnlock(m_pAviFile->hvideo_index);
	return FALSE;
}

/************************************************************************/
/*                         CheckEnable                                  */
/************************************************************************/
//	扁瓷 : Seek扁瓷捞 蜡瓤茄啊甫 八荤茄促.
//	八荤扁霖
//		 I 橇饭烙捞 2俺 捞惑捞搁 SEEK啊瓷窍绊 
//					2俺 捞窍捞搁 SEEK阂啊瓷茄巴栏肺 魄沥茄促.
//	登档覆蔼.
//		TRUE	- SEEK扁瓷捞 蜡瓤.
//		FALSE	- SEEK扁瓷捞 公瓤.
//##ModelId=4753BE280284
BOOL CAviReader::CheckSeekEnable()
{
	UINT	i = 0;
	UINT	nEndIdx = m_pAviFile->video_frames;
	UINT	nCount = 0;

	m_pAviFile->lpvideo_index = (pvideo_index_entry)GlobalLock(m_pAviFile->hvideo_index);
	while (i != nEndIdx) {
		if(m_pAviFile->lpvideo_index[i].sign == I_FRAME)
		{
			nCount ++;
			if(nCount > 2)
				break;
		}
		i ++;
	};
	GlobalUnlock(m_pAviFile->hvideo_index);
	
	if(nCount < 2)
		return FALSE;

	return TRUE;
}

//##ModelId=4753BE280285
double CAviReader::GetVideoBitrate()
{
	double bitrate = 300.0; //300Bms
	if( m_pAviFile )
		bitrate = (double)m_pAviFile->video_bytes / (1000.0 * m_pAviFile->video_frames/m_pAviFile->fps);
	return bitrate;
}

//##ModelId=4753BE280286
double CAviReader::GetAudioBitrate()
{
	double bitrate = 80.0; //80Bms
	if( m_pAviFile )
	{
		bitrate = (double)m_pAviFile->audio_bytes / (1000.0 * m_pAviFile->audio_chunks * 1024.0 / m_pAviFile->a_rate);
	}
	return bitrate;
}