avidecaps.cpp

PocketMVP V0.8082503 source for Pocket 的程序源代码

	hdrl_data=0;
	
	thisvid.video_tag[0] = thisvid.video_strn/10 + '0';
	thisvid.video_tag[1] = thisvid.video_strn%10 + '0';
	thisvid.video_tag[2] = 'd';
	thisvid.video_tag[3] = 'b';
	
	thisvid.audio_tag[0] = thisvid.audio_strn/10 + '0';
	thisvid.audio_tag[1] = thisvid.audio_strn%10 + '0';
	thisvid.audio_tag[2] = 'w';
	thisvid.audio_tag[3] = 'b';
	
	//InputMediaSeek(thisvid.movi_start, INPUT_SEEK_SET);
	
	
	idx_type = 0;
	thisvid.audio_chunks = nai;
	
	thisvid.idx=0;
	thisvid.audio_bytes = tot;
	/* 
     * reposition the file 
     *
     */
	InputMediaClose();
	int fsize=InputMediaOpen(thisvid.m_lpFilename,0,0,4000000,CacheSize);
	if (!fsize) return 0;
	int time=(int)((((double)thisvid.video_frames)/((double)thisvid.fps)));
	int abytes=(time*32000)/8;
	thisvid.threshhold=(int)(((double)((fsize-abytes)/time)/thisvid.fps)*(4));
	//Sleep(1000);
	InputMediaSeek(thisvid.movi_start, 
		INPUT_SEEK_SET);
	
	thisvid.video_pos = 0;
	return 1;
}


/*
 * Reading Functions
 *
 */

/*
 * Tries to open an AVI
 * with and without an index
 */

int AVIDecaps_Open(LPTSTR lpFilename, int Cache, int CacheSize,videoinfo** vidinfo)
{
	int ret=0;

	wcscpy(thisvid.m_lpFilename,lpFilename);
	thisvid.m_type=Cache;
	::CacheSize=CacheSize;
	if (Cache)
		hDLL=LoadLibrary(_T("InputMediaCache.dll"));
	else
		hDLL=LoadLibrary(_T("InputMedia.dll"));
	if (!hDLL) return 0;
	InputMediaRead=(pInputMediaRead)GetProcAddress(hDLL,_T("InputMediaRead"));
	InputMediaSeek=(pInputMediaSeek)GetProcAddress(hDLL,_T("InputMediaSeek"));
	InputMediaOpen=(pInputMediaOpen)GetProcAddress(hDLL,_T("InputMediaOpen"));
	InputMediaClose=(pInputMediaClose)GetProcAddress(hDLL,_T("InputMediaClose"));
	if (!InputMediaOpen(lpFilename, 0, 0,-1,1000000))
	{
		FreeLibrary(hDLL);
		hDLL=NULL;
		return 0;
	}
	thisvid.hIOMutex = CreateMutex (NULL, FALSE, NULL);

	thisvid.video_pos  = 0;
	thisvid.audio_posc = 0;
	thisvid.audio_posb = 0;

	thisvid.idx         = NULL;
	thisvid.video_index = NULL;
	thisvid.audio_index = NULL;


	if(AVIDecaps_IsAVI()) {

		
		if(AVIDecaps_FillHeader(1)) {
		
			ret= 1;
		}
	}
	*vidinfo=&::thisvid;
	return ret;
}


/*
 * Reads the next video Frame into
 * buffer, return the actual size of
 * the frame.
 *
 */

int AVIDecaps_NextVideoFrame(char *buffer, int drop)
{
   unsigned int n;
	if (drop&&AVIDecaps_isKeyframe(thisvid.video_pos+1))
	{
		thisvid.video_pos++;
		return 0;
	}
   n = thisvid.video_index[thisvid.video_pos].len;
   WaitForSingleObject(thisvid.hIOMutex, INFINITE);

   InputMediaSeek(thisvid.video_index[thisvid.video_pos].pos, INPUT_SEEK_SET);

   InputMediaRead(buffer, n);
   ReleaseMutex(thisvid.hIOMutex);

   thisvid.video_pos++;


   return n;
}

/*
 * Reads any amount of audio
 * data. FIXME : should return
 * the actual number read.
 */

int AVIDecaps_ReadAudio(char *audbuf, int bytes)
{
	int nr, left = 0, todo;


   nr = 0; 


   /*
    * We loop until we parsed enough
	* chunks for the amount we want
    *
    */

   while(bytes > 0)
   {
      left = thisvid.audio_index[thisvid.audio_posc].len - thisvid.audio_posb;

      if(!left)
      {
         if(thisvid.audio_posc>=thisvid.audio_chunks-1) 
		 {
			//ReleaseMutex(thisvid.hIOMutex);
			return nr;
		 }
         thisvid.audio_posc++;
         thisvid.audio_posb = 0;
         continue;
      }
      if(bytes<left)
         todo = bytes;
      else
         todo = left;
      
	  WaitForSingleObject(thisvid.hIOMutex, INFINITE);
	  InputMediaSeek(thisvid.audio_index[thisvid.audio_posc].pos + thisvid.audio_posb, INPUT_SEEK_SET);

      InputMediaRead(audbuf + nr, todo);
	  ReleaseMutex(thisvid.hIOMutex);

      bytes -= todo;
      nr    += todo;
      thisvid.audio_posb += todo;
   }



   return nr;
}


