source: trunk/src/testing/app/DecklinkCapture/decklinkcapture.cpp @ 4

#include "DeckLinkAPI.h"
#include <stdio.h>
#include <unistd.h>
#include <string.h>

// headers for SAGE
#include "sail.h"
#include "misc.h"


void    print_input_modes (IDeckLink* deckLink);
void    print_output_modes (IDeckLink* deckLink);

void    print_input_capabilities (IDeckLink* deckLink);
void    print_output_capabilities (IDeckLink* deckLink);

void    print_capabilities();
void    capture(int device, int mode, int connection);

sail sageInf; // sail object
void *PixelFrame;

// 1080i
//int winWidth = 1920;
//int winHeight = 1080;

// 720p
//int winWidth = 1280;
//int winHeight = 720;

// PAL
int winWidth = 720;
int winHeight = 576;

// NTSC
//int winWidth = 720;
//int winHeight = 486;



int main (int argc, char** argv)
{
    int done = 0;
    

        if (argc == 1) {
                fprintf(stderr, "Decklink Capture Program\n");
        }
        else {
                if ( (argc==2) && (!strcmp(argv[1],"-h")) ) {
                        fprintf(stderr, "Usage> %s \n", argv[0]);
                        fprintf(stderr, "\t\t\t -l\tlist capabilities\n");
                        fprintf(stderr, "\t\t\t -i input mode\tSelect a capture settings\n");
                }
                if ( (argc==2) && (!strcmp(argv[1],"-l")) ) {
                        print_capabilities();
                }
                if ( (argc==4) && (!strcmp(argv[1],"-i")) ) {

                int card = 0;
                int mode = atoi(argv[2]);
                int connexion = atoi(argv[3]);

                // SAGE setup
            sailConfig cfg;
            cfg.init("decklinkcapture.conf");   // every app has a config file named "appName.conf"
            std::cout << "SAIL configuration was initialized by decklinkcapture.conf" << std::endl;
         
            cfg.setAppName("decklinkcapture");
            cfg.rank = 0;
            cfg.resX = winWidth;
            cfg.resY = winHeight;
            cfg.winWidth = winWidth;
            cfg.winHeight = winHeight;

            sageRect renderImageMap;
            renderImageMap.left = 0.0;
            renderImageMap.right = 1.0;
            renderImageMap.bottom = 0.0;
            renderImageMap.top = 1.0;

            cfg.imageMap = renderImageMap;
            cfg.pixFmt = PIXFMT_YUV;
            cfg.rowOrd = TOP_TO_BOTTOM;
            cfg.master = true;
                         
            sageInf.init(cfg);
            std::cout << "sail initialized " << std::endl;
            
                // Capture setup
                capture(card, mode, connexion);
            //capture(0, 3, 1); // 0: card0, 3: 1080i 50, 1: HDMI
            //capture(0, 5, 1); // HD 1080i 59.94
            //capture(0, 4, 2); // HD 1080i 59.94 Component
            //capture(0, 5, 1); // HD 1080i 60
            //capture(0, 2, 1); // PAL
            //capture(0, 0, 1); // NTSC
 
                // Just wait and process messages
            while (!done) {
                sageMessage msg;
                
                if (sageInf.checkMsg(msg, false) > 0) {
                    switch (msg.getCode()) {
                        case APP_QUIT : {
                            exit(0);
                            break;
                        }
                    }
                }   
                sleep(1);
            }
            
                }
        }

        return 0;
}

class VideoDelegate : public IDeckLinkInputCallback
{
private:
        int32_t mRefCount;
        double  lastTime;
    int     framecount;
    
public:
    VideoDelegate () {
         framecount = 0;
    };
                                                
        virtual HRESULT         QueryInterface (REFIID iid, LPVOID *ppv)
        {};
        virtual ULONG           AddRef (void) {
        return mRefCount++;
    };
        virtual ULONG           Release (void) {
        int32_t         newRefValue;
        
        newRefValue = mRefCount--;
        if (newRefValue == 0)
        {
            delete this;
            return 0;
        }        
        return newRefValue;
    };

        virtual HRESULT VideoInputFrameArrived (IDeckLinkVideoInputFrame* arrivedFrame,
                                                IDeckLinkAudioInputPacket*);
        virtual HRESULT VideoInputFormatChanged(BMDVideoInputFormatChangedEvents, IDeckLinkDisplayMode*, BMDDetectedVideoInputFormatFlags)
        {};

};

