← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mplayer2/oneiric-proposed

« back to all changes in this revision

Viewing changes to mplayer/loader/dshow/DS_VideoDecoder.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 22:48:03 UTC
  • Revision ID: james.westby@ubuntu.com-20110320224803-kc2nlrxz6pcphmf1
Tags: upstream-2.0~rc2
Import upstream version 2.0~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
mplayer/loader/dshow/DS_VideoDecoder.c
 
1
/********************************************************
 
2
 
 
3
        DirectShow Video decoder implementation
 
4
        Copyright 2000 Eugene Kuznetsov  (divx@euro.ru)
 
5
 
 
6
*********************************************************/
 
7
#include "config.h"
 
8
#include "guids.h"
 
9
#include "interfaces.h"
 
10
#include "loader/registry.h"
 
11
#include "libwin32.h"
 
12
#include "DS_Filter.h"
 
13
 
 
14
struct DS_VideoDecoder
 
15
{
 
16
    IVideoDecoder iv;
 
17
 
 
18
    DS_Filter* m_pDS_Filter;
 
19
    AM_MEDIA_TYPE m_sOurType, m_sDestType;
 
20
    VIDEOINFOHEADER* m_sVhdr;
 
21
    VIDEOINFOHEADER* m_sVhdr2;
 
22
    int m_Caps;//CAPS m_Caps;                // capabilities of DirectShow decoder
 
23
    int m_iLastQuality;         // remember last quality as integer
 
24
    int m_iMinBuffers;
 
25
    int m_iMaxAuto;
 
26
    int m_bIsDivX;             // for speed
 
27
    int m_bIsDivX4;            // for speed
 
28
};
 
29
static SampleProcUserData sampleProcData;
 
30
 
 
31
#include "DS_VideoDecoder.h"
 
32
 
 
33
#include "loader/wine/winerror.h"
 
34
#ifdef WIN32_LOADER
 
35
#include "loader/ldt_keeper.h"
 
36
#endif
 
37
 
 
38
#include <unistd.h>
 
39
#include <fcntl.h>
 
40
#include <errno.h>
 
41
#include <sys/types.h>
 
42
#ifdef HAVE_SYS_MMAN_H
 
43
#include <sys/mman.h>
 
44
#endif
 
45
#include <stdio.h>
 
46
#include <stdlib.h>  // labs
 
47
 
 
48
// strcmp((const char*)info.dll,...)  is used instead of  (... == ...)
 
49
// so Arpi could use char* pointer in his simplified DS_VideoDecoder class
 
50
 
 
51
#define false 0
 
52
#define true 1
 
53
 
 
54
int DS_VideoDecoder_GetCapabilities(DS_VideoDecoder *this)
 
55
{return this->m_Caps;}
 
56
 
 
57
typedef struct ct ct;
 
58
 
 
59
struct ct {
 
60
                unsigned int bits;
 
61
                fourcc_t fcc;
 
62
                const GUID *subtype;
 
63
                int cap;
 
64
            };
 
65
 
 
66
static ct check[] = {
 
67
                {16, fccYUY2, &MEDIASUBTYPE_YUY2, CAP_YUY2},
 
68
                {12, fccIYUV, &MEDIASUBTYPE_IYUV, CAP_IYUV},
 
69
                {16, fccUYVY, &MEDIASUBTYPE_UYVY, CAP_UYVY},
 
70
                {12, fccYV12, &MEDIASUBTYPE_YV12, CAP_YV12},
 
71
                //{16, fccYV12, &MEDIASUBTYPE_YV12, CAP_YV12},
 
72
                {16, fccYVYU, &MEDIASUBTYPE_YVYU, CAP_YVYU},
 
73
                {12, fccI420, &MEDIASUBTYPE_I420, CAP_I420},
 
74
                {9,  fccYVU9, &MEDIASUBTYPE_YVU9, CAP_YVU9},
 
75
                {0, 0, 0, 0},
 
76
            };
 
77
 
 
78
 
 
79
DS_VideoDecoder * DS_VideoDecoder_Open(char* dllname, GUID* guid, BITMAPINFOHEADER * format, int flip, int maxauto)
 
