]> git.vomp.tv Git - vompclient-marten.git/blob - dssourcepin.cc
Windows HDTV
[vompclient-marten.git] / dssourcepin.cc
1 /*
2     Copyright 2004-2005 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "dssourcefilter.h"
22 #include <Dvdmedia.h>
23 #include <mmreg.h>
24 #include "draintarget.h"
25 #include "demuxeraudio.h"
26
27 EXTERN_C const GUID DECLSPEC_SELECTANY MEDIATYPE_WaveFmt_Mpeg1Layer3=
28 {WAVE_FORMAT_MPEGLAYER3,
29 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71};
30
31 #include "dssourcepin.h"
32
33
34
35 class DsSFEnumMediaTypes: public IEnumMediaTypes {
36 public:
37   DsSFEnumMediaTypes(DsSourcePin* papa,ULONG pos=0);
38   virtual ~DsSFEnumMediaTypes();
39   virtual HRESULT STDMETHODCALLTYPE Next(ULONG nummedia,  AM_MEDIA_TYPE **pins,ULONG *fetched);
40   virtual HRESULT STDMETHODCALLTYPE Skip(ULONG numpin);
41   virtual HRESULT STDMETHODCALLTYPE Reset();
42   virtual HRESULT STDMETHODCALLTYPE Clone(IEnumMediaTypes **enuma);
43   virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id,void ** object);
44   virtual ULONG STDMETHODCALLTYPE AddRef();
45     virtual ULONG STDMETHODCALLTYPE Release();
46 protected:
47   DsSourcePin* parent;
48   ULONG curpos;
49   volatile long refs;
50 };
51
52 DsSFEnumMediaTypes::DsSFEnumMediaTypes(DsSourcePin* papa,ULONG pos){
53   parent=papa;
54   curpos=pos;
55   parent->AddRef();
56   refs=0;
57 }
58
59 DsSFEnumMediaTypes::~DsSFEnumMediaTypes(){
60   parent->Release();
61 }
62
63 HRESULT STDMETHODCALLTYPE DsSFEnumMediaTypes::Next(ULONG numpin, AM_MEDIA_TYPE **pins,ULONG *fetched) {
64   int i;
65
66   if (pins==NULL) return E_POINTER;
67   if (numpin!=1 && fetched==NULL) return E_INVALIDARG;
68   *fetched=0;
69
70   for (i=0;(i<numpin);i++) {
71     pins[i]=(AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
72         if (parent->GetMediaType(curpos+i,pins[i])!=S_OK) {
73                 CoTaskMemFree(pins[i]);
74                 pins[i]=NULL;
75                 return S_FALSE;
76         }    curpos++;
77     if (fetched!=NULL)  (*fetched)++;
78   }
79   return S_OK;
80 }
81
82 HRESULT STDMETHODCALLTYPE   DsSFEnumMediaTypes::Skip(ULONG numpin){
83   curpos+=numpin;
84   if (curpos>1) return S_FALSE;
85   return S_OK;
86 }
87 HRESULT STDMETHODCALLTYPE DsSFEnumMediaTypes::Reset(){
88   curpos=0;
89   return S_OK;
90 }
91 HRESULT STDMETHODCALLTYPE DsSFEnumMediaTypes::Clone(IEnumMediaTypes **enuma){
92   if (enuma==NULL) return E_POINTER;
93   *enuma=new DsSFEnumMediaTypes(parent,curpos);
94   (*enuma)->AddRef();
95   return S_OK;
96 }
97
98 HRESULT STDMETHODCALLTYPE  DsSFEnumMediaTypes::QueryInterface(REFIID id,void ** object){
99   if (object==NULL) return E_POINTER;
100   if (id==IID_IUnknown ||id == IID_IEnumMediaTypes) {
101     *object=(IUnknown*)this;
102     ((IUnknown*)object)->AddRef();
103     return NOERROR;
104   } else {
105     *object=NULL;
106     return E_NOINTERFACE;
107   }
108 }
109
110
111
112 ULONG STDMETHODCALLTYPE DsSFEnumMediaTypes::AddRef(){
113   InterlockedIncrement(&refs);
114   long tempref=refs;
115   if (tempref>1) return tempref;
116   else return 1;
117 }
118
119 ULONG STDMETHODCALLTYPE DsSFEnumMediaTypes::Release(){
120   long tempref=InterlockedDecrement(&refs);
121
122   if (tempref==0) {
123     refs++;
124     delete this;
125     return NULL;
126   } else {
127     if (tempref>1) return tempref;
128     else return 1;
129   }
130 }
131
132
133 void CopyMType(AM_MEDIA_TYPE* dest,const AM_MEDIA_TYPE*source) {
134   memcpy(dest,source,sizeof(AM_MEDIA_TYPE));
135   if (source->pbFormat!=NULL) {
136     dest->pbFormat=(BYTE*)CoTaskMemAlloc(dest->cbFormat);
137     memcpy(dest->pbFormat,source->pbFormat,dest->cbFormat);
138   } else {
139           dest->pbFormat=NULL;
140   }
141 }
142 void ReleaseMType(AM_MEDIA_TYPE* free) {
143   if (free->cbFormat!=NULL) CoTaskMemFree(free->pbFormat);
144   free->pbFormat=NULL;
145 }
146
147 DsSourcePin::DsSourcePin(DsSourceFilter *pFilter,
148              HRESULT *phr,LPCWSTR pName,bool audio)
149 {
150   medtype.pbFormat=NULL;
151   isaudiopin=audio;
152   m_pFilter=pFilter;
153   connected=NULL;
154   connectedinput=NULL;
155   allocator=NULL;
156
157   v_width=640;
158   v_height=480;
159   
160   if (isaudiopin)
161   {
162       pinmode=MPTYPE_MPEG_AUDIO;
163       //pinmode=MPTYPE_AC3;
164   }
165   else
166   {
167         
168         pinmode=MPTYPE_VIDEO_MPEG2;
169   }
170
171 }
172
173 DsSourcePin::~DsSourcePin()
174 {
175
176
177
178 }
179
180 HRESULT STDMETHODCALLTYPE DsSourcePin::QueryInterface(REFIID id,void ** object){
181   if (object==NULL) return E_POINTER;
182   if (id==IID_IUnknown) {
183     *object=(IUnknown*)this;
184     ((IUnknown*)object)->AddRef();
185     return NOERROR;
186   } else if (id==IID_IPin) {
187     *object=(IPin*)this;
188     ((IPin*)object)->AddRef();
189     return NOERROR;
190   } else {
191     *object=NULL;
192     return E_NOINTERFACE;
193   }
194 }
195
196 ULONG STDMETHODCALLTYPE DsSourcePin::AddRef(){
197   return m_pFilter->AddRef();
198
199 }
200 ULONG STDMETHODCALLTYPE DsSourcePin::Release(){
201   return m_pFilter->Release();
202 }
203
204
205 /*IPin*/
206 HRESULT STDMETHODCALLTYPE DsSourcePin::Connect(IPin *pinempf,const AM_MEDIA_TYPE *mtype) {
207   if (pinempf==NULL) return E_POINTER;
208   EnterCriticalSection(&m_pFilter->filterlock);
209
210   if (connected!=NULL) {LeaveCriticalSection(&m_pFilter->filterlock);return VFW_E_ALREADY_CONNECTED;}
211   if (m_pFilter->mystate!=State_Stopped) {LeaveCriticalSection(&m_pFilter->filterlock);return VFW_E_NOT_STOPPED;}
212
213   bool gotmt=false;
214
215   if (mtype!=NULL) {
216     if (CheckMediaType(mtype)==S_OK){
217       pinempf->AddRef();
218       if (pinempf->ReceiveConnection((IPin*)this,mtype)==S_OK) {
219         CopyMType(&medtype,mtype);
220         LeaveCriticalSection(&m_pFilter->filterlock);
221       } else {
222         LeaveCriticalSection(&m_pFilter->filterlock);
223   if (mtype->pbFormat!=NULL) CoTaskMemFree(mtype->pbFormat);
224         pinempf->Release();
225         return VFW_E_TYPE_NOT_ACCEPTED;
226       }
227
228     } else {
229       LeaveCriticalSection(&m_pFilter->filterlock);
230  if (mtype->pbFormat!=NULL) CoTaskMemFree(mtype->pbFormat);
231       return VFW_E_TYPE_NOT_ACCEPTED;
232     }
233     CoTaskMemFree(mtype->pbFormat);
234   }else {
235     IEnumMediaTypes * emt;
236     EnumMediaTypes(&emt);
237     AM_MEDIA_TYPE  * emtype;
238     ULONG fetched=0;
239     pinempf->AddRef();
240         
241
242     while (emt->Next(1,&emtype,&fetched)==S_OK) {
243       if (CheckMediaType(emtype)==S_OK){
244         /*      PIN_INFO pini;
245                 pinempf->QueryPinInfo(&pini);
246                 if (pini.pFilter!=NULL) {
247                         FILTER_INFO filti;
248                         pini.pFilter->QueryFilterInfo(&filti);
249
250                         if (filti.pGraph!=NULL) filti.pGraph->Release();
251                         char buffer[MAX_FILTER_NAME*2];
252                         wcstombs(buffer,filti.achName,MAX_FILTER_NAME*2);
253                         MessageBox(0,buffer,"Filter",0);
254                         pini.pFilter->Release();
255                 }*/
256
257         if (pinempf->ReceiveConnection((IPin*)this,emtype)==S_OK) {
258           connected=pinempf;
259           CopyMType(&medtype,emtype);
260                   if (emtype->pbFormat!=NULL) CoTaskMemFree(emtype->pbFormat);
261                  
262                   CoTaskMemFree(emtype);
263           gotmt=true;
264           break;
265         }
266
267       }
268  if (emtype->pbFormat!=NULL) CoTaskMemFree(emtype->pbFormat);
269           CoTaskMemFree(emtype);
270     }
271     emt->Release();
272     if (gotmt==false) {
273       pinempf->EnumMediaTypes(&emt);
274       while (emt->Next(1,&emtype,&fetched)==S_OK) {
275         if (CheckMediaType(emtype)==S_OK){
276           if (pinempf->ReceiveConnection((IPin*)this,emtype)==S_OK) {
277             connected=pinempf;
278             CopyMType(&medtype,emtype);
279             if (emtype->pbFormat!=NULL) CoTaskMemFree(emtype->pbFormat);
280                                                 CoTaskMemFree(emtype);
281             gotmt=true;
282             break;
283           }
284
285         }
286         if (emtype->pbFormat!=NULL) CoTaskMemFree(emtype->pbFormat);
287                 CoTaskMemFree(emtype);
288       }
289       emt->Release();
290       if (gotmt==false) {
291         pinempf->Release();
292         LeaveCriticalSection(&m_pFilter->filterlock);
293         return VFW_E_NO_ACCEPTABLE_TYPES;
294       }
295     }
296   }
297
298   if (pinempf->QueryInterface(IID_IMemInputPin,(void**)&connectedinput)!=S_OK) {
299     LeaveCriticalSection(&m_pFilter->filterlock);
300     connected->Release();
301     connected=NULL;
302   /*  connectedinput->Release();
303     connectedinput=NULL;*/
304     return VFW_E_NO_TRANSPORT;
305   }
306   ALLOCATOR_PROPERTIES eigenall;
307   ZeroMemory(&eigenall,sizeof(eigenall));
308   connectedinput->GetAllocatorRequirements(&eigenall);
309   if (eigenall.cbAlign==0) eigenall.cbAlign=1;
310   connectedinput->GetAllocator(&allocator);
311   if (DecideBufferSize(allocator,&eigenall)==S_OK) {
312     if (connectedinput->NotifyAllocator(allocator,FALSE)==S_OK){
313       connected=pinempf;
314       LeaveCriticalSection(&m_pFilter->filterlock);
315       return S_OK;
316     }
317   }
318   if (allocator!=NULL) allocator->Release();
319   allocator=NULL;
320
321   if (CoCreateInstance(CLSID_MemoryAllocator,0,CLSCTX_INPROC_SERVER,
322     IID_IMemAllocator,(void **)allocator)==S_OK) {
323       if (DecideBufferSize(allocator,&eigenall)==S_OK) {
324         if (connectedinput->NotifyAllocator(allocator,FALSE)==S_OK){
325           connected=pinempf;
326           LeaveCriticalSection(&m_pFilter->filterlock);
327         return S_OK;
328       }
329     }
330   }
331   if (allocator!=NULL) allocator->Release();
332   allocator=NULL;
333   connected->Release();
334   connected=NULL;
335   connectedinput->Release();
336   connectedinput=NULL;
337   LeaveCriticalSection(&m_pFilter->filterlock);
338   return VFW_E_NO_TRANSPORT;
339
340
341
342
343 }
344 HRESULT STDMETHODCALLTYPE DsSourcePin::ReceiveConnection(IPin *connect,
345                              const AM_MEDIA_TYPE *mtype){
346      return VFW_E_TYPE_NOT_ACCEPTED; //We have only output pins
347 }
348  HRESULT STDMETHODCALLTYPE DsSourcePin::Disconnect() {
349    EnterCriticalSection(&m_pFilter->filterlock);
350    if (connected!=NULL) {
351      if (m_pFilter->mystate!=State_Stopped) {LeaveCriticalSection(&m_pFilter->filterlock);return VFW_E_NOT_STOPPED;}
352      /*TODO: Decommit allocator*/
353      allocator->Decommit();
354      allocator->Release();
355      allocator=NULL;
356      ReleaseMType(&medtype);
357      connectedinput->Release();
358      connectedinput=NULL;
359      connected->Release();
360      connected=NULL;
361      LeaveCriticalSection(&m_pFilter->filterlock);
362      return S_OK;
363    }
364    LeaveCriticalSection(&m_pFilter->filterlock);
365    return S_FALSE;
366  }
367
368  HRESULT STDMETHODCALLTYPE DsSourcePin::ConnectedTo(IPin **pin){
369    if (pin==NULL) return E_POINTER;
370    IPin* pinn=connected;
371    *pin=pinn;
372    if (pinn!=NULL) {
373      pinn->AddRef();
374      return S_OK;
375    } else {
376      return VFW_E_NOT_CONNECTED;
377    }
378  }
379  HRESULT STDMETHODCALLTYPE  DsSourcePin::ConnectionMediaType(AM_MEDIA_TYPE *mtype){
380    if (mtype==NULL) return E_POINTER;
381    if (connected!=NULL){
382     CopyMType(mtype,&medtype);
383     return S_OK;
384    } else {
385      ZeroMemory(mtype,sizeof(*mtype));
386      return VFW_E_NOT_CONNECTED;
387    }
388  }
389  HRESULT STDMETHODCALLTYPE DsSourcePin::QueryPinInfo(PIN_INFO *info){
390    if (info==NULL) return E_POINTER;
391    info->dir=PINDIR_OUTPUT;
392    info->pFilter=(IBaseFilter*)m_pFilter;
393    if (m_pFilter) m_pFilter->AddRef();
394    if (isaudiopin) wcscpy(info->achName,L"Audio");
395    else wcscpy(info->achName,L"Video");
396    return S_OK;
397  }
398
399  HRESULT STDMETHODCALLTYPE  DsSourcePin::QueryDirection(PIN_DIRECTION *dir){
400    if (dir==NULL) return E_POINTER;
401    *dir=PINDIR_OUTPUT;
402    return S_OK;
403  }
404  HRESULT STDMETHODCALLTYPE DsSourcePin::QueryId(LPWSTR *id){
405    if (id==NULL) return E_POINTER;
406    *id=(LPWSTR)CoTaskMemAlloc(12);
407    if (*id==NULL) return E_OUTOFMEMORY;
408
409
410    if (isaudiopin) wcscpy(*id,L"Audio");
411     else  wcscpy(*id, L"Video");
412     return S_OK;
413  }
414  HRESULT STDMETHODCALLTYPE  DsSourcePin::QueryAccept(const AM_MEDIA_TYPE *mtype) {
415    if (mtype==NULL) return S_FALSE;
416    if (CheckMediaType(mtype)==S_OK) return S_OK;
417    else return S_FALSE;
418  }
419  HRESULT STDMETHODCALLTYPE DsSourcePin::EnumMediaTypes(IEnumMediaTypes **enuma){
420 if (enuma==NULL) return E_POINTER;
421   *enuma=new DsSFEnumMediaTypes( this);
422   (*enuma)->AddRef();
423   return S_OK;
424 }
425
426 HRESULT STDMETHODCALLTYPE DsSourcePin::QueryInternalConnections(IPin **pin,ULONG *numpin){
427   return E_NOTIMPL;
428 }
429 HRESULT STDMETHODCALLTYPE DsSourcePin::EndOfStream(){
430   return E_UNEXPECTED; //we are a output pin!
431 }
432
433 HRESULT STDMETHODCALLTYPE DsSourcePin::NewSegment(REFERENCE_TIME start,REFERENCE_TIME stop,double rate){
434   return E_UNEXPECTED;//we are a output pin!
435 }
436
437 HRESULT DsSourcePin::getCurrentMediaSample(IMediaSample**ms){
438         if (allocator!=NULL) {
439                 return allocator->GetBuffer(ms,NULL,NULL,0);
440         }
441   else return E_NOINTERFACE;
442 }
443
444 HRESULT DsSourcePin::deliver(IMediaSample * ms){
445   //EnterCriticalSection(&m_pFilter->filterlock);
446   HRESULT hres;
447
448
449   if (connectedinput!=NULL)hres= connectedinput->Receive(ms);
450   else hres= VFW_E_NOT_CONNECTED;
451   //LeaveCriticalSection(&m_pFilter->filterlock);
452   return hres;
453
454 }
455
456 void DsSourcePin::SetMsToMt(IMediaSample *ms) {
457     ms->SetMediaType(&medtype);
458 }
459
460 bool DsSourcePin::supportsAc3() {
461     if (!isaudiopin)
462     {
463         return false; //Haha a video pin that supports ac3
464     }
465     if (!IsConnected())
466     {
467         return false; //Graph is not build, please wait
468     }
469     if (connected==NULL) 
470     {
471         return false; //Graph is not build, please wait
472     }
473     IPinConnection *pinconn=NULL; //according to docs, this is the prefered method
474     if (connected->QueryInterface(IID_IPinConnection,(void**)&pinconn)==S_OK) {
475         AM_MEDIA_TYPE test;
476         GetMediaType(10,&test);
477         if (pinconn->DynamicQueryAccept(&test)==S_OK)
478         {
479             pinconn->Release();
480             CoTaskMemFree(test.pbFormat);
481             return true;
482         } else {
483             pinconn->Release();
484             CoTaskMemFree(test.pbFormat);
485             return false;
486         }
487     }
488     AM_MEDIA_TYPE test;
489     GetMediaTypeAc3(0,&test);
490     if (connected->QueryAccept(&test)==S_OK)
491     {
492         CoTaskMemFree(test.pbFormat);
493         return true;
494     } 
495     CoTaskMemFree(test.pbFormat);
496     return false;
497
498 }
499
500 HRESULT DsSourcePin::GetMediaTypeMp3Audio(int iPosition, AM_MEDIA_TYPE *pmt)
501 {
502   HRESULT hr;
503   switch (iPosition) 
504   {
505       /*  case 0: {
506                 ZeroMemory(pmt,sizeof(*pmt));
507                 pmt->lSampleSize = 1;
508                 pmt->bFixedSizeSamples = TRUE;
509                 pmt->majortype=MEDIATYPE_Audio;
510                 MPEG1WAVEFORMAT wfe;
511                 ZeroMemory(&wfe,sizeof(wfe));
512                 wfe.wfx.cbSize=22;
513                 wfe.wfx.nSamplesPerSec=48000;
514                 wfe.wfx.nChannels=2;
515                 wfe.wfx.nAvgBytesPerSec=32000;
516                 wfe.wfx.nBlockAlign=768;
517                 wfe.wfx.wFormatTag=WAVE_FORMAT_MPEG;
518                 wfe.wfx.wBitsPerSample=0;
519                 wfe.fwHeadLayer=2;
520                 wfe.dwHeadBitrate=256000;
521                 wfe.fwHeadMode=ACM_MPEG_STEREO;
522                 wfe.fwHeadModeExt=1;
523                 wfe.wHeadEmphasis=1;
524                 wfe.fwHeadFlags=ACM_MPEG_ID_MPEG1 |ACM_MPEG_ORIGINALHOME | ACM_MPEG_PROTECTIONBIT;
525                 pmt->subtype=MEDIASUBTYPE_MPEG2_AUDIO;
526                 pmt->formattype=FORMAT_WaveFormatEx;
527                 pmt->cbFormat=sizeof(wfe);
528                 pmt->pbFormat=(BYTE*)CoTaskMemAlloc(sizeof(wfe));
529                 memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
530                 pmt->lSampleSize=0;
531                 hr=S_OK;
532                           } break;*/
533  /*  case 0: //MPEG2_AUDIO
534        {
535            ZeroMemory(pmt,sizeof(*pmt));
536            pmt->lSampleSize = 1;
537            pmt->bFixedSizeSamples = TRUE;
538            pmt->majortype = MEDIATYPE_Audio;
539            WAVEFORMATEX wfe;
540            ZeroMemory(&wfe,sizeof(wfe));
541            wfe.cbSize = 22;
542            wfe.nSamplesPerSec = 48000;
543            wfe.nChannels = 2;
544            wfe.nAvgBytesPerSec = 0;//32000;
545            wfe.nBlockAlign = 0;//768;
546            wfe.wFormatTag = WAVE_FORMAT_UNKNOWN;
547            wfe.wBitsPerSample = 0;
548            pmt->subtype = MEDIASUBTYPE_MPEG2_AUDIO;
549                    pmt->formattype = FORMAT_WaveFormatEx;
550                    pmt->cbFormat = sizeof(wfe);
551                    pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(wfe));
552                    memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
553                    pmt->lSampleSize=0;
554                    hr=S_OK;
555        } break;*/
556    case 0: {//Mpeg1
557        ZeroMemory(pmt,sizeof(*pmt));
558            pmt->lSampleSize = 1;
559            pmt->bFixedSizeSamples = TRUE;
560            pmt->majortype = MEDIATYPE_Audio;
561            MPEGLAYER3WAVEFORMAT wfe;
562            ZeroMemory(&wfe,sizeof(wfe));
563            wfe.wfx.cbSize = MPEGLAYER3_WFX_EXTRA_BYTES;
564            wfe.wfx.nSamplesPerSec =44100; //For the Fraunhofer decoder
565            wfe.wfx.nChannels = 2;
566            //wfe.wfx.nAvgBytesPerSec = 32000;
567        wfe.wfx.nAvgBytesPerSec = 0;//128*(1024/8);
568            wfe.wfx.nBlockAlign = 1;
569            wfe.wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3;
570        wfe.wfx.wBitsPerSample = 0;
571        wfe.wID=MPEGLAYER3_ID_MPEG;
572        wfe.nCodecDelay=1393;
573        wfe.nBlockSize=522;
574        wfe.nFramesPerBlock=1;
575            pmt->subtype=MEDIATYPE_WaveFmt_Mpeg1Layer3;
576        
577           
578            pmt->formattype=FORMAT_WaveFormatEx;
579            pmt->cbFormat=sizeof(wfe);
580            pmt->pbFormat=(BYTE*)CoTaskMemAlloc(sizeof(wfe));
581            memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
582            pmt->lSampleSize=0;
583            hr=S_OK;
584            } break; 
585        case 1: //MPEG2_AUDIO, this more less not right but works on some filters
586        {
587            ZeroMemory(pmt,sizeof(*pmt));
588            pmt->lSampleSize = 1;
589            pmt->bFixedSizeSamples = TRUE;
590            pmt->majortype = MEDIATYPE_Audio;
591            WAVEFORMATEX wfe;
592            ZeroMemory(&wfe,sizeof(wfe));
593            wfe.cbSize = 22;
594            wfe.nSamplesPerSec = 48000;
595            wfe.nChannels = 2;
596            wfe.nAvgBytesPerSec = 0;//32000;
597            wfe.nBlockAlign = 0;//768;
598            wfe.wFormatTag = WAVE_FORMAT_UNKNOWN;
599            wfe.wBitsPerSample = 0;
600            pmt->subtype = MEDIASUBTYPE_MPEG2_AUDIO;
601                    pmt->formattype = FORMAT_WaveFormatEx;
602                    pmt->cbFormat = sizeof(wfe);
603                    pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(wfe));
604                    memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
605                    pmt->lSampleSize=0;
606                    hr=S_OK;
607        } break;
608           default: {
609                   hr=VFW_S_NO_MORE_ITEMS;
610           }break;
611   };
612   return hr ;
613 }
614
615
616 HRESULT DsSourcePin::GetMediaTypeMpegAudio(int iPosition, AM_MEDIA_TYPE *pmt)
617 {
618   HRESULT hr;
619   switch (iPosition) 
620   {
621       /*  case 0: {
622                 ZeroMemory(pmt,sizeof(*pmt));
623                 pmt->lSampleSize = 1;
624                 pmt->bFixedSizeSamples = TRUE;
625                 pmt->majortype=MEDIATYPE_Audio;
626                 MPEG1WAVEFORMAT wfe;
627                 ZeroMemory(&wfe,sizeof(wfe));
628                 wfe.wfx.cbSize=22;
629                 wfe.wfx.nSamplesPerSec=48000;
630                 wfe.wfx.nChannels=2;
631                 wfe.wfx.nAvgBytesPerSec=32000;
632                 wfe.wfx.nBlockAlign=768;
633                 wfe.wfx.wFormatTag=WAVE_FORMAT_MPEG;
634                 wfe.wfx.wBitsPerSample=0;
635                 wfe.fwHeadLayer=2;
636                 wfe.dwHeadBitrate=256000;
637                 wfe.fwHeadMode=ACM_MPEG_STEREO;
638                 wfe.fwHeadModeExt=1;
639                 wfe.wHeadEmphasis=1;
640                 wfe.fwHeadFlags=ACM_MPEG_ID_MPEG1 |ACM_MPEG_ORIGINALHOME | ACM_MPEG_PROTECTIONBIT;
641                 pmt->subtype=MEDIASUBTYPE_MPEG2_AUDIO;
642                 pmt->formattype=FORMAT_WaveFormatEx;
643                 pmt->cbFormat=sizeof(wfe);
644                 pmt->pbFormat=(BYTE*)CoTaskMemAlloc(sizeof(wfe));
645                 memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
646                 pmt->lSampleSize=0;
647                 hr=S_OK;
648                           } break;*/
649    case 0: //MPEG2_AUDIO
650        {
651            ZeroMemory(pmt,sizeof(*pmt));
652            pmt->lSampleSize = 1;
653            pmt->bFixedSizeSamples = TRUE;
654            pmt->majortype = MEDIATYPE_Audio;
655            WAVEFORMATEX wfe;
656            ZeroMemory(&wfe,sizeof(wfe));
657            wfe.cbSize = 22;
658            wfe.nSamplesPerSec = 48000;
659            wfe.nChannels = 2;
660            wfe.nAvgBytesPerSec = 0;//32000;
661            wfe.nBlockAlign = 0;//768;
662            wfe.wFormatTag = WAVE_FORMAT_UNKNOWN;
663            wfe.wBitsPerSample = 0;
664            pmt->subtype = MEDIASUBTYPE_MPEG2_AUDIO;
665                    pmt->formattype = FORMAT_WaveFormatEx;
666                    pmt->cbFormat = sizeof(wfe);
667                    pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(wfe));
668                    memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
669                    pmt->lSampleSize=0;
670                    hr=S_OK;
671        } break;
672    case 1: {//Mpeg1
673        ZeroMemory(pmt,sizeof(*pmt));
674            pmt->lSampleSize = 1;
675            pmt->bFixedSizeSamples = TRUE;
676            pmt->majortype = MEDIATYPE_Audio;
677            MPEG1WAVEFORMAT wfe;
678            ZeroMemory(&wfe,sizeof(wfe));
679            wfe.wfx.cbSize = 22;
680            wfe.wfx.nSamplesPerSec = 48000;
681            wfe.wfx.nChannels = 2;
682            //wfe.wfx.nAvgBytesPerSec = 32000;
683        wfe.wfx.nAvgBytesPerSec = 0;
684            //wfe.wfx.nBlockAlign = 768;
685            wfe.wfx.wFormatTag = WAVE_FORMAT_UNKNOWN;
686        wfe.wfx.wBitsPerSample = 0;
687         /* wfe.fwHeadLayer=2;
688            wfe.dwHeadBitrate=256000;
689            wfe.fwHeadMode=ACM_MPEG_STEREO;
690            wfe.fwHeadModeExt=1;
691            wfe.wHeadEmphasis=1;
692        wfe.fwHeadFlags=ACM_MPEG_ID_MPEG1 |ACM_MPEG_ORIGINALHOME | ACM_MPEG_PROTECTIONBIT;*/
693            pmt->subtype=MEDIASUBTYPE_MPEG1Payload;
694            pmt->formattype=FORMAT_WaveFormatEx;
695            pmt->cbFormat=sizeof(wfe);
696            pmt->pbFormat=(BYTE*)CoTaskMemAlloc(sizeof(wfe));
697            memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
698            pmt->lSampleSize=0;
699            hr=S_OK;
700            } break;    
701           default: {
702                   hr=VFW_S_NO_MORE_ITEMS;
703           }break;
704   };
705   return hr ;
706 }
707
708 HRESULT DsSourcePin::GetMediaTypeAc3(int iPosition, AM_MEDIA_TYPE *pmt)
709 {
710   HRESULT hr;
711   switch (iPosition)
712   {
713    case 0:
714       { //AC3 for future use
715           ZeroMemory(pmt,sizeof(*pmt));
716           pmt->lSampleSize = 1;
717           pmt->bFixedSizeSamples = TRUE;
718           pmt->majortype = MEDIATYPE_Audio;
719           WAVEFORMATEX wfe;
720           ZeroMemory(&wfe,sizeof(wfe));
721           wfe.cbSize = 22;
722           wfe.nSamplesPerSec = 48000;
723                   wfe.nChannels = 2;
724                   wfe.nAvgBytesPerSec = 32000;
725                   wfe.nBlockAlign = 768;
726                   wfe.wFormatTag = WAVE_FORMAT_UNKNOWN;
727                   wfe.wBitsPerSample = 0;
728                   pmt->subtype = MEDIASUBTYPE_DOLBY_AC3;
729         //  pmt->subtype = MEDIASUBTYPE_DOLBY_AC3_SPDIF;
730                   pmt->formattype = FORMAT_WaveFormatEx;
731                   pmt->cbFormat = sizeof(wfe);
732                   pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(wfe));
733                   memcpy(pmt->pbFormat,&wfe,sizeof(wfe));
734                   pmt->lSampleSize = 0;
735                   hr = S_OK;
736       } break;
737   default: {
738       hr=VFW_S_NO_MORE_ITEMS;
739            }break;
740   };
741   return hr ;
742 }
743
744 HRESULT DsSourcePin::GetMediaTypeMpegVideo(int iPosition, AM_MEDIA_TYPE *pmt)
745 {
746   HRESULT hr;
747   if (iPosition == 0)
748   {
749       ZeroMemory(pmt,sizeof(*pmt));
750       pmt->lSampleSize = 1;
751       pmt->bFixedSizeSamples = TRUE;
752       pmt->majortype = MEDIATYPE_Video;
753       hr = S_OK;
754       pmt->subtype = MEDIASUBTYPE_MPEG2_VIDEO;
755       pmt->formattype = FORMAT_MPEG2Video;
756       MPEG2VIDEOINFO hdr;
757       ZeroMemory(&hdr,sizeof(hdr));
758       hdr.dwProfile = AM_MPEG2Profile_Main;
759       hdr.dwLevel = AM_MPEG2Level_Main;
760       hdr.hdr.bmiHeader.biSize = sizeof(hdr.hdr.bmiHeader);
761       hdr.hdr.bmiHeader.biWidth = v_width;
762       hdr.hdr.bmiHeader.biHeight = v_height;
763           /* Vista compat*/
764       hdr.hdr.dwPictAspectRatioX=1;//v_sar_width; 
765           hdr.hdr.dwPictAspectRatioY=1;//v_sar_height;
766           /* Vista compat*/
767       pmt->cbFormat = sizeof(hdr);
768       pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(hdr));
769       memcpy(pmt->pbFormat,&hdr,sizeof(hdr));
770   } else {
771       hr=VFW_S_NO_MORE_ITEMS;
772   }
773
774   return hr;
775 }
776
777 HRESULT DsSourcePin::GetMediaTypeH264Video(int iPosition, AM_MEDIA_TYPE *pmt)
778 {
779   HRESULT hr;
780   if (iPosition == 0)
781   {
782       ZeroMemory(pmt,sizeof(*pmt));
783       pmt->lSampleSize = 1;
784       pmt->bFixedSizeSamples = TRUE;
785       pmt->majortype = MEDIATYPE_Video;
786       hr = S_OK;
787       pmt->subtype =MEDIASUBTYPE_H264;// MAKEFOURCC('H','2','6','4');
788       pmt->formattype = FORMAT_VideoInfo2 ;
789                 
790
791       VIDEOINFOHEADER2 hdr;
792       ZeroMemory(&hdr,sizeof(hdr));
793       //hdr.dwProfile = AM_MPEG2Profile_Main;
794       //hdr.dwLevel = AM_MPEG2Level_Main;
795       hdr.bmiHeader.biSize = sizeof(hdr.bmiHeader);
796       hdr.bmiHeader.biWidth = v_width;//720;
797       hdr.bmiHeader.biHeight = v_height;//568;
798           hdr.bmiHeader.biCompression = MAKEFOURCC('H','2','6','4');
799           /* Vista compat*/
800           hdr.dwPictAspectRatioX=1;//v_sar_width; 
801           hdr.dwPictAspectRatioY=1;//v_sar_height;
802           /* Vista compat*/
803       pmt->cbFormat = sizeof(hdr);
804       pmt->pbFormat = (BYTE*)CoTaskMemAlloc(sizeof(hdr));
805       memcpy(pmt->pbFormat,&hdr,sizeof(hdr));
806   } else {
807       hr=VFW_S_NO_MORE_ITEMS;
808   }
809
810   return hr;
811 }
812
813 HRESULT DsSourcePin::GetMediaType(int iPosition, AM_MEDIA_TYPE *pmt)
814 {
815
816   switch (pinmode){
817   case MPTYPE_MPEG_AUDIO_LAYER3:
818       return GetMediaTypeMp3Audio(iPosition,pmt);
819   break;
820   
821   case MPTYPE_MPEG_AUDIO:
822           return GetMediaTypeMpegAudio(iPosition,pmt);
823   break;
824   case MPTYPE_VIDEO_MPEG2:
825       return GetMediaTypeMpegVideo(iPosition,pmt);
826   break;
827   case MPTYPE_VIDEO_H264:
828       return GetMediaTypeH264Video(iPosition,pmt);
829   break;
830   case MPTYPE_AC3_PRE13:
831   case MPTYPE_AC3:
832       return GetMediaTypeAc3(iPosition,pmt);
833   };
834 }
835
836 void DsSourcePin::SetPinMode(int mode, void* details) {
837     pinmode=mode;
838     AM_MEDIA_TYPE amtype;
839     ReleaseMType(&medtype);
840     if (details)
841     {
842         if (!isaudiopin)
843         {
844             v_width=((mptype_video_detail*) details)->width;
845             v_height=((mptype_video_detail*) details)->height;
846         }
847     }
848     GetMediaType(0,&medtype);
849 }
850
851 HRESULT DsSourcePin::Inactive() {
852   if (allocator!=NULL) return allocator->Decommit();
853   return VFW_E_NO_ALLOCATOR;
854 }
855
856 HRESULT DsSourcePin::Active() {
857   if (allocator!=NULL) return allocator->Commit();
858   return VFW_E_NO_ALLOCATOR;
859 }
860
861
862 HRESULT DsSourcePin::Run(REFERENCE_TIME reftime){
863   return NOERROR;
864 }
865
866 // No description
867 HRESULT DsSourcePin::CheckMediaType(const AM_MEDIA_TYPE *pmt)
868 {
869     HRESULT res=S_FALSE;
870     bool subtype=false;
871     switch (pinmode) {
872     case MPTYPE_MPEG_AUDIO_LAYER3:
873      //   subtype=(pmt->subtype==(MEDIASUBTYPE_MPEG2_AUDIO));
874      // subtype=(pmt->subtype==MEDIASUBTYPE_MPEG1Payload) || subtype;
875
876        subtype=(pmt->subtype==MEDIATYPE_WaveFmt_Mpeg1Layer3);
877        subtype=subtype || (pmt->subtype==MEDIASUBTYPE_MPEG2_AUDIO);
878       if (pmt->majortype==MEDIATYPE_Audio && subtype) 
879       {
880           res = S_OK ;
881       } 
882       else 
883       {
884           res = S_FALSE ;
885       }
886       break;
887
888     case MPTYPE_MPEG_AUDIO:
889           subtype=(pmt->subtype==(MEDIASUBTYPE_MPEG2_AUDIO));
890       subtype=(pmt->subtype==MEDIASUBTYPE_MPEG1Payload) || subtype;
891       if (pmt->majortype==MEDIATYPE_Audio && subtype) 
892       {
893           res = S_OK ;
894       } 
895       else 
896       {
897           res = S_FALSE ;
898       }
899       break;
900   case MPTYPE_VIDEO_MPEG2:
901        if (pmt->majortype==MEDIATYPE_Video &&
902            pmt-> subtype==MEDIASUBTYPE_MPEG2_VIDEO) 
903        {
904                res = S_OK ;
905         } 
906        else 
907        {
908             res = S_FALSE ;
909         }
910         break;
911   case MPTYPE_VIDEO_H264:
912        if (pmt->majortype==MEDIATYPE_Video &&
913            pmt-> subtype==MEDIASUBTYPE_H264) 
914        {
915                res = S_OK ;
916         } 
917        else 
918        {
919             res = S_FALSE ;
920         }
921         break;
922   case MPTYPE_AC3_PRE13:
923   case MPTYPE_AC3:
924       subtype=pmt->subtype==(MEDIASUBTYPE_DOLBY_AC3);
925       subtype=pmt->subtype==(MEDIASUBTYPE_DOLBY_AC3_SPDIF) || subtype;
926       if (pmt->majortype==MEDIATYPE_Audio && subtype) 
927       {
928           res = S_OK ;
929       }
930       else 
931       {
932           res = S_FALSE ;
933       }
934       break;
935     };
936     return res;
937 }
938
939 HRESULT DsSourcePin::DecideBufferSize(IMemAllocator *pa,ALLOCATOR_PROPERTIES *all_pp){
940   HRESULT hr;
941
942     if (pa==NULL)return E_POINTER;
943     if (all_pp==NULL) return E_POINTER;
944   if (isaudiopin) {
945     if (all_pp->cBuffers*all_pp->cbBuffer < 100*16*1024)
946     {
947       //all_pp->cBuffers = 300;//old
948       all_pp->cBuffers = 100;
949       all_pp->cbBuffer = 16*1024;
950     }
951   } else {
952     if (all_pp->cBuffers*all_pp->cbBuffer < 50*64*1024*5)
953     {
954       //all_pp->cBuffers = 300;//old
955       all_pp->cBuffers = 50;
956       all_pp->cbBuffer = 64*1024*5;
957     }
958   }
959
960     ALLOCATOR_PROPERTIES all_pp_cur;
961     hr =pa->SetProperties(all_pp,&all_pp_cur);
962     if (FAILED(hr))
963     {
964         return hr;
965     }
966     if (all_pp_cur.cbBuffer*all_pp_cur.cBuffers < all_pp->cBuffers*all_pp->cbBuffer)
967     {
968         return E_FAIL;
969     }
970
971     return S_OK;
972 }
973