HRESULT VideoDelegate::VideoInputFrameArrived (IDeckLinkVideoInputFrame* arrivedFrame,
                                               IDeckLinkAudioInputPacket*)
{
                BMDTimeValue            frameTime, frameDuration;
                int                                     hours, minutes, seconds, frames;
                HRESULT                         theResult;
                
                arrivedFrame->GetStreamTime(&frameTime, &frameDuration, 600);
                
                hours = (frameTime / (600 * 60*60));
                minutes = (frameTime / (600 * 60)) % 60;
                seconds = (frameTime / 600) % 60;
                frames = (frameTime / 6) % 100;
                //fprintf(stderr, "frame> %02d:%02d:%02d:%02d", hours, minutes, seconds, frames);
                //fprintf(stderr, "\t %dx%d\r", arrivedFrame->GetWidth(), arrivedFrame->GetHeight() );

        arrivedFrame->GetBytes(&PixelFrame);
        unsigned char *rgbBuffer = (unsigned char *)sageInf.getBuffer();
        memcpy(rgbBuffer, PixelFrame, arrivedFrame->GetWidth()*arrivedFrame->GetHeight()*2);
        sageInf.swapBuffer();
    
#if 0
        char fn[128];
        memset(fn, 0, 128);
        sprintf(fn, "frame%04d.yuv", framecount);
        FILE *f=fopen(fn, "w+");
        fwrite(PixelFrame, 1, 1920*1080*2, f);
        fclose(f);
#endif   

        framecount++;
        
        return S_OK;

}


void capture(int device, int mode, int connection)
{
    int dnum, mnum, cnum;
        int     itemCount;
   
        IDeckLinkIterator *deckLinkIterator;
        IDeckLink         *deckLink;
        HRESULT            result;

        IDeckLinkInput*               deckLinkInput = NULL;
        IDeckLinkDisplayModeIterator* displayModeIterator = NULL;
        IDeckLinkDisplayMode*         displayMode = NULL;
        IDeckLinkConfiguration       *deckLinkConfiguration = NULL;
    VideoDelegate                *delegate;

//     PixelFrame = (void*)malloc(1920*1080*2);
//     memset(PixelFrame, 0, 1920*1080*2);;
    

    fprintf(stderr, "Starting> Capture on device %d, mode %d, connection %d\n", device, mode, connection);
    
        // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
        deckLinkIterator = CreateDeckLinkIteratorInstance();
        if (deckLinkIterator == NULL)
        {
                fprintf(stderr, "A DeckLink iterator could not be created (DeckLink drivers may not be installed).\n");
                return;
        }

    dnum = 0;
    deckLink = NULL;
    
        while (deckLinkIterator->Next(&deckLink) == S_OK)
        {
        if (device != dnum) {
            dnum++;
                // Release the IDeckLink instance when we've finished with it to prevent leaks
            deckLink->Release();
            continue;
        }
        dnum++;
        
                const char *deviceNameString = NULL;
                
            // *** Print the model name of the DeckLink card
                result = deckLink->GetModelName(&deviceNameString);
                if (result == S_OK)
                {
                        char deviceName[64];    
                        fprintf(stderr, "Using device [%s]\n", deviceNameString);

                // Query the DeckLink for its configuration interface
            result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput);
            if (result != S_OK)
            {
                fprintf(stderr, "Could not obtain the IDeckLinkInput interface - result = %08x\n", result);
                return;
            }

                // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on input
            result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
            if (result != S_OK)
            {
                fprintf(stderr, "Could not obtain the video input display mode iterator - result = %08x\n", result);
                return;
            }

            mnum = 0;
            while (displayModeIterator->Next(&displayMode) == S_OK)
            {
                if (mode != mnum) {
                    mnum++;
                        // Release the IDeckLinkDisplayMode object to prevent a leak
                    displayMode->Release();
                    continue;
                }
                mnum++;                
     
                const char *displayModeString = NULL;
                
                result = displayMode->GetName(&displayModeString);
                if (result == S_OK)
                {
                    BMDPixelFormat pf = bmdFormat8BitYUV;

                    fprintf(stderr, "Stopping previous streams, if needed\n");
                    deckLinkInput->StopStreams();

                    const char *displayModeString = NULL;               
                    displayMode->GetName(&displayModeString);
                    fprintf(stderr, "Enable video input: %s\n", displayModeString);

                    deckLinkInput->EnableVideoInput(displayMode->GetDisplayMode(), pf, 0);



                    // Query the DeckLink for its configuration interface
                    result = deckLinkInput->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration);
                    if (result != S_OK)
                    {
                        fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface: %08x\n", result);
                        return;
                    }
                    BMDVideoConnection conn;
                    switch (connection) {
                        case 0:
                            conn = bmdVideoConnectionSDI;
                            break;
                        case 1:
                            conn = bmdVideoConnectionHDMI;
                            break;
                        case 2:
                            conn = bmdVideoConnectionComponent;
                            break;
                        case 3:
                            conn = bmdVideoConnectionComposite;
                            break;
                        case 4:
                            conn = bmdVideoConnectionSVideo;
                            break;
                        case 5:
                            conn = bmdVideoConnectionOpticalSDI;
                            break;
                        default:
                            break;
                    }
                    
                    if (deckLinkConfiguration->SetVideoInputFormat(conn) == S_OK) {
                        fprintf(stderr, "Input set to: %d\n", connection);
                    }
                    
                    delegate = new VideoDelegate();
                    deckLinkInput->SetCallback(delegate);
                    
                    fprintf(stderr, "Start capture\n", connection);
                    deckLinkInput->StartStreams();

               }

            }
        
                }
        }


        // Release the IDeckLink instance when we've finished with it to prevent leaks
    if (deckLink) deckLink->Release();
        // Ensure that the interfaces we obtained are released to prevent a memory leak
        if (displayModeIterator != NULL)
                displayModeIterator->Release();

   return;
}
    