80
{
 
81
    DS_VideoDecoder *this;
 
82
    HRESULT result;
 
83
    ct* c;
 
84
 
 
85
    this = malloc(sizeof(DS_VideoDecoder));
 
86
    memset( this, 0, sizeof(DS_VideoDecoder));
 
87
 
 
88
    this->m_sVhdr2 = 0;
 
89
    this->m_iLastQuality = -1;
 
90
    this->m_iMaxAuto = maxauto;
 
91
 
 
92
#ifdef WIN32_LOADER
 
93
    Setup_LDT_Keeper();
 
94
#endif
 
95
 
 
96
    //memset(&m_obh, 0, sizeof(m_obh));
 
97
    //m_obh.biSize = sizeof(m_obh);
 
98
    /*try*/
 
99
    {
 
100
        unsigned int bihs;
 
101
 
 
102
        bihs = (format->biSize < (int) sizeof(BITMAPINFOHEADER)) ?
 
103
            sizeof(BITMAPINFOHEADER) : format->biSize;
 
104
 
 
105
        this->iv.m_bh = malloc(bihs);
 
106
        memcpy(this->iv.m_bh, format, bihs);
 
107
        this->iv.m_bh->biSize = bihs;
 
108
 
 
109
        this->iv.m_State = STOP;
 
110
        //this->iv.m_pFrame = 0;
 
111
        this->iv.m_Mode = DIRECT;
 
112
        this->iv.m_iDecpos = 0;
 
113
        this->iv.m_iPlaypos = -1;
 
114
        this->iv.m_fQuality = 0.0f;
 
115
        this->iv.m_bCapable16b = true;
 
116
 
 
117
        bihs += sizeof(VIDEOINFOHEADER) - sizeof(BITMAPINFOHEADER);
 
118
        this->m_sVhdr = malloc(bihs);
 
119
        memset(this->m_sVhdr, 0, bihs);
 
120
        memcpy(&this->m_sVhdr->bmiHeader, this->iv.m_bh, this->iv.m_bh->biSize);
 
121
        this->m_sVhdr->rcSource.left = this->m_sVhdr->rcSource.top = 0;
 
122
        this->m_sVhdr->rcSource.right = this->m_sVhdr->bmiHeader.biWidth;
 
123
        this->m_sVhdr->rcSource.bottom = this->m_sVhdr->bmiHeader.biHeight;
 
124
        //this->m_sVhdr->rcSource.right = 0;
 
125
        //this->m_sVhdr->rcSource.bottom = 0;
 
126
        this->m_sVhdr->rcTarget = this->m_sVhdr->rcSource;
 
127
 
 
128
        this->m_sOurType.majortype = MEDIATYPE_Video;
 
129
        this->m_sOurType.subtype = MEDIATYPE_Video;
 
130
        this->m_sOurType.subtype.f1 = this->m_sVhdr->bmiHeader.biCompression;
 
131
        this->m_sOurType.formattype = FORMAT_VideoInfo;
 
132
        this->m_sOurType.bFixedSizeSamples = false;
 
133
        this->m_sOurType.bTemporalCompression = true;
 
134
        this->m_sOurType.pUnk = 0;
 
135
        this->m_sOurType.cbFormat = bihs;
 
136
        this->m_sOurType.pbFormat = (char*)this->m_sVhdr;
 
137
 
 
138
        this->m_sVhdr2 = malloc(sizeof(VIDEOINFOHEADER)+12);
 
139
        memcpy(this->m_sVhdr2, this->m_sVhdr, sizeof(VIDEOINFOHEADER));
 
140
        memset((char*)this->m_sVhdr2 + sizeof(VIDEOINFOHEADER), 0, 12);
 
141
        this->m_sVhdr2->bmiHeader.biCompression = 0;
 
142
        this->m_sVhdr2->bmiHeader.biBitCount = 24;
 
143
 
 
144
        memset(&this->m_sDestType, 0, sizeof(this->m_sDestType));
 
145
        this->m_sDestType.majortype = MEDIATYPE_Video;
 
146
        this->m_sDestType.subtype = MEDIASUBTYPE_RGB24;
 
147
        this->m_sDestType.formattype = FORMAT_VideoInfo;
 
148
        this->m_sDestType.bFixedSizeSamples = true;
 
149
        this->m_sDestType.bTemporalCompression = false;
 
150
        this->m_sDestType.lSampleSize = labs(this->m_sVhdr2->bmiHeader.biWidth*this->m_sVhdr2->bmiHeader.biHeight
 
151
                                       * ((this->m_sVhdr2->bmiHeader.biBitCount + 7) / 8));
 
152
        this->m_sVhdr2->bmiHeader.biSizeImage = this->m_sDestType.lSampleSize;
 
153
        this->m_sDestType.pUnk = 0;
 
154
        this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER);
 
155
        this->m_sDestType.pbFormat = (char*)this->m_sVhdr2;
 
156
 
 
157
        memset(&this->iv.m_obh, 0, sizeof(this->iv.m_obh));
 
158
        memcpy(&this->iv.m_obh, this->iv.m_bh, sizeof(this->iv.m_obh) < (unsigned) this->iv.m_bh->biSize
 
159
               ? sizeof(this->iv.m_obh) : (unsigned) this->iv.m_bh->biSize);
 
160
        this->iv.m_obh.biBitCount=24;
 
161
        this->iv.m_obh.biSize = sizeof(BITMAPINFOHEADER);
 
162
        this->iv.m_obh.biCompression = 0;       //BI_RGB
 
163
        //this->iv.m_obh.biHeight = labs(this->iv.m_obh.biHeight);
 
164
        this->iv.m_obh.biSizeImage = labs(this->iv.m_obh.biWidth * this->iv.m_obh.biHeight)
 
165
                              * ((this->iv.m_obh.biBitCount + 7) / 8);
 
166
 
 
167
 
 
168
        this->m_pDS_Filter = DS_FilterCreate(dllname, guid, &this->m_sOurType, &this->m_sDestType,&sampleProcData);
 
169
 
 
170
        if (!this->m_pDS_Filter)
 
171
        {
 
172
            printf("Failed to create DirectShow filter\n");
 
173
            return 0;
 
174
        }
 
175
 
 
176
        if (!flip)
 
177
        {
 
178
            this->iv.m_obh.biHeight *= -1;
 
179
            this->m_sVhdr2->bmiHeader.biHeight = this->iv.m_obh.biHeight;
 
180
            result = this->m_pDS_Filter->m_pOutputPin->vt->QueryAccept(this->m_pDS_Filter->m_pOutputPin, &this->m_sDestType);
 
181
            if (result)
 
182
            {
 
183
                printf("Decoder does not support upside-down RGB frames\n");
 
184
                this->iv.m_obh.biHeight *= -1;
 
185
                this->m_sVhdr2->bmiHeader.biHeight = this->iv.m_obh.biHeight;
 
186
            }
 
187
        }
 
188
 
 
189
        memcpy( &this->iv.m_decoder, &this->iv.m_obh, sizeof(this->iv.m_obh) );
 
190
 
 
191
        switch (this->iv.m_bh->biCompression)
 
192
        {
 
193
#if 0
 
194
        case fccDIV3:
 
195
        case fccDIV4:
 
196
        case fccDIV5:
 
197
        case fccDIV6:
 
198
        case fccMP42:
 
199
        case fccWMV2:
 
200
            //YV12 seems to be broken for DivX :-) codec
 
201
//      case fccIV50:
 
202
            //produces incorrect picture
 
203
            //m_Caps = (CAPS) (m_Caps & ~CAP_YV12);
 
204
            //m_Caps = CAP_UYVY;//CAP_YUY2; // | CAP_I420;
 
205
            //m_Caps = CAP_I420;
 
206
            this->m_Caps = (CAP_YUY2 | CAP_UYVY);
 
207
            break;
 
208
#endif
 
209
        default:
 
210
 
 
211
            this->m_Caps = CAP_NONE;
 
212
 
 
213
            printf("Decoder supports the following YUV formats: ");
 
214
            for (c = check; c->bits; c++)
 
215
            {
 
216
                this->m_sVhdr2->bmiHeader.biBitCount = c->bits;
 
217
                this->m_sVhdr2->bmiHeader.biCompression = c->fcc;
 
218
                this->m_sDestType.subtype = *c->subtype;
 
219
                result = this->m_pDS_Filter->m_pOutputPin->vt->QueryAccept(this->m_pDS_Filter->m_pOutputPin, &this->m_sDestType);
 
220
                if (!result)
 
221
                {
 
222
                    this->m_Caps = (this->m_Caps | c->cap);
 
223
                    printf("%.4s ", (char *)&c->fcc);
 
224
                }
 
225
            }
 
226
            printf("\n");
 
227
        }
 
228
 
 
229
        if (this->m_Caps != CAP_NONE)
 
230
            printf("Decoder is capable of YUV output (flags 0x%x)\n", (int)this->m_Caps);
 
231
 
 
232
        this->m_sVhdr2->bmiHeader.biBitCount = 24;
 
233
        this->m_sVhdr2->bmiHeader.biCompression = 0;
 
234
        this->m_sDestType.subtype = MEDIASUBTYPE_RGB24;
 
235
 
 
236
        this->m_iMinBuffers = this->iv.VBUFSIZE;
 
237
        this->m_bIsDivX = (strcmp(dllname, "divxcvki.ax") == 0
 
238
                     || strcmp(dllname, "divx_c32.ax") == 0
 
239
                     || strcmp(dllname, "wmvds32.ax") == 0
 
240
                     || strcmp(dllname, "wmv8ds32.ax") == 0);
 
241
        this->m_bIsDivX4 = (strcmp(dllname, "divxdec.ax") == 0);
 
242
        if (this->m_bIsDivX)
 
243
            this->iv.VBUFSIZE += 7;
 
244
        else if (this->m_bIsDivX4)
 
245
            this->iv.VBUFSIZE += 9;
 
246
    }
 
