开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
DecapsAVI.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：22k
源码类别：

VC书籍

开发平台：

Visual C++

DecapsAVI.cpp：源码内容
  2. #include "DecapsAVI.h"
  6. static void long2str(char *dst, int n)
  7. {
  8. dst[0] = (n      ) & 0xff;
  9. dst[1] = (n >>  8) & 0xff;
  10. dst[2] = (n >> 16) & 0xff;
  11. dst[3] = (n >> 24) & 0xff;
  12. }
  16. unsigned long str2ulong(char *str)
  17. {
  18.     unsigned long result;
  20. result = ( ((unsigned long) str[0] & 0xFF) | ( ((unsigned long)str[1] &0xFF) << 8) |
  21.   (((unsigned long) str[2] & 0xFF) << 16) | ( ((unsigned long) str[3] & 0xFF) << 24) );
  23. return result;
  24. }
  26. static unsigned long str2ushort(char *str)
  27. {
  28. return ( str[0] | (str[1]<<8) );
  29. }
  33. media_type_t MediaDecapsAVI::GetType()
  34. {
  35. return MEDIA_TYPE_DECAPS;
  36. }
  40. char *MediaDecapsAVI::GetName()
  41. {
  42. return "AVI Demuxer";
  43. }
  46. MP_RESULT MediaDecapsAVI::Connect(MediaItem *item)
  47. {
  48. if(item->GetType() == MEDIA_TYPE_INPUT) {
  50. this->input = (MediaItemInput *) item;
  51. }
  53. this->video_pos  = 0;
  54. this->audio_posc = 0;
  55. this->audio_posb = 0;
  57. this->idx         = NULL;
  58. this->video_index = NULL;
  59. this->audio_index = NULL;
  62. if(this->IsAVI()) {
  64. if(this->FillHeader(1)) {
  66. return MP_RESULT_OK;
  67. }
  68. else {
  70. this->input->Seek(0, INPUT_SEEK_SET);
  72. this->IsAVI();
  74. if(this->FillHeader(0)) {
  76. return MP_RESULT_OK;
  77. }
  78. }
  79. }
  81. return MP_RESULT_ERROR;
  82. }
  86. MP_RESULT MediaDecapsAVI::ReleaseConnections()
  87. {
  88. this->input = NULL;
  90. if(this->idx != NULL)
  91. free(this->idx);
  93. if(this->video_index != NULL)
  94. free(this->video_index);
  96. if(this->audio_index != NULL)
  97. free(this->audio_index);
  99. this->idx         = NULL;
  100. this->video_index = NULL;
  101. this->audio_index = NULL;
  103. this->audio_strn = 0;
  104. this->video_strn = 0;
  106. memset(&this->waveformatex, 0, sizeof(MPEGLAYER3WAVEFORMAT));
  107. memset(&this->bitmapinfoheader, 0, sizeof(BITMAPINFOHEADER));
  109. return MP_RESULT_OK;
  110. }
  112. DWORD         MediaDecapsAVI::GetCaps()
  113. {
  114. return 0;
  115. }
  117. MP_RESULT     MediaDecapsAVI::Configure(HINSTANCE hInstance, HWND hwnd)
  118. {
  119. return MP_RESULT_ERROR;
  120. }
  125. MediaDecapsAVI::MediaDecapsAVI()
  126. {
  127. this->video_pos  = 0;
  128. this->audio_posc = 0;
  129. this->audio_posb = 0;
  131. this->idx         = NULL;
  132. this->video_index = NULL;
  133. this->audio_index = NULL;
  135. this->hIOMutex = CreateMutex (NULL, FALSE, NULL);
  137. this->input = NULL;
  138. }
  140. MediaDecapsAVI::~MediaDecapsAVI()
  141. {
  142. CloseHandle(this->hIOMutex);
  143. }
  145. int MediaDecapsAVI::IsAVI()
  146. {
  147. MediaBuffer *mb = new MediaBuffer();
  148. mb->Alloc(12);
  150. if(this->input != NULL) {
  152. if( this->input->Read(mb, 12) != 12 ) {
  154. delete mb;
  155. return 0;
  156. }
  159. if( strncmp((char *) mb->GetData(), "RIFF", 4) !=0 || 
  160. strncmp(((char *) mb->GetData()) + 8, "AVI ", 4) !=0 ) {
  161. return 0;
  162. }
  164. delete mb;
  165. return 1;
  166. }
  168. return 0;
  169. }
  171. int MediaDecapsAVI::SampleSize()
  172. {
  173. int s;
  175. s = ((this->a_bits + 7) / 8) * this->a_chans;
  177. if(s == 0)
  178. s = 1;
  180. return s;
  181. }
  183. int MediaDecapsAVI::FillHeader(int getIndex)
  184. {
  185. unsigned long  n, rate; 
  186. long           scale, idx_type;
  187. char          *hdrl_data;
  188. long           i, hdrl_len = 0;
  189. long           nvi, nai, ioff;
  190. long           tot;
  191. int            lasttag = 0;
  192. int            vids_strh_seen = 0;
  193. int            vids_strf_seen = 0;
  194. int            auds_strh_seen = 0;
  195. int            auds_strf_seen = 0;
  196. int            num_stream = 0;
  197. MediaBuffer   *mb = new MediaBuffer();
  199. if(this->input == NULL)
  200. return MP_RESULT_ERROR;
  202. mb->Alloc(256);
  206. hdrl_data = 0;
  208. while(1)
  209.     {
  210. if( this->input->Read(mb, 8) != 8 ) 
  211. break; 
  214. n = str2ulong(((char *) mb->GetData()) + 4);
  215. n = PAD_EVEN(n);
  217. if(strncmp((char *) mb->GetData(), "LIST", 4) == 0)
  218. {
  220. if( this->input->Read(mb, 4) != 4 ) {
  222. mb->Free();
  223. return 0;
  224. }
  226. n -= 4;
  228. if(strncmp((char *) mb->GetData(), "hdrl", 4) == 0)
  229. {
  232. MediaBuffer *mbh;
  233. hdrl_len = n;
  235. char buffer[256];
  236. sprintf(buffer, "size = %d", n);
  238. mbh = new MediaBuffer();
  239. mbh->Alloc(n);
  241. hdrl_data = (char *) new char[n];
  243. if(hdrl_data == NULL) { 
  245. mb->Free();
  246. return 0;
  247. }
  249. if( this->input->Read(mbh, n) != n ) {
  251. mb->Free();
  252. return 0;
  253. }
  255. memcpy(hdrl_data, mbh->GetData(), n);
  256. mbh->Free();
  257. }
  258. else if(strncmp((char *) mb->GetData(), "movi", 4) == 0)
  259. {
  260. this->movi_start = this->input->Seek(0, INPUT_SEEK_CUR);
  262. this->input->Seek(n, INPUT_SEEK_CUR);
  263. }
  264. else
  265. this->input->Seek(n, INPUT_SEEK_CUR);
  266. }
  267. else if(strncmp((char *) mb->GetData(),"idx1",4) == 0)
  268. {
  272. this->n_idx = this->max_idx = n/16;
  273. this->idx = (char((*)[16]) ) new char[n];
  275. if(this->idx == NULL) { 
  277. mb->Free();
  278. return 0;
  279. }
  281. unsigned long read;
  282. MediaBuffer  *mbi = new MediaBuffer();
  284. mbi->Alloc(n);
  286. if( (read = this->input->Read(mbi, n)) != n ) {
  288. break;
  289. }
  291. memcpy(this->idx, mbi->GetData(), n);
  292. mbi->Free();
  293. }
  294. else {
  295.   
  296. this->input->Seek(n, INPUT_SEEK_CUR);
  297. }
  298. }
  300. if(!hdrl_data) {
  302. mb->Free();
  303. return 0;
  304. }
  306. if(!this->movi_start) {
  308. mb->Free();
  309. return 0;
  310. }
  315. for(i=0; i < hdrl_len; )
  316. {
  319. if(strncmp(hdrl_data + i, "LIST", 4)==0) 
  320. { 
  321. i+= 12; 
  322. continue; 
  323. }
  325. n = str2ulong(hdrl_data+i+4);
  326. n = PAD_EVEN(n);
  330. if(strncmp(hdrl_data + i, "strh", 4)==0)
  331. {
  332. i += 8;
  333. if(strncmp(hdrl_data + i, "vids", 4) == 0 && !vids_strh_seen)
  334. {
  335. memcpy(this->compressor,hdrl_data+i+4,4);
  337. this->compressor[4] = 0;
  339. scale = str2ulong(hdrl_data+i+20);
  340. rate  = str2ulong(hdrl_data+i+24);
  342. if(scale!=0) 
  343. this->fps = (double)rate/(double)scale;
  345. this->video_frames = str2ulong(hdrl_data+i+32);
  346. this->video_strn = num_stream;
  348. vids_strh_seen = 1;
  349. lasttag = 1; 
  350. }
  351. else if (strncmp (hdrl_data + i, "auds", 4) == 0 && ! auds_strh_seen)
  352. {
  353. this->audio_bytes = str2ulong(hdrl_data + i + 32)*this->SampleSize();
  354. this->audio_strn = num_stream;
  356. auds_strh_seen = 1;
  357. lasttag = 2; 
  358. }
  359. else
  360. lasttag = 0;
  361. num_stream++;
  362. }
  363. else if(strncmp(hdrl_data + i, "strf", 4)==0)
  364. {
  365. i += 8;
  366. if(lasttag == 1)
  367. {
  370. memcpy(&this->bitmapinfoheader, 
  371. hdrl_data + i,
  372. sizeof(BITMAPINFOHEADER));  
  374. this->width  = str2ulong(hdrl_data+i+4);
  375. this->height = str2ulong(hdrl_data+i+8);
  376. vids_strf_seen = 1;
  377. }
  378. else if(lasttag == 2)
  379. {
  382. memcpy(&this->waveformatex,
  383.    hdrl_data + i,
  384.    sizeof(MPEGLAYER3WAVEFORMAT));
  386. this->a_fmt   = str2ushort(hdrl_data + i  );
  387. this->a_chans = str2ushort(hdrl_data + i + 2);
  388. this->a_rate  = str2ulong (hdrl_data + i + 4);
  389. this->a_bits  = str2ushort(hdrl_data + i + 14) == 0 ? 16 : str2ushort(hdrl_data + i + 14);
  391. auds_strf_seen = 1;
  392. }
  393. lasttag = 0;
  394. }
  395. else
  396. {
  397. i += 8;
  398. lasttag = 0;
  399. }
  401. i += n;
  402. }
  404. free(hdrl_data);
  406. if(!vids_strh_seen || !vids_strf_seen || this->video_frames==0) { 
  408. mb->Free();
  409. return 0;
  410. }
  412. this->video_tag[0] = this->video_strn/10 + '0';
  413. this->video_tag[1] = this->video_strn%10 + '0';
  414. this->video_tag[2] = 'd';
  415. this->video_tag[3] = 'b';
  418. if(!this->a_chans) 
  419. this->audio_strn = 99;
  421. this->audio_tag[0] = this->audio_strn/10 + '0';
  422. this->audio_tag[1] = this->audio_strn%10 + '0';
  423. this->audio_tag[2] = 'w';
  424. this->audio_tag[3] = 'b';
  426. this->input->Seek(this->movi_start, INPUT_SEEK_SET);
  429. if(!getIndex) 
  430. return 1;
  434. idx_type = 0;
  436. if(this->idx)
  437. {
  438. unsigned long pos, len;
  442. for(i = 0; i < this->n_idx; i++) {
  443. if( strncmp(this->idx[i], this->video_tag, 3) == 0 ) 
  444. break;
  445. }
  447. if(i >= this->n_idx) 
  448. return 0;
  450. pos = str2ulong(this->idx[i] + 8);
  451. len = str2ulong(this->idx[i] + 12);
  453. this->input->Seek(pos, INPUT_SEEK_SET);
  455. if(this->input->Read(mb, 8)!=8) 
  456. return 0;
  458. if( strncmp((char *) mb->GetData(), this->idx[i], 4) == 0 && str2ulong((char *) mb->GetData() + 4) == len )
  459. {
  462. idx_type = 1; 
  463. }
  464. else
  465. {
  466. this->input->Seek(pos + this->movi_start - 4,INPUT_SEEK_SET);
  468. if(this->input->Read(mb, 8) != 8) 
  469. return 0;
  471. if( strncmp((char *) mb->GetData(), this->idx[i], 4) == 0 && str2ulong((char *) mb->GetData() + 4) == len )
  472. {
  475. idx_type = 2; 
  476. }
  477. }
  480. }
  482. if(idx_type == 0)
  483. {
  487. this->input->Seek(this->movi_start, INPUT_SEEK_SET);
  489. this->max_idx = 4096;
  490. this->n_idx   = 0;
  492. this->idx = (char((*)[16]) ) new char[this->max_idx];
  494. while(1)
  495. {
  497. if( this->input->Read(mb, 8) != 8 ) 
  498. break;
  500. n = str2ulong((char *) mb->GetData() + 4);
  504. if(strncmp((char *) mb->GetData(), "LIST", 4) == 0)
  505. {
  506. this->input->Seek(4, INPUT_SEEK_CUR);
  507. continue;
  508. }
  512. if( ((((char *) mb->GetData())[2]=='d' || ((char *) mb->GetData())[2]=='D') &&
  513.  (((char *) mb->GetData())[3]=='b' || ((char *) mb->GetData())[3]=='B' || 
  514.   ((char *) mb->GetData())[3]=='c' || ((char *) mb->GetData())[3]=='C') ) || 
  515. ((((char *) mb->GetData())[2]=='w' || ((char *) mb->GetData())[2]=='W') &&
  516.  (((char *) mb->GetData())[3]=='b' || ((char *) mb->GetData())[3]=='B') ) )
  517. {
  518. this->AddIndexEntry(((char *) mb->GetData()),
  519. 0, 
  520. this->input->Seek(0, INPUT_SEEK_CUR) - 8, 
  521. n);
  522. }
  524. this->input->Seek(PAD_EVEN(n), INPUT_SEEK_CUR);
  525. }
  527. idx_type = 1;
  528. }
  532. nvi = 0;
  533. nai = 0;
  535. for(i=0; i < this->n_idx; i++)
  536. {
  537. if(strncmp(this->idx[i], this->video_tag, 3) == 0) 
  538. nvi++;
  540. if(strncmp(this->idx[i], this->audio_tag, 4) == 0) 
  541. nai++;
  542. }
  544. this->video_frames = nvi;
  545. this->audio_chunks = nai;
  547. if(this->video_frames == 0) {
  549. mb->Free();
  550. return 0;
  551. }
  553. this->video_index = (video_index_entry *) new char[(nvi*sizeof(video_index_entry))];
  555. if(this->video_index == 0) { 
  557. mb->Free();
  558. return 0;
  559. }
  561. if(this->audio_chunks)
  562. {
  563. this->audio_index = (audio_index_entry *) new char[(nai*sizeof(audio_index_entry))];
  565. if(this->audio_index == 0) {
  567. mb->Free();
  568. return 0;
  569. }
  570. }
  572. nvi = 0;
  573. nai = 0;
  574. tot = 0;
  576. ioff = idx_type == 1 ? 8 : this->movi_start+4;
  578. for(i=0; i < this->n_idx; i++)
  579. {
  580. if(strncmp(this->idx[i], this->video_tag, 3) == 0)
  581. {
  582. this->video_index[nvi].flags = str2ulong(this->idx[i]+ 4);
  583. this->video_index[nvi].pos   = str2ulong(this->idx[i]+ 8)+ioff;
  584. this->video_index[nvi].len   = str2ulong(this->idx[i]+12);
  586. nvi++;
  587. }
  588. if(strncmp(this->idx[i], this->audio_tag, 4) == 0)
  589. {
  590. this->audio_index[nai].pos = str2ulong(this->idx[i]+ 8)+ioff;
  591. this->audio_index[nai].len = str2ulong(this->idx[i]+12);
  592. this->audio_index[nai].tot = tot;
  594. tot += this->audio_index[nai].len;
  596. nai++;
  597. }
  598. }
  600. this->audio_bytes = tot;
  604. this->input->Seek(this->movi_start, INPUT_SEEK_SET);
  606. this->video_pos = 0;
  607. mb->Free();
  609. return 1;
  610. }
  612. int MediaDecapsAVI::AddIndexEntry(char *tag, 
  613.   long flags, 
  614.   long pos, 
  615.   long len)
  616. {
  617. void *ptr;
  619. if(this->n_idx*16 >= this->max_idx)
  620. {
  621. ptr = realloc((void *)this->idx,
  622. (this->max_idx + 4096) * 16);
  624. if(ptr == 0) {
  625. return -1;
  626. }
  628. this->max_idx += 4096;
  629. this->idx = (char((*)[16]) ) ptr;
  630. }
  634. memcpy(this->idx[this->n_idx], tag, 4);
  636. long2str(this->idx[this->n_idx]+ 4, flags);
  638. long2str(this->idx[this->n_idx]+ 8, pos);
  640. long2str(this->idx[this->n_idx]+12, len);
  644. this->n_idx++;
  646. return 0;
  647. }
  649. int  MediaDecapsAVI::ReFillIndex()
  650. {
  651. unsigned long  n; 
  652. long           idx_type;
  653. long           i;
  654. long           nvi, nai, ioff;
  655. long           tot;
  656. MediaBuffer   *mb = new MediaBuffer();
  658. if(this->input == NULL)
  659. return MP_RESULT_ERROR;
  661. mb->Alloc(256);
  665. this->input->Seek(this->movi_start, INPUT_SEEK_SET);
  667. this->max_idx = 4096;
  668. this->n_idx   = 0;
  670. this->idx = (char((*)[16]) ) realloc(this->idx, this->max_idx*16);
  672. while(1)
  673. {
  675. if( this->input->Read(mb, 8) != 8 ) 
  676. break;
  678. n = str2ulong((char *) mb->GetData() + 4);
  682. if(strncmp((char *) mb->GetData(), "LIST", 4) == 0)
  683. {
  684. this->input->Seek(4, INPUT_SEEK_CUR);
  685. continue;
  686. }
  690. if( ((((char *) mb->GetData())[2]=='d' || ((char *) mb->GetData())[2]=='D') &&
  691.  (((char *) mb->GetData())[3]=='b' || ((char *) mb->GetData())[3]=='B' || 
  692.   ((char *) mb->GetData())[3]=='c' || ((char *) mb->GetData())[3]=='C') ) || 
  693. ((((char *) mb->GetData())[2]=='w' || ((char *) mb->GetData())[2]=='W') &&
  694.  (((char *) mb->GetData())[3]=='b' || ((char *) mb->GetData())[3]=='B') ) )
  695. {
  696. this->AddIndexEntry(((char *) mb->GetData()),
  697. 0, 
  698. this->input->Seek(0, INPUT_SEEK_CUR) - 8, 
  699. n);
  700. }
  702. this->input->Seek(PAD_EVEN(n), INPUT_SEEK_CUR);
  703. }
  705. idx_type = 1;
  709. nvi = 0;
  710. nai = 0;
  712. for(i=0; i < this->n_idx; i++)
  713. {
  714. if(strncmp(this->idx[i], this->video_tag, 3) == 0) 
  715. nvi++;
  717. if(strncmp(this->idx[i], this->audio_tag, 4) == 0) 
  718. nai++;
  719. }
  721. this->video_frames = nvi;
  722. this->audio_chunks = nai;
  724. if(this->video_frames == 0) 
  725. return 0;
  727. this->video_index = (video_index_entry *) realloc(this->video_index, nvi*sizeof(video_index_entry));
  729. if(this->video_index == 0) 
  730. return 0;
  732. if(this->audio_chunks)
  733. {
  734. this->audio_index = (audio_index_entry *) realloc(this->audio_index, nai*sizeof(audio_index_entry));
  736. if(this->audio_index==0) {
  737. mb->Free();
  738. return 0;
  739. }
  740. }
  742. nvi = 0;
  743. nai = 0;
  744. tot = 0;
  746. ioff = idx_type == 1 ? 8 : this->movi_start+4;
  748. for(i=0; i < this->n_idx; i++)
  749. {
  750. if(strncmp(this->idx[i], this->video_tag, 3) == 0)
  751. {
  752. this->video_index[nvi].flags = str2ulong(this->idx[i]+ 4);
  753. this->video_index[nvi].pos   = str2ulong(this->idx[i]+ 8)+ioff;
  754. this->video_index[nvi].len   = str2ulong(this->idx[i]+12);
  756. nvi++;
  757. }
  758. if(strncmp(this->idx[i], this->audio_tag, 4) == 0)
  759. {
  760. this->audio_index[nai].pos = str2ulong(this->idx[i]+ 8)+ioff;
  761. this->audio_index[nai].len = str2ulong(this->idx[i]+12);
  762. this->audio_index[nai].tot = tot;
  764. tot += this->audio_index[nai].len;
  766. nai++;
  767. }
  768. }
  770. this->audio_bytes = tot;
  771. mb->Free();
  773. return 1;
  774. }
  778. BOOL MediaDecapsAVI::isKeyframe(long frame)
  779. {
  780.   if(frame < 0 || frame > this->video_frames)
  781.     frame = 0;
  783.   if(!this->video_index)         
  784.     { 
  785.  
  787.       return 1; 
  788.     }
  790.   return this->video_index[frame].flags & AVIIF_KEYFRAME;
  791. }
  793. unsigned int  MediaDecapsAVI::GetNumberOfVideoStreams()
  794. {
  797. return 1;
  798. }
  800. unsigned int  MediaDecapsAVI::GetNumberOfAudioStreams()
  801. {
  802. if(this->audio_strn == 99)
  803. return 0;
  805. return this->audio_strn;
  806. }
  808. unsigned int  MediaDecapsAVI::GetVideoWidth(unsigned int StreamId)
  809. {
  810. return this->width;
  811. }
  813. unsigned int  MediaDecapsAVI::GetVideoHeight(unsigned int StreamId)
  814. {
  815. return this->height;
  816. }
  818. double        MediaDecapsAVI::GetVideoFrameRate(unsigned int StreamId)
  819. {
  820. if(this->fps == 0)
  821. this->fps = 25;
  823. if(this->fps == 23)
  824. this->fps = 25;
  826. return this->fps;
  827. }
  829. char  *MediaDecapsAVI::GetVideoCompression(unsigned int StreamId)
  830. {
  831. return this->compressor;
  832. }
  834. BITMAPINFOHEADER *MediaDecapsAVI::GetVideoHeader(unsigned int StreamId)
  835. {
  836. return &this->bitmapinfoheader;
  837. }
  839. unsigned long MediaDecapsAVI::GetCurrentVideoFrame(unsigned int StreamId)
  840. {
  841. return this->video_pos;
  842. }
  845. unsigned long MediaDecapsAVI::GetTotalVideoFrames(unsigned int StreamId)
  846. {
  847. return this->video_frames;
  848. }
  850. unsigned long MediaDecapsAVI::GetTotalVideoTime(unsigned int StreamId)
  851. {
  852. if(this->fps == 0) {
  854. return 0;
  855. }
  856. else {
  858. return (unsigned long) (this->video_frames * 1000 / (double) this->fps);
  859. }
  860. }
  862. unsigned int  MediaDecapsAVI::GetAudioBits(unsigned int StreamId)
  863. {
  864. return this->a_bits;
  865. }
  867. unsigned int  MediaDecapsAVI::GetAudioChannels(unsigned int StreamId)
  868. {
  869. return this->a_chans;
  870. }
  872. unsigned int  MediaDecapsAVI::GetAudioFrequency(unsigned int StreamId)
  873. {
  874. return this->a_rate;
  875. }
  877. WAVEFORMATEX *MediaDecapsAVI::GetAudioFormat(unsigned int StreamId)
  878. {
  879. return (WAVEFORMATEX *) &this->waveformatex;
  880. }
  883. unsigned int  MediaDecapsAVI::GetNextVideoFrameSize(unsigned int StreamId)
  884. {
  885. if(!this->video_index) { 
  886. return 0; 
  887. }
  889. return(this->video_index[this->video_pos].len);
  890. }
  892. unsigned int MediaDecapsAVI::ReadVideoFrame(unsigned int StreamId, MediaBuffer *mb)
  893. {
  894. unsigned int m;
  895. unsigned int n;
  900. if(!this->video_index || !mb) {
  902. return MP_RESULT_ERROR; 
  903.     }
  905. if(this->video_pos < 0 || this->video_pos >= this->video_frames - 1) {
  907. return MP_RESULT_ERROR;
  908.     }
  912. WaitForSingleObject(this->hIOMutex, INFINITE);
  914. n = this->video_index[this->video_pos].len;
  916. this->input->Seek(this->video_index[this->video_pos].pos, INPUT_SEEK_SET);
  918. if(mb->GetSize() < n) {
  920. mb->ReAlloc(n);
  921. }
  923. if ((m = this->input->Read(mb, n)) != n) {
  925. this->video_pos++;
  927.     ReleaseMutex(this->hIOMutex);
  929. char msg[256];
  930. sprintf(msg, "index %u and %u at %u", this->video_index[this->video_pos].len, this->video_index[this->video_pos].pos, this->video_pos);
  931. MessageBox(NULL, msg, "", MB_OK);
  933. sprintf(msg, "read %d on %u at %d on %d", m, n, this->video_pos, this->video_frames);
  934. MessageBox(NULL, msg, "", MB_OK);
  936. return n;
  937.     }
  939.     this->video_pos++;
  941.  
  943.     ReleaseMutex(this->hIOMutex);
  945.     return MP_RESULT_OK;
  946. }
  948. unsigned int MediaDecapsAVI::ReadAudioData(unsigned int StreamId, char *buffer, unsigned int bytes)
  949. {
  950. unsigned int nr, pos, left = 0, todo, posc, posb, asked_bytes;
  951. MediaBuffer *mbi = new MediaBuffer();
  953. if(!this->audio_index || !buffer) {
  955. return MP_RESULT_ERROR; 
  956.     }
  958. asked_bytes = bytes;
  960. posc = this->audio_posc;
  961. posb = this->audio_posb;
  963.    nr = 0; 
  964.    mbi->Alloc(bytes);
  968.    WaitForSingleObject(this->hIOMutex, INFINITE);
  972. while(bytes > 0) {
  974. left = this->audio_index[this->audio_posc].len - this->audio_posb;
  976. if(left == 0) {
  978. if(this->audio_posc >= this->audio_chunks - 1) {
  980. ReleaseMutex(this->hIOMutex);
  982. this->audio_posb = posb;
  983. this->audio_posc = posc;
  985. return 0;
  986. }
  988. this->audio_posc++;
  989. this->audio_posb = 0;
  990. continue;
  991. }
  993. if(bytes < left)
  994. todo = bytes;
  995. else
  996. todo = left;
  998. pos = this->audio_index[this->audio_posc].pos + this->audio_posb;
  999.       
  1000. this->input->Seek(pos, INPUT_SEEK_SET);
  1002.     if (this->input->Read(mbi, todo) != todo) {
  1004. ReleaseMutex(this->hIOMutex);
  1008. this->audio_posb = posb;
  1009. this->audio_posc = posc;
  1011. return 0;
  1012. }
  1014. memcpy(buffer + nr, mbi->GetData(), todo);
  1016. bytes -= todo;
  1017. nr    += todo;
  1019. this->audio_posb += todo;
  1020. }
  1022. mbi->Free();
  1023. delete mbi;
  1027.     ReleaseMutex(this->hIOMutex);
  1029.     return asked_bytes;
  1030. }
  1032. MP_RESULT     MediaDecapsAVI::UpdateForSize()
  1033. {
  1034. this->ReFillIndex();
  1036. return MP_RESULT_OK;
  1037. }
  1039. MP_RESULT     MediaDecapsAVI::SeekAudio(unsigned int StreamId, long bytes)
  1040. {
  1041.    long n0, n1, n;
  1043.    if(!this->audio_index) { 
  1044.        return MP_RESULT_ERROR; 
  1045.    }
  1047.    if(bytes < 0) 
  1048.    bytes = 0;
  1050.    n0 = 0;
  1051.    n1 = this->audio_chunks;
  1053.    while(n0 < n1 - 1)
  1054.    {
  1055.       n = (n0 + n1) / 2;
  1056.       if(this->audio_index[n].tot > bytes)
  1057.          n1 = n;
  1058.       else
  1059.          n0 = n;
  1060.    }
  1062.    this->audio_posc = n0;
  1064.    if(this->audio_index[n0].len > 1000) {
  1065.  this->audio_posb = bytes - this->audio_index[n0].tot;
  1066.    }
  1067.    else {
  1068.      this->audio_posb = 0;
  1069.    }
  1071.    return MP_RESULT_OK;
  1072. }
  1074. MP_RESULT     MediaDecapsAVI::SeekVideo(unsigned int StreamId, long frame)
  1075. {
  1076. if(!this->video_index) {
  1078. return MP_RESULT_ERROR; 
  1079.     }
  1081. if (frame < 0 ) {
  1083. frame = 0;
  1084. }
  1086.    this->video_pos = frame;
  1088.    return MP_RESULT_OK;
  1089. }
  1091. MP_RESULT     MediaDecapsAVI::ReSeekAudio(unsigned int StreamId)
  1092. {
  1093. double ratio;
  1094. long audio_bytes;
  1096.     if(this->GetNumberOfAudioStreams() > 0) {
  1098.   WaitForSingleObject(this->hIOMutex, INFINITE);
  1100.       ratio = (double) ((double) this->video_pos / (double) this->video_frames);
  1101.       
  1104.       audio_bytes  = (long) (ratio * this->audio_bytes);
  1105.       audio_bytes  -= (audio_bytes % this->waveformatex.nBlockSize);
  1107.       this->SeekAudio(StreamId, audio_bytes);
  1109.       ReleaseMutex(this->hIOMutex);
  1110. }
  1112.     return MP_RESULT_OK;
  1113. }
  1115. MP_RESULT     MediaDecapsAVI::Seek(unsigned int videoStreamId, unsigned int audioStreamId, int percent)
  1116. {
  1117. long frame;
  1118. double ratio;
  1119. long audio_bytes;
  1120.   
  1121. WaitForSingleObject(this->hIOMutex, INFINITE);
  1125.     frame = (long) (percent * this->video_frames / 100);
  1127.  
  1128.   
  1129.     while(!this->isKeyframe(frame) && frame < this->video_frames) {
  1130.       frame++;
  1131.     }
  1134. if(frame >= this->video_frames)
  1135. frame = 0;
  1138.     
  1139. this->SeekVideo(videoStreamId, frame);
  1142.     if(this->GetNumberOfAudioStreams() > 0) {
  1143.       
  1144.       ratio = (double) ((double) frame / (double) this->video_frames);
  1145.       
  1146.  
  1148.       audio_bytes  = (long) (ratio * this->audio_bytes);
  1149.       audio_bytes  -= (audio_bytes % this->waveformatex.nBlockSize);
  1151.       this->SeekAudio(audioStreamId, audio_bytes);
  1153.       ReleaseMutex(this->hIOMutex);
  1155.       return MP_RESULT_OK;
  1156. }
  1158.     ReleaseMutex(this->hIOMutex);
  1160. return MP_RESULT_OK;
  1161. }
  1163. MP_RESULT     MediaDecapsAVI::Rewind(unsigned int videoStreamId, unsigned int audioStreamId)
  1164. {
  1165. this->video_pos  = 0;
  1166. this->audio_posc = 0;
  1167. this->audio_posb = 0;
  1169. return MP_RESULT_OK;
  1170. }
  1172. MP_RESULT     MediaDecapsAVI::SeekNextKeyFrame(unsigned int StreamId)
  1173. {
  1174. WaitForSingleObject(this->hIOMutex, INFINITE);
  1178. this->video_pos++;
  1180. while(!isKeyframe(this->video_pos) && this->video_pos < this->video_frames)
  1181. this->video_pos++;
  1183.     ReleaseMutex(this->hIOMutex);
  1185. return MP_RESULT_OK;
  1186. }
  1188. MP_RESULT     MediaDecapsAVI::SeekPreviousKeyFrame(unsigned int StreamId)
  1189. {
  1190. WaitForSingleObject(this->hIOMutex, INFINITE);
  1194. if(this->video_pos > 1) {
  1196. this->video_pos--;
  1197. this->video_pos--;
  1198. }
  1200. while(!isKeyframe(this->video_pos) && this->video_pos > 0)
  1201. this->video_pos--;
  1203.     ReleaseMutex(this->hIOMutex);
  1205. return MP_RESULT_OK;
  1206. }