void print_capabilities()
{
        IDeckLinkIterator* deckLinkIterator;
        IDeckLink*         deckLink;
        int                numDevices = 0;
        HRESULT            result;
        
        // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
        deckLinkIterator = CreateDeckLinkIteratorInstance();
        if (deckLinkIterator == NULL)
        {
                fprintf(stderr, "A DeckLink iterator could not be created (DeckLink drivers may not be installed).\n");
                return;
        }
        
        // Enumerate all cards in this system
        printf("Device(s):\n");
        while (deckLinkIterator->Next(&deckLink) == S_OK)
        {
                const char *            deviceNameString = NULL;
                
            // *** Print the model name of the DeckLink card
                result = deckLink->GetModelName(&deviceNameString);
                if (result == S_OK)
                {
                        char                    deviceName[64];
                        
                        printf("\t%3d: =============== %s ===============\n", numDevices, deviceNameString);
                }
                
            // ** List the video output display modes supported by the card
                print_input_modes(deckLink);
                
            // ** List the input capabilities of the card
                print_input_capabilities(deckLink);
                
            // Release the IDeckLink instance when we've finished with it to prevent leaks
                deckLink->Release();

            // Increment the total number of DeckLink cards found
                numDevices++;
        }
        
        
        // If no DeckLink cards were found in the system, inform the user
        if (numDevices == 0)
                printf("No Blackmagic Design devices were found.\n");
        printf("\n");
}



void print_input_modes (IDeckLink* deckLink)
{
        IDeckLinkInput*                         deckLinkInput = NULL;
        IDeckLinkDisplayModeIterator*           displayModeIterator = NULL;
        IDeckLinkDisplayMode*                   displayMode = NULL;
        HRESULT                                 result; 
        int mm = 0;
        
        // Query the DeckLink for its configuration interface
        result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the IDeckLinkInput interface - result = %08x\n", result);
                goto bail;
        }
        
        // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on input
        result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the video input display mode iterator - result = %08x\n", result);
                goto bail;
        }
        
        // List all supported output display modes
        printf("Supported video input display modes:\n");
        while (displayModeIterator->Next(&displayMode) == S_OK)
        {
                const char *                    displayModeString = NULL;
                
                result = displayMode->GetName(&displayModeString);
                if (result == S_OK)
                {
                        char            modeName[64];
                        int             modeWidth;
                        int             modeHeight;
                        BMDTimeValue    frameRateDuration;
                        BMDTimeScale    frameRateScale;
                        
                        
                // Obtain the display mode's properties
                        modeWidth = displayMode->GetWidth();
                        modeHeight = displayMode->GetHeight();
                        displayMode->GetFrameRate(&frameRateDuration, &frameRateScale);
                        printf("\t%3d) %-20s \t %d x %d \t %g FPS\n", mm, displayModeString, modeWidth, modeHeight, (double)frameRateScale / (double)frameRateDuration);
                        mm++;
                }
                
            // Release the IDeckLinkDisplayMode object to prevent a leak
                displayMode->Release();
        }
        
        printf("\n");
        
  bail:
        // Ensure that the interfaces we obtained are released to prevent a memory leak
        if (displayModeIterator != NULL)
                displayModeIterator->Release();
        
        if (deckLinkInput != NULL)
                deckLinkInput->Release();
}