247
    /*catch (FatalError& error)
 
248
    {
 
249
        delete[] m_sVhdr;
 
250
        delete[] m_sVhdr2;
 
251
        delete m_pDS_Filter;
 
252
        throw;
 
253
    }*/
 
254
    return this;
 
255
}
 
256
 
 
257
void DS_VideoDecoder_Destroy(DS_VideoDecoder *this)
 
258
{
 
259
    DS_VideoDecoder_StopInternal(this);
 
260
    this->iv.m_State = STOP;
 
261
    free(this->m_sVhdr);
 
262
    free(this->m_sVhdr2);
 
263
    DS_Filter_Destroy(this->m_pDS_Filter);
 
264
}
 
265
 
 
266
void DS_VideoDecoder_StartInternal(DS_VideoDecoder *this)
 
267
{
 
268
    Debug printf("DS_VideoDecoder_StartInternal\n");
 
269
    //cout << "DSSTART" << endl;
 
270
    this->m_pDS_Filter->m_pAll->vt->Commit(this->m_pDS_Filter->m_pAll);
 
271
    this->m_pDS_Filter->Start(this->m_pDS_Filter);
 
272
 
 
273
    this->iv.m_State = START;
 
274
}
 
275
 
 
276
void DS_VideoDecoder_StopInternal(DS_VideoDecoder *this)
 
277
{
 
278
    this->m_pDS_Filter->Stop(this->m_pDS_Filter);
 
279
    //??? why was this here ??? m_pOurOutput->SetFramePointer(0);
 
280
}
 
281
 
 
282
int DS_VideoDecoder_DecodeInternal(DS_VideoDecoder *this, const void* src, int size, int is_keyframe, char* pImage)
 
