juce/source/src/native/windows/juce_win32_CameraDevice.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 // (This file gets included by juce_win32_NativeCode.cpp, rather than being
  27 // compiled on its own).
  28 #if JUCE_INCLUDED_FILE && JUCE_USE_CAMERA
  29
  30
  31 //==============================================================================
  32 class DShowCameraDeviceInteral  : public ChangeBroadcaster
  33 {
  34 public:
  35     DShowCameraDeviceInteral (CameraDevice* const owner_,
  36                               const ComSmartPtr <ICaptureGraphBuilder2>& captureGraphBuilder_,
  37                               const ComSmartPtr <IBaseFilter>& filter_,
  38                               int minWidth, int minHeight,
  39                               int maxWidth, int maxHeight)
  40       : owner (owner_),
  41         captureGraphBuilder (captureGraphBuilder_),
  42         filter (filter_),
  43         ok (false),
  44         imageNeedsFlipping (false),
  45         width (0),
  46         height (0),
  47         activeUsers (0),
  48         recordNextFrameTime (false),
  49         previewMaxFPS (60)
  50     {
  51         HRESULT hr = graphBuilder.CoCreateInstance (CLSID_FilterGraph);
  52         if (FAILED (hr))
  53             return;
  54
  55         hr = captureGraphBuilder->SetFiltergraph (graphBuilder);
  56         if (FAILED (hr))
  57             return;
  58
  59         hr = graphBuilder.QueryInterface (mediaControl);
  60         if (FAILED (hr))
  61             return;
  62
  63         {
  64             ComSmartPtr <IAMStreamConfig> streamConfig;
  65
  66             hr = captureGraphBuilder->FindInterface (&PIN_CATEGORY_CAPTURE, 0, filter,
  67                                                      IID_IAMStreamConfig, (void**) streamConfig.resetAndGetPointerAddress());
  68
  69             if (streamConfig != nullptr)
  70             {
  71                 getVideoSizes (streamConfig);
  72
  73                 if (! selectVideoSize (streamConfig, minWidth, minHeight, maxWidth, maxHeight))
  74                     return;
  75             }
  76         }
  77
  78         hr = graphBuilder->AddFilter (filter, _T("Video Capture"));
  79         if (FAILED (hr))
  80             return;
  81
  82         hr = smartTee.CoCreateInstance (CLSID_SmartTee);
  83         if (FAILED (hr))
  84             return;
  85
  86         hr = graphBuilder->AddFilter (smartTee, _T("Smart Tee"));
  87         if (FAILED (hr))
  88             return;
  89
  90         if (! connectFilters (filter, smartTee))
  91             return;
  92
  93         ComSmartPtr <IBaseFilter> sampleGrabberBase;
  94         hr = sampleGrabberBase.CoCreateInstance (CLSID_SampleGrabber);
  95         if (FAILED (hr))
  96             return;
  97
  98         hr = sampleGrabberBase.QueryInterface (sampleGrabber);
  99         if (FAILED (hr))
 100             return;
 101
 102         {
 103             AM_MEDIA_TYPE mt = { 0 };
 104             mt.majortype = MEDIATYPE_Video;
 105             mt.subtype = MEDIASUBTYPE_RGB24;
 106             mt.formattype = FORMAT_VideoInfo;
 107             sampleGrabber->SetMediaType (&mt);
 108         }
 109
 110         callback = new GrabberCallback (*this);
 111         hr = sampleGrabber->SetCallback (callback, 1);
 112
 113         hr = graphBuilder->AddFilter (sampleGrabberBase, _T("Sample Grabber"));
 114         if (FAILED (hr))
 115             return;
 116
 117         ComSmartPtr <IPin> grabberInputPin;
 118         if (! (getPin (smartTee, PINDIR_OUTPUT, smartTeeCaptureOutputPin, "capture")
 119                 && getPin (smartTee, PINDIR_OUTPUT, smartTeePreviewOutputPin, "preview")
 120                 && getPin (sampleGrabberBase, PINDIR_INPUT, grabberInputPin)))
 121             return;
 122
 123         hr = graphBuilder->Connect (smartTeePreviewOutputPin, grabberInputPin);
 124         if (FAILED (hr))
 125             return;
 126
 127         AM_MEDIA_TYPE mt = { 0 };
 128         hr = sampleGrabber->GetConnectedMediaType (&mt);
 129         VIDEOINFOHEADER* pVih = (VIDEOINFOHEADER*) (mt.pbFormat);
 130         width = pVih->bmiHeader.biWidth;
 131         height = pVih->bmiHeader.biHeight;
 132
 133         ComSmartPtr <IBaseFilter> nullFilter;
 134         hr = nullFilter.CoCreateInstance (CLSID_NullRenderer);
 135         hr = graphBuilder->AddFilter (nullFilter, _T("Null Renderer"));
 136
 137         if (connectFilters (sampleGrabberBase, nullFilter)
 138               && addGraphToRot())
 139         {
 140             activeImage = Image (Image::RGB, width, height, true);
 141             loadingImage = Image (Image::RGB, width, height, true);
 142
 143             ok = true;
 144         }
 145     }
 146
 147     ~DShowCameraDeviceInteral()
 148     {
 149         if (mediaControl != nullptr)
 150             mediaControl->Stop();
 151
 152         removeGraphFromRot();
 153
 154         for (int i = viewerComps.size(); --i >= 0;)
 155             viewerComps.getUnchecked(i)->ownerDeleted();
 156
 157         callback = nullptr;
 158         graphBuilder = nullptr;
 159         sampleGrabber = nullptr;
 160         mediaControl = nullptr;
 161         filter = nullptr;
 162         captureGraphBuilder = nullptr;
 163         smartTee = nullptr;
 164         smartTeePreviewOutputPin = nullptr;
 165         smartTeeCaptureOutputPin = nullptr;
 166         asfWriter = nullptr;
 167     }
 168
 169     void addUser()
 170     {
 171         if (ok && activeUsers++ == 0)
 172             mediaControl->Run();
 173     }
 174
 175     void removeUser()
 176     {
 177         if (ok && --activeUsers == 0)
 178             mediaControl->Stop();
 179     }
 180
 181     int getPreviewMaxFPS() const
 182     {
 183         return previewMaxFPS;
 184     }
 185
 186     void handleFrame (double /*time*/, BYTE* buffer, long /*bufferSize*/)
 187     {
 188         if (recordNextFrameTime)
 189         {
 190             const double defaultCameraLatency = 0.1;
 191
 192             firstRecordedTime = Time::getCurrentTime() - RelativeTime (defaultCameraLatency);
 193             recordNextFrameTime = false;
 194
 195             ComSmartPtr <IPin> pin;
 196             if (getPin (filter, PINDIR_OUTPUT, pin))
 197             {
 198                 ComSmartPtr <IAMPushSource> pushSource;
 199                 HRESULT hr = pin.QueryInterface (pushSource);
 200
 201                 if (pushSource != nullptr)
 202                 {
 203                     REFERENCE_TIME latency = 0;
 204                     hr = pushSource->GetLatency (&latency);
 205
 206                     firstRecordedTime = firstRecordedTime - RelativeTime ((double) latency);
 207                 }
 208             }
 209         }
 210
 211         {
 212             const int lineStride = width * 3;
 213             const ScopedLock sl (imageSwapLock);
 214
 215             {
 216                 const Image::BitmapData destData (loadingImage, 0, 0, width, height, Image::BitmapData::writeOnly);
 217
 218                 for (int i = 0; i < height; ++i)
 219                     memcpy (destData.getLinePointer ((height - 1) - i),
 220                             buffer + lineStride * i,
 221                             lineStride);
 222             }
 223
 224             imageNeedsFlipping = true;
 225         }
 226
 227         if (listeners.size() > 0)
 228             callListeners (loadingImage);
 229
 230         sendChangeMessage();
 231     }
 232
 233     void drawCurrentImage (Graphics& g, int x, int y, int w, int h)
 234     {
 235         if (imageNeedsFlipping)
 236         {
 237             const ScopedLock sl (imageSwapLock);
 238             swapVariables (loadingImage, activeImage);
 239             imageNeedsFlipping = false;
 240         }
 241
 242         RectanglePlacement rp (RectanglePlacement::centred);
 243         double dx = 0, dy = 0, dw = width, dh = height;
 244         rp.applyTo (dx, dy, dw, dh, x, y, w, h);
 245         const int rx = roundToInt (dx), ry = roundToInt (dy);
 246         const int rw = roundToInt (dw), rh = roundToInt (dh);
 247
 248         {
 249             Graphics::ScopedSaveState ss (g);
 250
 251             g.excludeClipRegion (Rectangle<int> (rx, ry, rw, rh));
 252             g.fillAll (Colours::black);
 253         }
 254
 255         g.drawImage (activeImage, rx, ry, rw, rh, 0, 0, width, height);
 256     }
 257
 258     bool createFileCaptureFilter (const File& file, int quality)
 259     {
 260         removeFileCaptureFilter();
 261         file.deleteFile();
 262         mediaControl->Stop();
 263         firstRecordedTime = Time();
 264         recordNextFrameTime = true;
 265         previewMaxFPS = 60;
 266
 267         HRESULT hr = asfWriter.CoCreateInstance (CLSID_WMAsfWriter);
 268
 269         if (SUCCEEDED (hr))
 270         {
 271             ComSmartPtr <IFileSinkFilter> fileSink;
 272             hr = asfWriter.QueryInterface (fileSink);
 273
 274             if (SUCCEEDED (hr))
 275             {
 276                 hr = fileSink->SetFileName (file.getFullPathName().toWideCharPointer(), 0);
 277
 278                 if (SUCCEEDED (hr))
 279                 {
 280                     hr = graphBuilder->AddFilter (asfWriter, _T("AsfWriter"));
 281
 282                     if (SUCCEEDED (hr))
 283                     {
 284                         ComSmartPtr <IConfigAsfWriter> asfConfig;
 285                         hr = asfWriter.QueryInterface (asfConfig);
 286                         asfConfig->SetIndexMode (true);
 287                         ComSmartPtr <IWMProfileManager> profileManager;
 288                         hr = WMCreateProfileManager (profileManager.resetAndGetPointerAddress());
 289
 290                         // This gibberish is the DirectShow profile for a video-only wmv file.
 291                         String prof ("<profile version=\"589824\" storageformat=\"1\" name=\"Quality\" description=\"Quality type for output.\">"
 292                                        "<streamconfig majortype=\"{73646976-0000-0010-8000-00AA00389B71}\" streamnumber=\"1\" "
 293                                                      "streamname=\"Video Stream\" inputname=\"Video409\" bitrate=\"894960\" "
 294                                                      "bufferwindow=\"0\" reliabletransport=\"1\" decodercomplexity=\"AU\" rfc1766langid=\"en-us\">"
 295                                          "<videomediaprops maxkeyframespacing=\"50000000\" quality=\"90\"/>"
 296                                          "<wmmediatype subtype=\"{33564D57-0000-0010-8000-00AA00389B71}\" bfixedsizesamples=\"0\" "
 297                                                       "btemporalcompression=\"1\" lsamplesize=\"0\">"
 298                                          "<videoinfoheader dwbitrate=\"894960\" dwbiterrorrate=\"0\" avgtimeperframe=\"$AVGTIMEPERFRAME\">"
 299                                              "<rcsource left=\"0\" top=\"0\" right=\"$WIDTH\" bottom=\"$HEIGHT\"/>"
 300                                              "<rctarget left=\"0\" top=\"0\" right=\"$WIDTH\" bottom=\"$HEIGHT\"/>"
 301                                              "<bitmapinfoheader biwidth=\"$WIDTH\" biheight=\"$HEIGHT\" biplanes=\"1\" bibitcount=\"24\" "
 302                                                                "bicompression=\"WMV3\" bisizeimage=\"0\" bixpelspermeter=\"0\" biypelspermeter=\"0\" "
 303                                                                "biclrused=\"0\" biclrimportant=\"0\"/>"
 304                                            "</videoinfoheader>"
 305                                          "</wmmediatype>"
 306                                        "</streamconfig>"
 307                                      "</profile>");
 308
 309                         const int fps[] = { 10, 15, 30 };
 310                         int maxFramesPerSecond = fps [jlimit (0, numElementsInArray (fps) - 1, quality & 0xff)];
 311
 312                         if ((quality & 0xff000000) != 0) // (internal hacky way to pass explicit frame rates for testing)
 313                             maxFramesPerSecond = (quality >> 24) & 0xff;
 314
 315                         prof = prof.replace ("$WIDTH", String (width))
 316                                    .replace ("$HEIGHT", String (height))
 317                                    .replace ("$AVGTIMEPERFRAME", String (10000000 / maxFramesPerSecond));
 318
 319                         ComSmartPtr <IWMProfile> currentProfile;
 320                         hr = profileManager->LoadProfileByData (prof.toWideCharPointer(), currentProfile.resetAndGetPointerAddress());
 321                         hr = asfConfig->ConfigureFilterUsingProfile (currentProfile);
 322
 323                         if (SUCCEEDED (hr))
 324                         {
 325                             ComSmartPtr <IPin> asfWriterInputPin;
 326
 327                             if (getPin (asfWriter, PINDIR_INPUT, asfWriterInputPin, "Video Input 01"))
 328                             {
 329                                 hr = graphBuilder->Connect (smartTeeCaptureOutputPin, asfWriterInputPin);
 330
 331                                 if (SUCCEEDED (hr) && ok && activeUsers > 0
 332                                      && SUCCEEDED (mediaControl->Run()))
 333                                 {
 334                                     previewMaxFPS = (quality < 2) ? 15 : 25; // throttle back the preview comps to try to leave the cpu free for encoding
 335
 336                                     if ((quality & 0x00ff0000) != 0)  // (internal hacky way to pass explicit frame rates for testing)
 337                                         previewMaxFPS = (quality >> 16) & 0xff;
 338
 339                                     return true;
 340                                 }
 341                             }
 342                         }
 343                     }
 344                 }
 345             }
 346         }
 347
 348         removeFileCaptureFilter();
 349
 350         if (ok && activeUsers > 0)
 351             mediaControl->Run();
 352
 353         return false;
 354     }
 355
 356     void removeFileCaptureFilter()
 357     {
 358         mediaControl->Stop();
 359
 360         if (asfWriter != nullptr)
 361         {
 362             graphBuilder->RemoveFilter (asfWriter);
 363             asfWriter = nullptr;
 364         }
 365
 366         if (ok && activeUsers > 0)
 367             mediaControl->Run();
 368
 369         previewMaxFPS = 60;
 370     }
 371
 372     //==============================================================================
 373     void addListener (CameraDevice::Listener* listenerToAdd)
 374     {
 375         const ScopedLock sl (listenerLock);
 376
 377         if (listeners.size() == 0)
 378             addUser();
 379
 380         listeners.addIfNotAlreadyThere (listenerToAdd);
 381     }
 382
 383     void removeListener (CameraDevice::Listener* listenerToRemove)
 384     {
 385         const ScopedLock sl (listenerLock);
 386         listeners.removeValue (listenerToRemove);
 387
 388         if (listeners.size() == 0)
 389             removeUser();
 390     }
 391
 392     void callListeners (const Image& image)
 393     {
 394         const ScopedLock sl (listenerLock);
 395
 396         for (int i = listeners.size(); --i >= 0;)
 397         {
 398             CameraDevice::Listener* const l = listeners[i];
 399
 400             if (l != nullptr)
 401                 l->imageReceived (image);
 402         }
 403     }
 404
 405
 406     //==============================================================================
 407     class DShowCaptureViewerComp   : public Component,
 408                                      public ChangeListener
 409     {
 410     public:
 411         DShowCaptureViewerComp (DShowCameraDeviceInteral* const owner_)
 412             : owner (owner_), maxFPS (15), lastRepaintTime (0)
 413         {
 414             setOpaque (true);
 415             owner->addChangeListener (this);
 416             owner->addUser();
 417             owner->viewerComps.add (this);
 418             setSize (owner->width, owner->height);
 419         }
 420
 421         ~DShowCaptureViewerComp()
 422         {
 423             if (owner != nullptr)
 424             {
 425                 owner->viewerComps.removeValue (this);
 426                 owner->removeUser();
 427                 owner->removeChangeListener (this);
 428             }
 429         }
 430
 431         void ownerDeleted()
 432         {
 433             owner = nullptr;
 434         }
 435
 436         void paint (Graphics& g)
 437         {
 438             g.setColour (Colours::black);
 439             g.setImageResamplingQuality (Graphics::lowResamplingQuality);
 440
 441             if (owner != nullptr)
 442                 owner->drawCurrentImage (g, 0, 0, getWidth(), getHeight());
 443             else
 444                 g.fillAll (Colours::black);
 445         }
 446
 447         void changeListenerCallback (ChangeBroadcaster*)
 448         {
 449             const int64 now = Time::currentTimeMillis();
 450
 451             if (now >= lastRepaintTime + (1000 / maxFPS))
 452             {
 453                 lastRepaintTime = now;
 454                 repaint();
 455
 456                 if (owner != nullptr)
 457                     maxFPS = owner->getPreviewMaxFPS();
 458             }
 459         }
 460
 461     private:
 462         DShowCameraDeviceInteral* owner;
 463         int maxFPS;
 464         int64 lastRepaintTime;
 465     };
 466
 467     //==============================================================================
 468     bool ok;
 469     int width, height;
 470     Time firstRecordedTime;
 471
 472     Array <DShowCaptureViewerComp*> viewerComps;
 473
 474 private:
 475     CameraDevice* const owner;
 476     ComSmartPtr <ICaptureGraphBuilder2> captureGraphBuilder;
 477     ComSmartPtr <IBaseFilter> filter;
 478     ComSmartPtr <IBaseFilter> smartTee;
 479     ComSmartPtr <IGraphBuilder> graphBuilder;
 480     ComSmartPtr <ISampleGrabber> sampleGrabber;
 481     ComSmartPtr <IMediaControl> mediaControl;
 482     ComSmartPtr <IPin> smartTeePreviewOutputPin;
 483     ComSmartPtr <IPin> smartTeeCaptureOutputPin;
 484     ComSmartPtr <IBaseFilter> asfWriter;
 485     int activeUsers;
 486     Array <int> widths, heights;
 487     DWORD graphRegistrationID;
 488
 489     CriticalSection imageSwapLock;
 490     bool imageNeedsFlipping;
 491     Image loadingImage;
 492     Image activeImage;
 493
 494     bool recordNextFrameTime;
 495     int previewMaxFPS;
 496
 497     void getVideoSizes (IAMStreamConfig* const streamConfig)
 498     {
 499         widths.clear();
 500         heights.clear();
 501
 502         int count = 0, size = 0;
 503         streamConfig->GetNumberOfCapabilities (&count, &size);
 504
 505         if (size == sizeof (VIDEO_STREAM_CONFIG_CAPS))
 506         {
 507             for (int i = 0; i < count; ++i)
 508             {
 509                 VIDEO_STREAM_CONFIG_CAPS scc;
 510                 AM_MEDIA_TYPE* config;
 511
 512                 HRESULT hr = streamConfig->GetStreamCaps (i, &config, (BYTE*) &scc);
 513
 514                 if (SUCCEEDED (hr))
 515                 {
 516                     const int w = scc.InputSize.cx;
 517                     const int h = scc.InputSize.cy;
 518
 519                     bool duplicate = false;
 520
 521                     for (int j = widths.size(); --j >= 0;)
 522                     {
 523                         if (w == widths.getUnchecked (j) && h == heights.getUnchecked (j))
 524                         {
 525                             duplicate = true;
 526                             break;
 527                         }
 528                     }
 529
 530                     if (! duplicate)
 531                     {
 532                         DBG ("Camera capture size: " + String (w) + ", " + String (h));
 533                         widths.add (w);
 534                         heights.add (h);
 535                     }
 536
 537                     deleteMediaType (config);
 538                 }
 539             }
 540         }
 541     }
 542
 543     bool selectVideoSize (IAMStreamConfig* const streamConfig,
 544                           const int minWidth, const int minHeight,
 545                           const int maxWidth, const int maxHeight)
 546     {
 547         int count = 0, size = 0, bestArea = 0, bestIndex = -1;
 548         streamConfig->GetNumberOfCapabilities (&count, &size);
 549
 550         if (size == sizeof (VIDEO_STREAM_CONFIG_CAPS))
 551         {
 552             AM_MEDIA_TYPE* config;
 553             VIDEO_STREAM_CONFIG_CAPS scc;
 554
 555             for (int i = 0; i < count; ++i)
 556             {
 557                 HRESULT hr = streamConfig->GetStreamCaps (i, &config, (BYTE*) &scc);
 558
 559                 if (SUCCEEDED (hr))
 560                 {
 561                     if (scc.InputSize.cx >= minWidth
 562                          && scc.InputSize.cy >= minHeight
 563                          && scc.InputSize.cx <= maxWidth
 564                          && scc.InputSize.cy <= maxHeight)
 565                     {
 566                         int area = scc.InputSize.cx * scc.InputSize.cy;
 567                         if (area > bestArea)
 568                         {
 569                             bestIndex = i;
 570                             bestArea = area;
 571                         }
 572                     }
 573
 574                     deleteMediaType (config);
 575                 }
 576             }
 577
 578             if (bestIndex >= 0)
 579             {
 580                 HRESULT hr = streamConfig->GetStreamCaps (bestIndex, &config, (BYTE*) &scc);
 581
 582                 hr = streamConfig->SetFormat (config);
 583                 deleteMediaType (config);
 584                 return SUCCEEDED (hr);
 585             }
 586         }
 587
 588         return false;
 589     }
 590
 591     static bool getPin (IBaseFilter* filter, const PIN_DIRECTION wantedDirection,
 592                         ComSmartPtr<IPin>& result, const char* pinName = nullptr)
 593     {
 594         ComSmartPtr <IEnumPins> enumerator;
 595         ComSmartPtr <IPin> pin;
 596
 597         filter->EnumPins (enumerator.resetAndGetPointerAddress());
 598
 599         while (enumerator->Next (1, pin.resetAndGetPointerAddress(), 0) == S_OK)
 600         {
 601             PIN_DIRECTION dir;
 602             pin->QueryDirection (&dir);
 603
 604             if (wantedDirection == dir)
 605             {
 606                 PIN_INFO info = { 0 };
 607                 pin->QueryPinInfo (&info);
 608
 609                 if (pinName == nullptr || String (pinName).equalsIgnoreCase (String (info.achName)))
 610                 {
 611                     result = pin;
 612                     return true;
 613                 }
 614             }
 615         }
 616
 617         return false;
 618     }
 619
 620     bool connectFilters (IBaseFilter* const first, IBaseFilter* const second) const
 621     {
 622         ComSmartPtr <IPin> in, out;
 623
 624         return getPin (first, PINDIR_OUTPUT, out)
 625                 && getPin (second, PINDIR_INPUT, in)
 626                 && SUCCEEDED (graphBuilder->Connect (out, in));
 627     }
 628
 629     bool addGraphToRot()
 630     {
 631         ComSmartPtr <IRunningObjectTable> rot;
 632         if (FAILED (GetRunningObjectTable (0, rot.resetAndGetPointerAddress())))
 633             return false;
 634
 635         ComSmartPtr <IMoniker> moniker;
 636         WCHAR buffer[128];
 637         HRESULT hr = CreateItemMoniker (_T("!"), buffer, moniker.resetAndGetPointerAddress());
 638         if (FAILED (hr))
 639             return false;
 640
 641         graphRegistrationID = 0;
 642         return SUCCEEDED (rot->Register (0, graphBuilder, moniker, &graphRegistrationID));
 643     }
 644
 645     void removeGraphFromRot()
 646     {
 647         ComSmartPtr <IRunningObjectTable> rot;
 648
 649         if (SUCCEEDED (GetRunningObjectTable (0, rot.resetAndGetPointerAddress())))
 650             rot->Revoke (graphRegistrationID);
 651     }
 652
 653     static void deleteMediaType (AM_MEDIA_TYPE* const pmt)
 654     {
 655         if (pmt->cbFormat != 0)
 656             CoTaskMemFree ((PVOID) pmt->pbFormat);
 657
 658         if (pmt->pUnk != nullptr)
 659             pmt->pUnk->Release();
 660
 661         CoTaskMemFree (pmt);
 662     }
 663
 664     //==============================================================================
 665     class GrabberCallback   : public ComBaseClassHelper <ISampleGrabberCB>
 666     {
 667     public:
 668         GrabberCallback (DShowCameraDeviceInteral& owner_)
 669             : owner (owner_)
 670         {
 671         }
 672
 673         //==============================================================================
 674         STDMETHODIMP SampleCB (double /*SampleTime*/, IMediaSample* /*pSample*/)
 675         {
 676             return E_FAIL;
 677         }
 678
 679         STDMETHODIMP BufferCB (double time, BYTE* buffer, long bufferSize)
 680         {
 681             owner.handleFrame (time, buffer, bufferSize);
 682             return S_OK;
 683         }
 684
 685     private:
 686         DShowCameraDeviceInteral& owner;
 687
 688         GrabberCallback (const GrabberCallback&);
 689         GrabberCallback& operator= (const GrabberCallback&);
 690     };
 691
 692     ComSmartPtr <GrabberCallback> callback;
 693     Array <CameraDevice::Listener*> listeners;
 694     CriticalSection listenerLock;
 695
 696     //==============================================================================
 697     JUCE_DECLARE_NON_COPYABLE (DShowCameraDeviceInteral);
 698 };
 699
 700
 701 //==============================================================================
 702 CameraDevice::CameraDevice (const String& name_, int /*index*/)
 703     : name (name_)
 704 {
 705     isRecording = false;
 706 }
 707
 708 CameraDevice::~CameraDevice()
 709 {
 710     stopRecording();
 711     delete static_cast <DShowCameraDeviceInteral*> (internal);
 712     internal = nullptr;
 713 }
 714
 715 Component* CameraDevice::createViewerComponent()
 716 {
 717     return new DShowCameraDeviceInteral::DShowCaptureViewerComp (static_cast <DShowCameraDeviceInteral*> (internal));
 718 }
 719
 720 String CameraDevice::getFileExtension()
 721 {
 722     return ".wmv";
 723 }
 724
 725 void CameraDevice::startRecordingToFile (const File& file, int quality)
 726 {
 727     stopRecording();
 728
 729     DShowCameraDeviceInteral* const d = (DShowCameraDeviceInteral*) internal;
 730     d->addUser();
 731     isRecording = d->createFileCaptureFilter (file, quality);
 732 }
 733
 734 Time CameraDevice::getTimeOfFirstRecordedFrame() const
 735 {
 736     DShowCameraDeviceInteral* const d = (DShowCameraDeviceInteral*) internal;
 737     return d->firstRecordedTime;
 738 }
 739
 740 void CameraDevice::stopRecording()
 741 {
 742     if (isRecording)
 743     {
 744         DShowCameraDeviceInteral* const d = (DShowCameraDeviceInteral*) internal;
 745         d->removeFileCaptureFilter();
 746         d->removeUser();
 747         isRecording = false;
 748     }
 749 }
 750
 751 void CameraDevice::addListener (Listener* listenerToAdd)
 752 {
 753     DShowCameraDeviceInteral* const d = (DShowCameraDeviceInteral*) internal;
 754
 755     if (listenerToAdd != nullptr)
 756         d->addListener (listenerToAdd);
 757 }
 758
 759 void CameraDevice::removeListener (Listener* listenerToRemove)
 760 {
 761     DShowCameraDeviceInteral* const d = (DShowCameraDeviceInteral*) internal;
 762
 763     if (listenerToRemove != nullptr)
 764         d->removeListener (listenerToRemove);
 765 }
 766
 767
 768 //==============================================================================
 769 namespace
 770 {
 771     ComSmartPtr <IBaseFilter> enumerateCameras (StringArray* const names,
 772                                                 const int deviceIndexToOpen,
 773                                                 String& name)
 774     {
 775         int index = 0;
 776         ComSmartPtr <IBaseFilter> result;
 777
 778         ComSmartPtr <ICreateDevEnum> pDevEnum;
 779         HRESULT hr = pDevEnum.CoCreateInstance (CLSID_SystemDeviceEnum);
 780
 781         if (SUCCEEDED (hr))
 782         {
 783             ComSmartPtr <IEnumMoniker> enumerator;
 784             hr = pDevEnum->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, enumerator.resetAndGetPointerAddress(), 0);
 785
 786             if (SUCCEEDED (hr) && enumerator != nullptr)
 787             {
 788                 ComSmartPtr <IMoniker> moniker;
 789                 ULONG fetched;
 790
 791                 while (enumerator->Next (1, moniker.resetAndGetPointerAddress(), &fetched) == S_OK)
 792                 {
 793                     ComSmartPtr <IBaseFilter> captureFilter;
 794                     hr = moniker->BindToObject (0, 0, IID_IBaseFilter, (void**) captureFilter.resetAndGetPointerAddress());
 795
 796                     if (SUCCEEDED (hr))
 797                     {
 798                         ComSmartPtr <IPropertyBag> propertyBag;
 799                         hr = moniker->BindToStorage (0, 0, IID_IPropertyBag, (void**) propertyBag.resetAndGetPointerAddress());
 800
 801                         if (SUCCEEDED (hr))
 802                         {
 803                             VARIANT var;
 804                             var.vt = VT_BSTR;
 805
 806                             hr = propertyBag->Read (_T("FriendlyName"), &var, 0);
 807                             propertyBag = nullptr;
 808
 809                             if (SUCCEEDED (hr))
 810                             {
 811                                 if (names != nullptr)
 812                                     names->add (var.bstrVal);
 813
 814                                 if (index == deviceIndexToOpen)
 815                                 {
 816                                     name = var.bstrVal;
 817                                     result = captureFilter;
 818                                     break;
 819                                 }
 820
 821                                 ++index;
 822                             }
 823                         }
 824                     }
 825                 }
 826             }
 827         }
 828
 829         return result;
 830     }
 831 }
 832
 833 StringArray CameraDevice::getAvailableDevices()
 834 {
 835     StringArray devs;
 836     String dummy;
 837     enumerateCameras (&devs, -1, dummy);
 838     return devs;
 839 }
 840
 841 CameraDevice* CameraDevice::openDevice (int index,
 842                                         int minWidth, int minHeight,
 843                                         int maxWidth, int maxHeight)
 844 {
 845     ComSmartPtr <ICaptureGraphBuilder2> captureGraphBuilder;
 846     HRESULT hr = captureGraphBuilder.CoCreateInstance (CLSID_CaptureGraphBuilder2);
 847
 848     if (SUCCEEDED (hr))
 849     {
 850         String name;
 851         const ComSmartPtr <IBaseFilter> filter (enumerateCameras (0, index, name));
 852
 853         if (filter != nullptr)
 854         {
 855             ScopedPointer <CameraDevice> cam (new CameraDevice (name, index));
 856
 857             DShowCameraDeviceInteral* const intern
 858                 = new DShowCameraDeviceInteral (cam, captureGraphBuilder, filter,
 859                                                 minWidth, minHeight, maxWidth, maxHeight);
 860             cam->internal = intern;
 861
 862             if (intern->ok)
 863                 return cam.release();
 864         }
 865     }
 866
 867     return nullptr;
 868 }
 869
 870
 871 #endif