void    print_output_modes (IDeckLink* deckLink)
{
        IDeckLinkOutput*                                        deckLinkOutput = NULL;
        IDeckLinkDisplayModeIterator*           displayModeIterator = NULL;
        IDeckLinkDisplayMode*                           displayMode = NULL;
        HRESULT                                                         result; 
        
        // Query the DeckLink for its configuration interface
        result = deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&deckLinkOutput);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the IDeckLinkOutput interface - result = %08x\n", result);
                goto bail;
        }
        
        // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output
        result = deckLinkOutput->GetDisplayModeIterator(&displayModeIterator);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the video output display mode iterator - result = %08x\n", result);
                goto bail;
        }
        
        // List all supported output display modes
        printf("Supported video output display modes:\n");
        while (displayModeIterator->Next(&displayMode) == S_OK)
        {
                const char *                    displayModeString = NULL;
                
                result = displayMode->GetName(&displayModeString);
                if (result == S_OK)
                {
                        char                    modeName[64];
                        int                             modeWidth;
                        int                             modeHeight;
                        BMDTimeValue    frameRateDuration;
                        BMDTimeScale    frameRateScale;
                        
                        
                // Obtain the display mode's properties
                        modeWidth = displayMode->GetWidth();
                        modeHeight = displayMode->GetHeight();
                        displayMode->GetFrameRate(&frameRateDuration, &frameRateScale);
                        printf("\t%-20s \t %d x %d \t %g FPS\n", displayModeString, modeWidth, modeHeight, (double)frameRateScale / (double)frameRateDuration);
                }
                
            // Release the IDeckLinkDisplayMode object to prevent a leak
                displayMode->Release();
        }
        
        printf("\n");
        
  bail:
        // Ensure that the interfaces we obtained are released to prevent a memory leak
        if (displayModeIterator != NULL)
                displayModeIterator->Release();
        
        if (deckLinkOutput != NULL)
                deckLinkOutput->Release();
}

void    print_input_capabilities (IDeckLink* deckLink)
{
        IDeckLinkConfiguration*         deckLinkConfiguration = NULL;
        IDeckLinkConfiguration*         deckLinkValidator = NULL;
        int                                                     itemCount;
        HRESULT                                         result; 
        int mm = 0;
        
        // Query the DeckLink for its configuration interface
        result = deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result);
                goto bail;
        }
        
        // Obtain a validator object from the IDeckLinkConfiguration interface.
        // The validator object implements IDeckLinkConfiguration, however, all configuration changes are ignored
        // and will not take effect.  However, you can use the returned result code from the validator object
        // to determine whether the card supports a particular configuration.
        
        result = deckLinkConfiguration->GetConfigurationValidator(&deckLinkValidator);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the configuration validator interface - result = %08x\n", result);
                goto bail;
        }
        
        // Use the validator object to determine which video input connections are available
        printf("Supported video input connections:\n  ");
        itemCount = 0;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionSDI) == S_OK)
        {
                printf("\t%3d) SDI\n", itemCount);
        }
    itemCount++;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionHDMI) == S_OK)
        {
                printf("\t%3d) HDMI\n", itemCount);
        }
    itemCount++;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionComponent) == S_OK)
        {
                printf("\t%3d) Component\n", itemCount);
        }
    itemCount++;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionComposite) == S_OK)
        {
                printf("\t%3d) Composite\n", itemCount);
        }
    itemCount++;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionSVideo) == S_OK)
        {
                printf("\t%3d) S-Video\n", itemCount);
        }
    itemCount++;
        if (deckLinkValidator->SetVideoInputFormat(bmdVideoConnectionOpticalSDI) == S_OK)
        {
                printf("\t%3d) Optical SDI\n", itemCount);
        }
        
        printf("\n");
        
  bail:
        if (deckLinkValidator != NULL)
                deckLinkValidator->Release();
        
        if (deckLinkConfiguration != NULL)
                deckLinkConfiguration->Release();
}

void    print_output_capabilities (IDeckLink* deckLink)
{
        IDeckLinkConfiguration*         deckLinkConfiguration = NULL;
        IDeckLinkConfiguration*         deckLinkValidator = NULL;
        int                                                     itemCount;
        HRESULT                                         result; 
        
        // Query the DeckLink for its configuration interface
        result = deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result);
                goto bail;
        }
        
        // Obtain a validator object from the IDeckLinkConfiguration interface.
        // The validator object implements IDeckLinkConfiguration, however, all configuration changes are ignored
        // and will not take effect.  However, you can use the returned result code from the validator object
        // to determine whether the card supports a particular configuration.
        
        result = deckLinkConfiguration->GetConfigurationValidator(&deckLinkValidator);
        if (result != S_OK)
        {
                fprintf(stderr, "Could not obtain the configuration validator interface - result = %08x\n", result);
                goto bail;
        }
        
        // Use the validator object to determine which video output connections are available
        printf("Supported video output connections:\n  ");
        itemCount = 0;
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionSDI) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("SDI");
        }
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionHDMI) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("HDMI");
        }
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionComponent) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("Component");
        }
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionComposite) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("Composite");
        }
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionSVideo) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("S-Video");
        }
        if (deckLinkValidator->SetVideoOutputFormat(bmdVideoConnectionOpticalSDI) == S_OK)
        {
                if (itemCount++ > 0)
                        printf(", ");
                printf("Optical SDI");
        }
        
        printf("\n\n");
        
bail:
        if (deckLinkValidator != NULL)
                deckLinkValidator->Release();
        
        if (deckLinkConfiguration != NULL)
                deckLinkConfiguration->Release();
}