283
{
 
284
    IMediaSample* sample = 0;
 
285
    char* ptr;
 
286
    int result;
 
287
 
 
288
    Debug printf("DS_VideoDecoder_DecodeInternal(%p,%p,%d,%d,%p)\n",this,src,size,is_keyframe,pImage);
 
289
 
 
290
    this->m_pDS_Filter->m_pAll->vt->GetBuffer(this->m_pDS_Filter->m_pAll, &sample, 0, 0, 0);
 
291
 
 
292
    if (!sample)
 
293
    {
 
294
        Debug printf("ERROR: null sample\n");
 
295
        return -1;
 
296
    }
 
297
 
 
298
    //cout << "DECODE " << (void*) pImage << "   d: " << (void*) pImage->Data() << endl;
 
299
 
 
300
 
 
301
    sample->vt->SetActualDataLength(sample, size);
 
302
    sample->vt->GetPointer(sample, (BYTE **)&ptr);
 
303
    memcpy(ptr, src, size);
 
304
    sample->vt->SetSyncPoint(sample, is_keyframe);
 
305
    sample->vt->SetPreroll(sample, pImage ? 0 : 1);
 
306
    // sample->vt->SetMediaType(sample, &m_sOurType);
 
307
 
 
308
    // FIXME: - crashing with YV12 at this place decoder will crash
 
309
    //          while doing this call
 
310
    // %FS register was not setup for calling into win32 dll. Are all
 
311
    // crashes inside ...->Receive() fixed now?
 
312
    //
 
313
    // nope - but this is surely helpfull - I'll try some more experiments
 
314
#ifdef WIN32_LOADER
 
315
    Setup_FS_Segment();
 
316
#endif
 
317
#if 0
 
318
    if (!this->m_pDS_Filter || !this->m_pDS_Filter->m_pImp
 
319
        || !this->m_pDS_Filter->m_pImp->vt
 
320
        || !this->m_pDS_Filter->m_pImp->vt->Receive)
 
321
        printf("DecodeInternal ERROR???\n");
 
322
#endif
 
323
    result = this->m_pDS_Filter->m_pImp->vt->Receive(this->m_pDS_Filter->m_pImp, sample);
 
324
    if (result)
 
325
    {
 
326
        Debug printf("DS_VideoDecoder::DecodeInternal() error putting data into input pin %x\n", result);
 
327
    }
 
328
    if (pImage)
 
329
    {
 
330
        memcpy(pImage, sampleProcData.frame_pointer, sampleProcData.frame_size);
 
331
    }
 
332
    sample->vt->Release((IUnknown*)sample);
 
333
 
 
334
#if 0
 
335
    if (this->m_bIsDivX)
 
336
    {
 
337
        int q;
 
338
        IHidden* hidden=(IHidden*)((int)this->m_pDS_Filter->m_pFilter + 0xb8);
 
339
        // always check for actual value
 
340
        // this seems to be the only way to know the actual value
 
341
        hidden->vt->GetSmth2(hidden, &this->m_iLastQuality);
 
342
        if (this->m_iLastQuality > 9)
 
343
            this->m_iLastQuality -= 10;
 
344
 
 
345
        if (this->m_iLastQuality < 0)
 
346
            this->m_iLastQuality = 0;
 
347
        else if (this->m_iLastQuality > this->m_iMaxAuto)
 
348
            this->m_iLastQuality = this->m_iMaxAuto;
 
349
 
 
350
        //cout << " Qual: " << this->m_iLastQuality << endl;
 
351
        this->iv.m_fQuality = this->m_iLastQuality / 4.0;
 
352
    }
 
353
    else if (this->m_bIsDivX4)
 
354
    {
 
355
 
 
356
        // maybe access methods directly to safe some cpu cycles...
 
357
        DS_VideoDecoder_GetValue(this, "Postprocessing", this->m_iLastQuality);
 
358
        if (this->m_iLastQuality < 0)
 
359
            this->m_iLastQuality = 0;
 
360
        else if (this->m_iLastQuality > this->m_iMaxAuto)
 
361
            this->m_iLastQuality = this->m_iMaxAuto;
 
362
 
 
363
        //cout << " Qual: " << m_iLastQuality << endl;
 
364
        this->iv.m_fQuality = this->m_iLastQuality / 6.0;
 
365
    }
 
366
 
 
367
    if (this->iv.m_Mode == -1 ) // ???BUFFERED_QUALITY_AUTO)
 
368
    {
 
369
        // adjust Quality - depends on how many cached frames we have
 
370
        int buffered = this->iv.m_iDecpos - this->iv.m_iPlaypos;
 
371
 
 
372
        if (this->m_bIsDivX || this->m_bIsDivX4)
 
373
        {
 
374
            int to = buffered - this->m_iMinBuffers;
 
375
            if (to < 0)
 
376
                to = 0;
 
377
            if (to != this->m_iLastQuality)
 
378
            {
 
379
                if (to > this->m_iMaxAuto)
 
380
                    to = this->m_iMaxAuto;
 
381
                if (this->m_iLastQuality != to)
 
382
                {
 
383
                    if (this->m_bIsDivX)
 
384
                    {
 
385
                        IHidden* hidden=(IHidden*)((int)this->m_pDS_Filter->m_pFilter + 0xb8);
 
386
                        hidden->vt->SetSmth(hidden, to, 0);
 
387
                    }
 
388
                    else
 
389
                        DS_VideoDecoder_SetValue(this, "Postprocessing", to);
 
390
#ifndef QUIET
 
391
                    //printf("Switching quality %d -> %d  b:%d\n",m_iLastQuality, to, buffered);
 
392
#endif
 
393
                }
 
394
            }
 
395
        }
 
396
    }
 
397
#endif
 
398
 
 
399
    return 0;
 
400
}
 
401
 
 
402
/*
 
403
 * bits == 0   - leave unchanged
 
404
 */
 
405
//int SetDestFmt(DS_VideoDecoder * this, int bits = 24, fourcc_t csp = 0);
 
406
int DS_VideoDecoder_SetDestFmt(DS_VideoDecoder *this, int bits, unsigned int csp)
 