double AVIDecaps_FrameRate()
{

	return (double) thisvid.fps;
}


int AVIDecaps_AudioSeek(long bytes)
{
   long n0, n1, n;

   if(!thisvid.audio_index) { 
       return -1; 
   }

   if(bytes < 0) 
	   bytes = 0;

   n0 = 0;
   n1 = thisvid.audio_chunks;

   while(n0 < n1 - 1)
   {
      n = (n0 + n1) / 2;
      if(thisvid.audio_index[n].tot > bytes)
         n1 = n;
      else
         n0 = n;
   }

   thisvid.audio_posc = n0;

   if(thisvid.audio_index[n0].len > 1000) {
     thisvid.audio_posb = bytes - thisvid.audio_index[n0].tot;
   }
   else {
     thisvid.audio_posb = 0;
   }

   return 0;
}

BOOL AVIDecaps_isKeyframe(long frame)
{
  return thisvid.video_index[frame].flags; // & AVIIF_KEYFRAME;
}

int AVIDecaps_Seek(int percent, int isFrame)
{
	long frame;
	double ratio;
	long audio_bytes;

	WaitForSingleObject(thisvid.hIOMutex, INFINITE);

	/*
     * compute the desired 
     * frame number
     *
     */

	if (!isFrame)
		frame = (long) (percent * thisvid.video_frames / 100);
	else
		frame=percent;

    /*
     * and go to the next 
     * keyframe.
     *
     */
  
    while(!AVIDecaps_isKeyframe(frame)) {
      frame--;
    }

    /*
     * now set video 
     * position.
     *
     */
    
	//AVIDecaps_VideoSeek(frame);
	thisvid.video_pos = frame;
    /*
     * calculate what ratio 
     * it corresponds to
     *
     */
    if(thisvid.audio_strn > 0) {
      
      ratio = (double) ((double) frame / (double) thisvid.video_frames);
      
      /*
       * and set audio 
       * position
       *
       */
      audio_bytes  = (long) (ratio * thisvid.audio_bytes);
      audio_bytes  += audio_bytes % 4;

      AVIDecaps_AudioSeek(audio_bytes);

      ReleaseMutex(thisvid.hIOMutex);
	  if (thisvid.audio_index[thisvid.audio_posc].pos + thisvid.audio_posb<thisvid.video_index[thisvid.video_pos].pos)
		InputMediaSeek(thisvid.audio_index[thisvid.audio_posc].pos + thisvid.audio_posb, INPUT_SEEK_SET);
	  else
		InputMediaSeek(thisvid.video_index[thisvid.video_pos].pos, INPUT_SEEK_SET);
		
      return thisvid.audio_bytes-audio_bytes;
	}

	return 1;
}

int AVIDecaps_ReSeekAudio()
{
	double ratio;
	long audio_bytes;

    if(thisvid.audio_strn > 0) {

	  WaitForSingleObject(thisvid.hIOMutex, INFINITE);

      ratio = (double) ((double) thisvid.video_pos / (double) thisvid.video_frames);
      
      audio_bytes  = (long) (ratio * thisvid.audio_bytes);
      audio_bytes  += audio_bytes % 4;

      AVIDecaps_AudioSeek(audio_bytes);

      ReleaseMutex(thisvid.hIOMutex);

	}

    return thisvid.audio_bytes-audio_bytes;
}

double AVIDecaps_GetProgress()
{
	return (double) ((double)(thisvid.video_pos))*100.0/((double)thisvid.video_frames);
}


int AVIDecaps_Close()
{
	if (hDLL)
	{
		InputMediaClose();
		if (thisvid.video_index) free(thisvid.video_index);
		if (thisvid.audio_index) free(thisvid.audio_index);
		if (thisvid.idx) free(thisvid.idx);
		thisvid.video_index=0;
		thisvid.audio_index=0;
		thisvid.idx=0;
		FreeLibrary(hDLL);
		hDLL=NULL;
	}
	return 1;
}


void InitializeReader(reader* rd)
{
	rd->READER_Open=AVIDecaps_Open;
	rd->READER_ReadAudio=AVIDecaps_ReadAudio;
	rd->READER_NextVideoFrame=AVIDecaps_NextVideoFrame;
	rd->READER_Seek=AVIDecaps_Seek;
	rd->READER_ReSeekAudio=AVIDecaps_ReSeekAudio;
	rd->READER_GetProgress=AVIDecaps_GetProgress;
	rd->READER_Close=AVIDecaps_Close;
	rd->READER_isKeyFrame=AVIDecaps_isKeyframe;

}