169
|
1 /********************************************************
|
|
2
|
|
3 DirectShow Video decoder implementation
|
|
4 Copyright 2000 Eugene Kuznetsov (divx@euro.ru)
|
|
5 Converted C++ --> C :) by A'rpi/ESP-team
|
|
6
|
|
7 *********************************************************/
|
|
8
|
|
9 //#include <config.h>
|
|
10
|
|
11 //#include "DS_VideoDecoder.h"
|
|
12 #include <string.h>
|
|
13 #include <stdlib.h>
|
|
14 #include <except.h>
|
|
15 #define __MODULE__ "DirectShow_VideoDecoder"
|
|
16
|
1063
|
17 using namespace std;
|
|
18
|
169
|
19 #include <errno.h>
|
|
20 #ifdef HAVE_MALLOC_H
|
|
21 #include <malloc.h>
|
|
22 #endif
|
|
23 //#include <loader.h>
|
|
24 //#include <wine/winbase.h>
|
|
25 #include <stdio.h>
|
|
26 #include <unistd.h>
|
|
27 #include <fcntl.h>
|
|
28 #include <strstream>
|
|
29 #include <dlfcn.h>
|
|
30 #include <sys/types.h>
|
|
31 #include <sys/mman.h>
|
|
32
|
173
|
33 #include <registry.h>
|
|
34 #include <wine/winreg.h>
|
|
35
|
169
|
36 #include "guids.h"
|
|
37 #include "interfaces.h"
|
|
38 #include "DS_Filter.h"
|
|
39
|
|
40 #include "BitmapInfo.h"
|
|
41
|
|
42 #include <string>
|
|
43 #include <default.h>
|
|
44
|
|
45 #include "DS_VideoDec.h"
|
|
46
|
173
|
47
|
169
|
48 using namespace std;
|
|
49 extern "C" char* def_path;
|
|
50
|
|
51 static char** m_destptr=0;
|
|
52
|
|
53 static DS_Filter* dsf=0;
|
|
54
|
|
55 static AM_MEDIA_TYPE m_sOurType, m_sDestType;
|
|
56 static VIDEOINFOHEADER m_sVhdr;
|
|
57 static VIDEOINFOHEADER *m_sVhdr2;
|
|
58 static void* m_pCust;
|
|
59
|
|
60 static BITMAPINFOHEADER m_bh;//format of input data
|
|
61 static BitmapInfo m_decoder;//format of decoder output
|
|
62 static BitmapInfo m_obh; //format of returned frames
|
|
63 // CImage* m_outFrame;
|
|
64
|
|
65 // int m_iState=0;
|
|
66
|
|
67 extern "C" int DS_VideoDecoder_Open(char* dllname, GUID* guid, BITMAPINFOHEADER* format, int flip,char** d_ptr)
|
|
68 // :IVideoDecoder(info), m_sVhdr2(0)
|
|
69 {
|
|
70
|
|
71 m_destptr=d_ptr;
|
|
72
|
|
73 //m_outFrame=0;
|
|
74 //decpos = 0;
|
|
75 //playpos = 0;
|
|
76 //realtime = 0;
|
|
77
|
|
78 try
|
|
79 {
|
|
80 m_bh=*format;
|
|
81 memset(&m_obh, 0, sizeof(m_obh));
|
|
82 m_obh.biSize=sizeof(m_obh);
|
|
83
|
713
|
84 memset(&m_sVhdr, 0, sizeof(m_sVhdr));
|
169
|
85 m_sVhdr.bmiHeader=m_bh;
|
|
86 m_sVhdr.rcSource.left=m_sVhdr.rcSource.top=0;
|
|
87 m_sVhdr.rcSource.right=m_sVhdr.bmiHeader.biWidth;
|
|
88 m_sVhdr.rcSource.bottom=m_sVhdr.bmiHeader.biHeight;
|
|
89 m_sVhdr.rcTarget=m_sVhdr.rcSource;
|
|
90 m_sOurType.majortype=MEDIATYPE_Video;
|
|
91
|
|
92 m_sOurType.subtype=MEDIATYPE_Video;
|
|
93 m_sOurType.subtype.f1=m_sVhdr.bmiHeader.biCompression;
|
|
94 m_sOurType.formattype=FORMAT_VideoInfo;
|
|
95 m_sOurType.bFixedSizeSamples=false;
|
|
96 m_sOurType.bTemporalCompression=true;
|
|
97 m_sOurType.pUnk=0;
|
713
|
98 m_sOurType.cbFormat=sizeof(m_sVhdr);
|
169
|
99 m_sOurType.pbFormat=(char*)&m_sVhdr;
|
|
100
|
|
101 m_sVhdr2=(VIDEOINFOHEADER*)(new char[sizeof(VIDEOINFOHEADER)+12]);
|
|
102 *m_sVhdr2=m_sVhdr;
|
|
103 m_sVhdr2->bmiHeader.biCompression=0;
|
|
104 m_sVhdr2->bmiHeader.biBitCount=24;
|
|
105
|
713
|
106 memset(&m_sDestType, 0, sizeof(m_sDestType));
|
169
|
107 m_sDestType.majortype=MEDIATYPE_Video;
|
|
108 m_sDestType.subtype=MEDIASUBTYPE_RGB24;
|
|
109 m_sDestType.formattype=FORMAT_VideoInfo;
|
|
110 m_sDestType.bFixedSizeSamples=true;
|
|
111 m_sDestType.bTemporalCompression=false;
|
|
112 m_sDestType.lSampleSize=abs(m_sVhdr2->bmiHeader.biWidth*m_sVhdr2->bmiHeader.biHeight*
|
|
113 ((m_sVhdr2->bmiHeader.biBitCount+7)/8));
|
|
114 m_sVhdr2->bmiHeader.biSizeImage=m_sDestType.lSampleSize;
|
|
115 m_sDestType.pUnk=0;
|
|
116 m_sDestType.cbFormat=sizeof(VIDEOINFOHEADER);
|
|
117 m_sDestType.pbFormat=(char*)m_sVhdr2;
|
|
118
|
|
119 m_obh=m_bh;
|
|
120 m_obh.setBits(24);
|
|
121
|
|
122 HRESULT result;
|
|
123
|
713
|
124 dsf=new DS_Filter();
|
|
125 dsf->Create(dllname, guid, &m_sOurType, &m_sDestType);
|
|
126
|
169
|
127 if(!flip)
|
|
128 {
|
|
129 m_sVhdr2->bmiHeader.biHeight*=-1;
|
|
130 m_obh.biHeight*=-1;
|
713
|
131 result=dsf->m_pOutputPin->vt->QueryAccept(dsf->m_pOutputPin, &m_sDestType);
|
|
132 if(result){
|
|
133 printf("DShow: Decoder does not support upside-down frames");
|
|
134 m_obh.biHeight*=-1;
|
|
135 }
|
169
|
136 }
|
|
137
|
468
|
138 #if 0
|
169
|
139 m_sVhdr2->bmiHeader.biBitCount=16;
|
|
140 m_sVhdr2->bmiHeader.biCompression=fccYUY2;
|
|
141 m_sDestType.subtype=MEDIASUBTYPE_YUY2;
|
|
142 result=dsf->m_pOutputPin->vt->QueryAccept(dsf->m_pOutputPin, &m_sDestType);
|
|
143 // if(!result) caps=(CAPS)(caps | CAP_YUY2);
|
468
|
144 #endif
|
169
|
145
|
|
146 m_sVhdr2->bmiHeader.biBitCount=24;
|
|
147 m_sVhdr2->bmiHeader.biCompression=0;
|
|
148 m_sDestType.subtype=MEDIASUBTYPE_RGB24;
|
|
149 m_decoder=m_obh;
|
|
150 //qual = 0-1;
|
|
151 }
|
|
152 catch(FatalError& error)
|
|
153 {
|
|
154 delete[] m_sVhdr2;
|
|
155 return 1;
|
|
156 }
|
|
157 return 0;
|
|
158 }
|
|
159
|
|
160 extern "C" void DS_VideoDecoder_Start(){
|
|
161 if(dsf->m_iState!=1) return;
|
|
162 dsf->Start();
|
|
163
|
|
164 ALLOCATOR_PROPERTIES props, props1;
|
|
165 props.cBuffers=1;
|
|
166 props.cbBuffer=1024*1024; //m_sDestType.lSampleSize;//don't know how to do this correctly
|
|
167 props.cbAlign=props.cbPrefix=0;
|
|
168 dsf->m_pAll->vt->SetProperties(dsf->m_pAll, &props, &props1);
|
|
169 dsf->m_pAll->vt->Commit(dsf->m_pAll);
|
|
170
|
|
171 // m_outFrame=new CImage(&m_decoder,(unsigned char *)malloc(m_sDestType.lSampleSize),false);
|
|
172 //m_outFrame=new CImage(&m_decoder, 0, false);
|
|
173 // printf("Datap %x\n",m_outFrame->getaddr());
|
|
174
|
|
175
|
|
176 // dsf->m_pOurOutput->SetFramePointer((char **)m_outFrame->getaddr()); //!FIXME!
|
|
177 dsf->m_pOurOutput->SetFramePointer(m_destptr); //!FIXME!
|
|
178
|
|
179 // filling = realtime;
|
|
180
|
|
181 dsf->m_iState=2;
|
|
182 return;
|
|
183 }
|
|
184
|
|
185 extern "C" void DS_VideoDecoder_Stop(){
|
|
186 if(dsf->m_iState!=2) return;
|
|
187 dsf->Stop();
|
713
|
188 // dsf->m_pOurOutput->SetFramePointer(0);
|
169
|
189 // free(m_outFrame->data());
|
|
190 //m_outFrame->release();//just in case
|
|
191 //m_outFrame=0;
|
|
192 // FlushCache();
|
|
193 dsf->m_iState=1;
|
|
194 return;
|
|
195 }
|
|
196
|
|
197 extern "C" void DS_VideoDecoder_Restart(){
|
|
198 if(dsf->m_iState!=2) return;
|
|
199
|
|
200 dsf->Stop();
|
|
201 dsf->Start();
|
|
202
|
|
203 ALLOCATOR_PROPERTIES props, props1;
|
|
204 props.cBuffers=1;
|
|
205 props.cbBuffer=m_sDestType.lSampleSize;//don't know how to do this correctly
|
|
206 props.cbAlign=props.cbPrefix=0;
|
|
207 dsf->m_pAll->vt->SetProperties(dsf->m_pAll, &props, &props1);
|
|
208 dsf->m_pAll->vt->Commit(dsf->m_pAll);
|
|
209 }
|
|
210
|
|
211 extern "C" void DS_VideoDecoder_Close(){
|
|
212 if(dsf->m_iState==0) return;
|
|
213 if(dsf->m_iState==2) DS_VideoDecoder_Stop();
|
|
214 delete[] m_sVhdr2;
|
|
215 // delete m_outFrame;
|
|
216 }
|
|
217
|
|
218 extern "C" int DS_VideoDecoder_DecodeFrame(char* src, int size, int is_keyframe, int render){
|
|
219
|
|
220 if(!size)return 0;
|
|
221
|
|
222 m_bh.biSizeImage=size;
|
|
223
|
|
224 IMediaSample* sample=0;
|
173
|
225 //printf("GetBuffer... (m_pAll=%X) ",dsf->m_pAll);fflush(stdout);
|
169
|
226 dsf->m_pAll->vt->GetBuffer(dsf->m_pAll, &sample, 0, 0, 0);
|
173
|
227 //printf("OK!\n");
|
169
|
228 if(!sample)
|
|
229 {
|
|
230 Debug cerr<<"ERROR: null sample"<<endl;
|
|
231 return -1;
|
|
232 }
|
|
233 char* ptr;
|
173
|
234 //printf("GetPtr...");fflush(stdout);
|
169
|
235 sample->vt->GetPointer(sample, (BYTE **)&ptr);
|
173
|
236 //printf("OK!\n");
|
169
|
237 memcpy(ptr, src, size);
|
173
|
238 //printf("memcpy OK!\n");
|
169
|
239 sample->vt->SetActualDataLength(sample, size);
|
173
|
240 //printf("SetActualDataLength OK!\n");
|
169
|
241 sample->vt->SetSyncPoint(sample, is_keyframe);
|
173
|
242 //printf("SetSyncPoint OK!\n");
|
169
|
243 sample->vt->SetPreroll(sample, !render);
|
|
244 // sample->vt->SetMediaType(sample, &m_sOurType);
|
|
245 int result=dsf->m_pImp->vt->Receive(dsf->m_pImp, sample);
|
|
246 if(result)
|
173
|
247 printf("Error putting data into input pin %x\n", result);
|
169
|
248
|
|
249 sample->vt->Release((IUnknown*)sample);
|
|
250
|
|
251 return 0;
|
|
252 }
|
|
253
|
|
254 extern "C" int DS_VideoDecoder_SetDestFmt(int bits, int csp){
|
|
255 if(dsf->m_iState==0) return -1;
|
|
256 // if(!CImage::supported(csp, bits)) return -1;
|
|
257 HRESULT result;
|
|
258 // BitmapInfo temp=m_obh;
|
|
259 if(csp==0)
|
|
260 {
|
|
261 switch(bits)
|
|
262 {
|
|
263 case 15:
|
|
264 m_sDestType.subtype=MEDIASUBTYPE_RGB555;
|
|
265 break;
|
|
266 case 16:
|
|
267 m_sDestType.subtype=MEDIASUBTYPE_RGB565;
|
|
268 break;
|
|
269 case 24:
|
|
270 m_sDestType.subtype=MEDIASUBTYPE_RGB24;
|
|
271 break;
|
|
272 case 32:
|
|
273 m_sDestType.subtype=MEDIASUBTYPE_RGB32;
|
|
274 break;
|
|
275 default:
|
|
276 break;
|
|
277 }
|
|
278 m_obh.setBits(bits);
|
|
279 // .biSizeImage=abs(temp.biWidth*temp.biHeight*((temp.biBitCount+7)/8));
|
|
280 }
|
|
281 else
|
|
282 {
|
468
|
283 m_obh.setSpace(csp,bits);
|
169
|
284 switch(csp)
|
|
285 {
|
|
286 case fccYUY2:
|
|
287 m_sDestType.subtype=MEDIASUBTYPE_YUY2;
|
468
|
288 printf("DShow: using YUY2 colorspace\n");
|
169
|
289 break;
|
|
290 case fccYV12:
|
|
291 m_sDestType.subtype=MEDIASUBTYPE_YV12;
|
468
|
292 printf("DShow: using YV12 colorspace\n");
|
169
|
293 break;
|
|
294 case fccIYUV:
|
|
295 m_sDestType.subtype=MEDIASUBTYPE_IYUV;
|
468
|
296 printf("DShow: using IYUV colorspace\n");
|
169
|
297 break;
|
|
298 case fccUYVY:
|
|
299 m_sDestType.subtype=MEDIASUBTYPE_UYVY;
|
468
|
300 printf("DShow: using UYVY colorspace\n");
|
169
|
301 break;
|
|
302 case fccYVYU:
|
|
303 m_sDestType.subtype=MEDIASUBTYPE_YVYU;
|
468
|
304 printf("DShow: using YVYU colorspace\n");
|
169
|
305 break;
|
|
306 }
|
|
307 }
|
|
308
|
|
309 m_sDestType.lSampleSize=m_obh.biSizeImage;
|
|
310 memcpy(&(m_sVhdr2->bmiHeader), &m_obh, sizeof(m_obh));
|
|
311 m_sVhdr2->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
|
|
312 if(m_sVhdr2->bmiHeader.biCompression==3)
|
|
313 m_sDestType.cbFormat=sizeof(VIDEOINFOHEADER)+12;
|
|
314 else
|
|
315 m_sDestType.cbFormat=sizeof(VIDEOINFOHEADER);
|
|
316
|
|
317 result=dsf->m_pOutputPin->vt->QueryAccept(dsf->m_pOutputPin, &m_sDestType);
|
|
318
|
|
319 if(result!=0)
|
|
320 {
|
|
321 if(csp)
|
|
322 cerr<<"Warning: unsupported color space"<<endl;
|
|
323 else
|
|
324 cerr<<"Warning: unsupported bit depth"<<endl;
|
|
325
|
|
326 m_sDestType.lSampleSize=m_decoder.biSizeImage;
|
|
327 memcpy(&(m_sVhdr2->bmiHeader), &m_decoder, sizeof(m_decoder));
|
|
328 m_sVhdr2->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
|
|
329 if(m_sVhdr2->bmiHeader.biCompression==3)
|
|
330 m_sDestType.cbFormat=sizeof(VIDEOINFOHEADER)+12;
|
|
331 else
|
|
332 m_sDestType.cbFormat=sizeof(VIDEOINFOHEADER);
|
|
333 return 1;
|
|
334 }
|
|
335
|
|
336 m_decoder=m_obh;
|
|
337 // m_obh=temp;
|
|
338 // if(csp)
|
|
339 // m_obh.biBitCount=BitmapInfo::BitCount(csp);
|
|
340 m_bh.biBitCount=bits;
|
|
341 if(dsf->m_iState>0)
|
|
342 {
|
|
343 int old_state=dsf->m_iState;
|
|
344 if(dsf->m_iState==2) DS_VideoDecoder_Stop();
|
|
345 dsf->m_pInputPin->vt->Disconnect(dsf->m_pInputPin);
|
|
346 dsf->m_pOutputPin->vt->Disconnect(dsf->m_pOutputPin);
|
|
347 dsf->m_pOurOutput->SetNewFormat(m_sDestType);
|
|
348 result=dsf->m_pInputPin->vt->ReceiveConnection(dsf->m_pInputPin, dsf->m_pOurInput, &m_sOurType);
|
|
349 if(result)
|
|
350 {
|
|
351 cerr<<"Error reconnecting input pin "<<hex<<result<<dec<<endl;
|
|
352 return -1;
|
|
353 }
|
|
354 result=dsf->m_pOutputPin->vt->ReceiveConnection(dsf->m_pOutputPin,
|
|
355 dsf->m_pOurOutput, &m_sDestType);
|
|
356 if(result)
|
|
357 {
|
|
358 cerr<<"Error reconnecting output pin "<<hex<<result<<dec<<endl;
|
|
359 return -1;
|
|
360 }
|
|
361 if(old_state==2) DS_VideoDecoder_Start();
|
|
362 }
|
|
363 return 0;
|
|
364 }
|
|
365
|
|
366
|
|
367 extern "C" int DS_SetValue_DivX(char* name, int value){
|
|
368 int temp;
|
|
369 if(dsf->m_iState!=2) return VFW_E_NOT_RUNNING;
|
|
370 // brightness 87
|
|
371 // contrast 74
|
|
372 // hue 23
|
|
373 // saturation 20
|
|
374 // post process mode 0
|
|
375 // get1 0x01
|
|
376 // get2 10
|
|
377 // get3=set2 86
|
|
378 // get4=set3 73
|
|
379 // get5=set4 19
|
|
380 // get6=set5 23
|
|
381 printf("DivX setting: %s = %d\n",name,value);
|
|
382
|
|
383 IHidden* hidden=(IHidden*)((int)dsf->m_pFilter+0xb8);
|
|
384 if(strcmp(name, "Brightness")==0)
|
|
385 return hidden->vt->SetSmth2(hidden, value, 0);
|
|
386 if(strcmp(name, "Contrast")==0)
|
|
387 return hidden->vt->SetSmth3(hidden, value, 0);
|
|
388 if(strcmp(name, "Hue")==0)
|
|
389 return hidden->vt->SetSmth5(hidden, value, 0);
|
|
390 if(strcmp(name, "Saturation")==0)
|
|
391 return hidden->vt->SetSmth4(hidden, value, 0);
|
|
392 if(strcmp(name, "Quality")==0)
|
|
393 return hidden->vt->SetSmth(hidden, value, 0);
|
|
394
|
|
395 printf("Invalid setting!\n");
|
|
396 return -200;
|
|
397 }
|
|
398
|
173
|
399 extern "C" int DS_SetAttr_DivX(char* attribute, int value){
|
|
400 int result, status, newkey, count;
|
|
401 if(strcmp(attribute, "Quality")==0){
|
|
402 char* keyname="SOFTWARE\\Microsoft\\Scrunch";
|
|
403 result=RegCreateKeyExA(HKEY_CURRENT_USER, keyname, 0, 0, 0, 0, 0, &newkey, &status);
|
|
404 if(result!=0)
|
|
405 {
|
|
406 printf("VideoDecoder::SetExtAttr: registry failure\n");
|
|
407 return -1;
|
|
408 }
|
|
409 result=RegSetValueExA(newkey, "Current Post Process Mode", 0, REG_DWORD, &value, 4);
|
|
410 if(result!=0)
|
|
411 {
|
|
412 printf("VideoDecoder::SetExtAttr: error writing value\n");
|
|
413 return -1;
|
|
414 }
|
|
415 value=-1;
|
|
416 result=RegSetValueExA(newkey, "Force Post Process Mode", 0, REG_DWORD, &value, 4);
|
|
417 if(result!=0)
|
|
418 {
|
|
419 printf("VideoDecoder::SetExtAttr: error writing value\n");
|
|
420 return -1;
|
|
421 }
|
|
422 RegCloseKey(newkey);
|
|
423 return 0;
|
|
424 }
|
169
|
425
|
173
|
426 if(
|
|
427 (strcmp(attribute, "Saturation")==0) ||
|
|
428 (strcmp(attribute, "Hue")==0) ||
|
|
429 (strcmp(attribute, "Contrast")==0) ||
|
|
430 (strcmp(attribute, "Brightness")==0)
|
|
431 )
|
|
432 {
|
|
433 char* keyname="SOFTWARE\\Microsoft\\Scrunch\\Video";
|
|
434 result=RegCreateKeyExA(HKEY_CURRENT_USER, keyname, 0, 0, 0, 0, 0, &newkey, &status);
|
|
435 if(result!=0)
|
|
436 {
|
|
437 printf("VideoDecoder::SetExtAttr: registry failure\n");
|
|
438 return -1;
|
|
439 }
|
|
440 result=RegSetValueExA(newkey, attribute, 0, REG_DWORD, &value, 4);
|
|
441 if(result!=0)
|
|
442 {
|
|
443 printf("VideoDecoder::SetExtAttr: error writing value\n");
|
|
444 return -1;
|
|
445 }
|
|
446 RegCloseKey(newkey);
|
|
447 return 0;
|
|
448 }
|
|
449
|
|
450 printf("Unknown attribute!\n");
|
|
451 return -200;
|
|
452 }
|
|
453
|