407
{
 
408
    HRESULT result;
 
409
    ALLOCATOR_PROPERTIES props,props1;
 
410
    int should_test=1;
 
411
    int stopped = 0;
 
412
 
 
413
    Debug printf("DS_VideoDecoder_SetDestFmt (%p, %d, %d)\n",this,bits,(int)csp);
 
414
 
 
415
       /* if (!CImage::Supported(csp, bits))
 
416
        return -1;
 
417
*/
 
418
    // BitmapInfo temp = m_obh;
 
419
 
 
420
    if (!csp)   // RGB
 
421
    {
 
422
        int ok = true;
 
423
 
 
424
        switch (bits)
 
425
        {
 
426
        case 15:
 
427
            this->m_sDestType.subtype = MEDIASUBTYPE_RGB555;
 
428
            break;
 
429
        case 16:
 
430
            this->m_sDestType.subtype = MEDIASUBTYPE_RGB565;
 
431
            break;
 
432
        case 24:
 
433
            this->m_sDestType.subtype = MEDIASUBTYPE_RGB24;
 
434
            break;
 
435
        case 32:
 
436
            this->m_sDestType.subtype = MEDIASUBTYPE_RGB32;
 
437
            break;
 
438
        default:
 
439
            ok = false;
 
440
            break;
 
441
        }
 
442
 
 
443
        if (ok) {
 
444
            if (bits == 15)
 
445
                this->iv.m_obh.biBitCount=16;
 
446
            else
 
447
                this->iv.m_obh.biBitCount=bits;
 
448
            if( bits == 15 || bits == 16 ) {
 
449
              this->iv.m_obh.biSize=sizeof(BITMAPINFOHEADER)+12;
 
450
              this->iv.m_obh.biCompression=3;//BI_BITFIELDS
 
451
              this->iv.m_obh.biSizeImage=abs((int)(2*this->iv.m_obh.biWidth*this->iv.m_obh.biHeight));
 
452
            }
 
453
 
 
454
            if( bits == 16 ) {
 
455
              this->iv.m_obh.colors[0]=0xF800;
 
456
              this->iv.m_obh.colors[1]=0x07E0;
 
457
              this->iv.m_obh.colors[2]=0x001F;
 
458
            } else if ( bits == 15 ) {
 
459
              this->iv.m_obh.colors[0]=0x7C00;
 
460
              this->iv.m_obh.colors[1]=0x03E0;
 
461
              this->iv.m_obh.colors[2]=0x001F;
 
462
            } else {
 
463
              this->iv.m_obh.biSize = sizeof(BITMAPINFOHEADER);
 
464
              this->iv.m_obh.biCompression = 0; //BI_RGB
 
465
              //this->iv.m_obh.biHeight = labs(this->iv.m_obh.biHeight);
 
466
              this->iv.m_obh.biSizeImage = labs(this->iv.m_obh.biWidth * this->iv.m_obh.biHeight)
 
467
                              * ((this->iv.m_obh.biBitCount + 7) / 8);
 
468
            }
 
469
        }
 
470
        //.biSizeImage=abs(temp.biWidth*temp.biHeight*((temp.biBitCount+7)/8));
 
471
    } else
 
472
    {   // YUV
 
473
        int ok = true;
 
474
        switch (csp)
 
475
        {
 
476
        case fccYUY2:
 
477
            this->m_sDestType.subtype = MEDIASUBTYPE_YUY2;
 
478
            break;
 
479
        case fccYV12:
 
480
            this->m_sDestType.subtype = MEDIASUBTYPE_YV12;
 
481
            break;
 
482
        case fccIYUV:
 
483
            this->m_sDestType.subtype = MEDIASUBTYPE_IYUV;
 
484
            break;
 
485
        case fccI420:
 
486
            this->m_sDestType.subtype = MEDIASUBTYPE_I420;
 
487
            break;
 
488
        case fccUYVY:
 
489
            this->m_sDestType.subtype = MEDIASUBTYPE_UYVY;
 
490
            break;
 
491
        case fccYVYU:
 
492
            this->m_sDestType.subtype = MEDIASUBTYPE_YVYU;
 
493
            break;
 
494
        case fccYVU9:
 
495
            this->m_sDestType.subtype = MEDIASUBTYPE_YVU9;
 
496
        default:
 
497
            ok = false;
 
498
            break;
 
499
        }
 
500
 
 
501
        if (ok) {
 
502
          if (csp != 0 && csp != 3 && this->iv.m_obh.biHeight > 0)
 
503
            this->iv.m_obh.biHeight *= -1; // YUV formats uses should have height < 0
 
504
          this->iv.m_obh.biSize = sizeof(BITMAPINFOHEADER);
 
505
          this->iv.m_obh.biCompression=csp;
 
506
          this->iv.m_obh.biBitCount=bits;
 
507
          this->iv.m_obh.biSizeImage=labs(this->iv.m_obh.biBitCount*
 
508
             this->iv.m_obh.biWidth*this->iv.m_obh.biHeight)>>3;
 
509
        }
 
510
    }
 
511
    this->m_sDestType.lSampleSize = this->iv.m_obh.biSizeImage;
 
512
    memcpy(&(this->m_sVhdr2->bmiHeader), &this->iv.m_obh, sizeof(this->iv.m_obh));
 
513
    this->m_sVhdr2->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 
514
    if (this->m_sVhdr2->bmiHeader.biCompression == 3)
 
515
        this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER) + 12;
 
516
    else
 
517
        this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER);
 
518
 
 
519
 
 
520
    switch(csp)
 
521
    {
 
522
    case fccYUY2:
 
523
        if(!(this->m_Caps & CAP_YUY2))
 
524
            should_test=false;
 
525
        break;
 
526
    case fccYV12:
 
527
        if(!(this->m_Caps & CAP_YV12))
 
528
            should_test=false;
 
529
        break;
 
530
    case fccIYUV:
 
531
        if(!(this->m_Caps & CAP_IYUV))
 
532
            should_test=false;
 
533
        break;
 
534
    case fccI420:
 
535
        if(!(this->m_Caps & CAP_I420))
 
536
            should_test=false;
 
537
        break;
 
538
    case fccUYVY:
 
539
        if(!(this->m_Caps & CAP_UYVY))
 
540
            should_test=false;
 
541
        break;
 
542
    case fccYVYU:
 
543
        if(!(this->m_Caps & CAP_YVYU))
 
544
            should_test=false;
 
545
        break;
 
546
    case fccYVU9:
 
547
        if(!(this->m_Caps & CAP_YVU9))
 
548
            should_test=false;
 
549
        break;
 
550
    }
 
551
    if(should_test)
 
552
        result = this->m_pDS_Filter->m_pOutputPin->vt->QueryAccept(this->m_pDS_Filter->m_pOutputPin, &this->m_sDestType);
 
553
    else
 
554
        result = -1;
 
555
 
 
556
    if (result != 0)
 
