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