557
    {
 
558
        if (csp)
 
559
            printf("Warning: unsupported color space\n");
 
560
        else
 
561
            printf("Warning: unsupported bit depth\n");
 
562
 
 
563
        this->m_sDestType.lSampleSize = this->iv.m_decoder.biSizeImage;
 
564
        memcpy(&(this->m_sVhdr2->bmiHeader), &this->iv.m_decoder, sizeof(this->iv.m_decoder));
 
565
        this->m_sVhdr2->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 
566
        if (this->m_sVhdr2->bmiHeader.biCompression == 3)
 
567
            this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER) + 12;
 
568
        else
 
569
            this->m_sDestType.cbFormat = sizeof(VIDEOINFOHEADER);
 
570
 
 
571
        return -1;
 
572
    }
 
573
 
 
574
    memcpy( &this->iv.m_decoder, &this->iv.m_obh, sizeof(this->iv.m_obh));
 
575
 
 
576
//    m_obh=temp;
 
577
//    if(csp)
 
578
//      m_obh.biBitCount=BitmapInfo::BitCount(csp);
 
579
    this->iv.m_bh->biBitCount = bits;
 
580
 
 
581
    //DS_VideoDecoder_Restart(this);
 
582
 
 
583
    if (this->iv.m_State == START)
 
584
    {
 
585
        DS_VideoDecoder_StopInternal(this);
 
586
        this->iv.m_State = STOP;
 
587
        stopped = true;
 
588
    }
 
589
 
 
590
    this->m_pDS_Filter->m_pInputPin->vt->Disconnect(this->m_pDS_Filter->m_pInputPin);
 
591
    this->m_pDS_Filter->m_pOutputPin->vt->Disconnect(this->m_pDS_Filter->m_pOutputPin);
 
592
    this->m_pDS_Filter->m_pOurOutput->SetNewFormat(this->m_pDS_Filter->m_pOurOutput,&this->m_sDestType);
 
593
    result = this->m_pDS_Filter->m_pInputPin->vt->ReceiveConnection(this->m_pDS_Filter->m_pInputPin,
 
594
                                                              this->m_pDS_Filter->m_pOurInput,
 
595
                                                              &this->m_sOurType);
 
596
    if (result)
 
597
    {
 
598
        printf("Error reconnecting input pin 0x%x\n", (int)result);
 
599
        return -1;
 
600
    }
 
601
 
 
602
    if(this->m_pDS_Filter->m_pAll)
 
603
        this->m_pDS_Filter->m_pAll->vt->Release(this->m_pDS_Filter->m_pAll);
 
604
    this->m_pDS_Filter->m_pAll=MemAllocatorCreate();
 
605
    if (!this->m_pDS_Filter->m_pAll)
 
606
    {
 
607
        printf("Call to MemAllocatorCreate failed\n");
 
608
        return -1;
 
609
    }
 
610
    //Seting allocator property according to our media type
 
611
    props.cBuffers=1;
 
612
    props.cbBuffer=this->m_sDestType.lSampleSize;
 
613
    props.cbAlign=1;
 
614
    props.cbPrefix=0;
 
615
    this->m_pDS_Filter->m_pAll->vt->SetProperties(this->m_pDS_Filter->m_pAll, &props, &props1);
 
616
    //Notify remote pin about choosed allocator
 
617
    this->m_pDS_Filter->m_pImp->vt->NotifyAllocator(this->m_pDS_Filter->m_pImp, this->m_pDS_Filter->m_pAll, 0);
 
618
 
 
619
    result = this->m_pDS_Filter->m_pOutputPin->vt->ReceiveConnection(this->m_pDS_Filter->m_pOutputPin,
 
620
                                                               (IPin *)this->m_pDS_Filter->m_pOurOutput,
 
621
                                                               &this->m_sDestType);
 
622
    if (result)
 
623
    {
 
624
        printf("Error reconnecting output pin 0x%x\n", (int)result);
 
625
        return -1;
 
626
    }
 
627
 
 
628
    if (stopped)
 
629
    {
 
630
        DS_VideoDecoder_StartInternal(this);
 
631
        this->iv.m_State = START;
 
632
    }
 
633
 
 
634
    return 0;
 
635
}
 
636
 
 
637
 
 
638
int DS_VideoDecoder_SetDirection(DS_VideoDecoder *this, int d)
 
639
{
 
640
    this->iv.m_obh.biHeight = (d) ? this->iv.m_bh->biHeight : -this->iv.m_bh->biHeight;
 
641
    this->m_sVhdr2->bmiHeader.biHeight = this->iv.m_obh.biHeight;
 
642
    return 0;
 
643
}
 
644
 
 
645
int DS_VideoDecoder_GetValue(DS_VideoDecoder *this, const char* name, int* value)
 
646
{
 
647
/*
 
648
    if (m_bIsDivX4)
 
649
    {
 
650
        IDivxFilterInterface* pIDivx;
 
651
        if (m_pDS_Filter->m_pFilter->vt->QueryInterface((IUnknown*)m_pDS_Filter->m_pFilter, &IID_IDivxFilterInterface, (void**)&pIDivx))
 
652
        {
 
653
            Debug printf("No such interface\n");
 
654
            return -1;
 
655
        }
 
656
        if (strcmp(name, "Postprocessing") == 0)
 
657
        {
 
658
            pIDivx->vt->get_PPLevel(pIDivx, &value);
 
659
            value /= 10;
 
660
        }
 
661
        else if (strcmp(name, "Brightness") == 0)
 
662
            pIDivx->vt->get_Brightness(pIDivx, &value);
 
663
        else if (strcmp(name, "Contrast") == 0)
 
664
            pIDivx->vt->get_Contrast(pIDivx, &value);
 
665
        else if (strcmp(name, "Saturation") == 0)
 
666
            pIDivx->vt->get_Saturation(pIDivx, &value);
 
667
        else if (strcmp(name, "MaxAuto") == 0)
 
668
            value = m_iMaxAuto;
 
669
        pIDivx->vt->Release((IUnknown*)pIDivx);
 
670
        return 0;
 
671
    }
 
672
    else if (m_bIsDivX)
 
673
    {
 
674
        if (m_State != START)
 
675
            return VFW_E_NOT_RUNNING;
 
676
// brightness 87
 
677
// contrast 74
 
678
// hue 23
 
679
// saturation 20
 
680
// post process mode 0
 
681
// get1 0x01
 
682
// get2 10
 
683
// get3=set2 86
 
684
// get4=set3 73
 
685
// get5=set4 19
 
686
// get6=set5 23
 
687
        IHidden* hidden=(IHidden*)((int)m_pDS_Filter->m_pFilter+0xb8);
 
688
        if (strcmp(name, "Quality") == 0)
 
689
        {
 
690
            // NOT SURE
 
691
            int r = hidden->vt->GetSmth2(hidden, &value);
 
692
            if (value >= 10)
 
693
                value -= 10;
 
694
            return 0;
 
695
        }
 
696
        if (strcmp(name, "Brightness") == 0)
 
697
            return hidden->vt->GetSmth3(hidden, &value);
 
698
        if (strcmp(name, "Contrast") == 0)
 
699
            return hidden->vt->GetSmth4(hidden, &value);
 
700
        if (strcmp(name, "Hue") == 0)
 
701
            return hidden->vt->GetSmth6(hidden, &value);
 
702
        if (strcmp(name, "Saturation") == 0)
 
703
            return hidden->vt->GetSmth5(hidden, &value);
 
704
        if (strcmp(name, "MaxAuto") == 0)
 
705
        {
 
706
            value = m_iMaxAuto;
 
707
            return 0;
 
708
        }
 
709
    }
 
710
    else if (strcmp((const char*)record.dll, "ir50_32.dll") == 0)
 
711
    {
 
712
        IHidden2* hidden = 0;
 
713
        if (m_pDS_Filter->m_pFilter->vt->QueryInterface((IUnknown*)m_pDS_Filter->m_pFilter, &IID_Iv50Hidden, (void**)&hidden))
 
714
        {
 
715
            Debug printf("No such interface\n");
 
716
            return -1;
 
717
        }
 
718
        // FIXME
 
719
        int recordpar[30];
 
720
        recordpar[0]=0x7c;
 
721
        recordpar[1]=fccIV50;
 
722
        recordpar[2]=0x10005;
 
723
        recordpar[3]=2;
 
724
        recordpar[4]=1;
 
725
        recordpar[5]=0x80000000;
 
726
 
 
727
        if (strcmp(name, "Brightness") == 0)
 
728
            recordpar[5]|=0x20;
 
729
        else if (strcmp(name, "Saturation") == 0)
 
730
            recordpar[5]|=0x40;
 
731
        else if (strcmp(name, "Contrast") == 0)
 
732
            recordpar[5]|=0x80;
 
733
        if (!recordpar[5])
 
734
        {
 
735
            hidden->vt->Release((IUnknown*)hidden);
 
736
            return -1;
 
737
        }
 
738
        if (hidden->vt->DecodeSet(hidden, recordpar))
 
739
            return -1;
 
740
 
 
741
        if (strcmp(name, "Brightness") == 0)
 
742
            value = recordpar[18];
 
743
        else if (strcmp(name, "Saturation") == 0)
 
744
            value = recordpar[19];
 
745
        else if (strcmp(name, "Contrast") == 0)
 
746
            value = recordpar[20];
 
747
 
 
748
        hidden->vt->Release((IUnknown*)hidden);
 
749
    }
 
750
*/
 
751
    return 0;
 
752
}
 
753
 
 
754
int DS_VideoDecoder_SetValue(DS_VideoDecoder *this, const char* name, int value)
 
755
{
 
756
    if (this->m_bIsDivX4) {
 
757
        IDivxFilterInterface* pIDivx=NULL;
 
758
//      printf("DS_SetValue for DIVX4, name=%s  value=%d\n",name,value);
 
759
        if (this->m_pDS_Filter->m_pFilter->vt->QueryInterface((IUnknown*)this->m_pDS_Filter->m_pFilter, &IID_IDivxFilterInterface, (void**)&pIDivx))
 
760
        {
 
761
            printf("No such interface\n");
 
762
            return -1;
 
763
        }
 
764
        if (strcasecmp(name, "Postprocessing") == 0)
 
765
            pIDivx->vt->put_PPLevel(pIDivx, value * 10);
 
766
        else if (strcasecmp(name, "Brightness") == 0)
 
767
            pIDivx->vt->put_Brightness(pIDivx, value);
 
768
        else if (strcasecmp(name, "Contrast") == 0)
 
769
            pIDivx->vt->put_Contrast(pIDivx, value);
 
770
        else if (strcasecmp(name, "Saturation") == 0)
 
771
            pIDivx->vt->put_Saturation(pIDivx, value);
 
772
        else if (strcasecmp(name, "MaxAuto") == 0)
 
773
            this->m_iMaxAuto = value;
 
774
        pIDivx->vt->Release((IUnknown*)pIDivx);
 
775
        //printf("Set %s  %d\n", name, value);
 
776
        return 0;
 
777
    }
 
778
 
 
779
    if (this->m_bIsDivX) {
 
780
        IHidden* hidden;
 
781
        if (this->iv.m_State != START)
 
782
            return VFW_E_NOT_RUNNING;
 
783
 
 
784
        //cout << "set value " << name << "  " << value << endl;
 
785
// brightness 87
 
786
// contrast 74
 
787
// hue 23
 
788
// saturation 20
 
789
// post process mode 0
 
790
// get1 0x01
 
791
// get2 10
 
792
// get3=set2 86
 
793
// get4=set3 73
 
794
// get5=set4 19
 
795
        // get6=set5 23
 
796
        hidden = (IHidden*)((int)this->m_pDS_Filter->m_pFilter + 0xb8);
 
797
        //printf("DS_SetValue for DIVX, name=%s  value=%d\n",name,value);
 
798
        if (strcasecmp(name, "Quality") == 0)
 
799
        {
 
800
            this->m_iLastQuality = value;
 
801
            return hidden->vt->SetSmth(hidden, value, 0);
 
802
        }
 
803
        if (strcasecmp(name, "Brightness") == 0)
 
804
            return hidden->vt->SetSmth2(hidden, value, 0);
 
805
        if (strcasecmp(name, "Contrast") == 0)
 
806
            return hidden->vt->SetSmth3(hidden, value, 0);
 
807
        if (strcasecmp(name, "Saturation") == 0)
 
808
            return hidden->vt->SetSmth4(hidden, value, 0);
 
809
        if (strcasecmp(name, "Hue") == 0)
 
810
            return hidden->vt->SetSmth5(hidden, value, 0);
 
811
        if (strcasecmp(name, "MaxAuto") == 0)
 
812
        {
 
813
            this->m_iMaxAuto = value;
 
814
        }
 
815
        return 0;
 
816
    }
 
817
#if 0
 
818
    if (strcmp((const char*)record.dll, "ir50_32.dll") == 0)
 
819
    {
 
820
        IHidden2* hidden = 0;
 
821
        if (m_pDS_Filter->m_pFilter->vt->QueryInterface((IUnknown*)m_pDS_Filter->m_pFilter, &IID_Iv50Hidden, (void**)&hidden))
 
822
        {
 
823
            Debug printf("No such interface\n");
 
824
            return -1;
 
825
        }
 
826
        int recordpar[30];
 
827
        recordpar[0]=0x7c;
 
828
        recordpar[1]=fccIV50;
 
829
        recordpar[2]=0x10005;
 
830
        recordpar[3]=2;
 
831
        recordpar[4]=1;
 
832
        recordpar[5]=0x80000000;
 
833
        if (strcmp(name, "Brightness") == 0)
 
834
        {
 
835
            recordpar[5]|=0x20;
 
836
            recordpar[18]=value;
 
837
        }
 
838
        else if (strcmp(name, "Saturation") == 0)
 
839
        {
 
840
            recordpar[5]|=0x40;
 
841
            recordpar[19]=value;
 
842
        }
 
843
        else if (strcmp(name, "Contrast") == 0)
 
844
        {
 
845
            recordpar[5]|=0x80;
 
846
            recordpar[20]=value;
 
847
        }
 
848
        if(!recordpar[5])
 
849
        {
 
850
            hidden->vt->Release((IUnknown*)hidden);
 
851
            return -1;
 
852
        }
 
853
        HRESULT result = hidden->vt->DecodeSet(hidden, recordpar);
 
854
        hidden->vt->Release((IUnknown*)hidden);
 
855
 
 
856
        return result;
 
857
    }
 
858
#endif
 
859
//    printf("DS_SetValue for ????, name=%s  value=%d\n",name,value);
 
860
    return 0;
 
861
}
 
862
 
 
863
int DS_SetAttr_DivX(char* attribute, int value){
 
864
    int result, status, newkey;
 
865
        if(strcasecmp(attribute, "Quality")==0){
 
866
            char* keyname="SOFTWARE\\Microsoft\\Scrunch";
 
867
            result=RegCreateKeyExA(HKEY_CURRENT_USER, keyname, 0, 0, 0, 0, 0,                   &newkey, &status);
 
868
            if(result!=0)
 
869
            {
 
870
                printf("VideoDecoder::SetExtAttr: registry failure\n");
 
871
                return -1;
 
872
            }
 
873
            result=RegSetValueExA(newkey, "Current Post Process Mode", 0, REG_DWORD, &value, 4);
 
874
            if(result!=0)
 
875
            {
 
876
                printf("VideoDecoder::SetExtAttr: error writing value\n");
 
877
                return -1;
 
878
            }
 
879
            value=-1;
 
880
            result=RegSetValueExA(newkey, "Force Post Process Mode", 0, REG_DWORD, &value, 4);
 
881
            if(result!=0)
 
882
            {
 
883
                printf("VideoDecoder::SetExtAttr: error writing value\n");
 
884
                return -1;
 
885
            }
 
886
            RegCloseKey(newkey);
 
887
            return 0;
 
888
        }
 
889
 
 
890
        if(
 
891
        (strcasecmp(attribute, "Saturation")==0) ||
 
892
        (strcasecmp(attribute, "Hue")==0) ||
 
893
        (strcasecmp(attribute, "Contrast")==0) ||
 
894
        (strcasecmp(attribute, "Brightness")==0)
 
895
        )
 
896
        {
 
897
            char* keyname="SOFTWARE\\Microsoft\\Scrunch\\Video";
 
898
            result=RegCreateKeyExA(HKEY_CURRENT_USER, keyname, 0, 0, 0, 0, 0,                   &newkey, &status);
 
899
            if(result!=0)
 
900
            {
 
901
                printf("VideoDecoder::SetExtAttr: registry failure\n");
 
902
                return -1;
 
903
            }
 
904
            result=RegSetValueExA(newkey, attribute, 0, REG_DWORD, &value, 4);
 
905
            if(result!=0)
 
906
            {
 
907
                printf("VideoDecoder::SetExtAttr: error writing value\n");
 
908
                return -1;
 
909
            }
 
910
            RegCloseKey(newkey);
 
911
            return 0;
 
912
        }
 
913
 
 
914
        printf("Unknown attribute!\n");
 
915
        return -200;
 
916
}