exolfgpi.c

PNX1500上视频采集源代码

/*
 * Copyright (c) 2005 Koninklijke Philips Electronics N V. All rights reserved.
 *
 * This source code and any compilation or derivative thereof is the proprietary
 * information of Koninklijke Philips Electronics N V and is confidential in
 * nature. Under no circumstances is this software to be exposed to or placed
 * under an Open Source License of any type without the express written
 * permission of Koninklijke Philips Electronics N V.
 *
 * #############################################################################
 *
 * Module: %name: exolFgpi.c % %version: 1 %
 *
 * %date_created: Tue May 17 12:29:11 2005 % %created_by: jcoxhead %
 *
 * %date_modified: Fri Jun 14 11:31:56 2002 %
 *
 * #############################################################################
 */

/*
 * DESCRIPTION: Dumps FGPI input to a file.
 */

#define AVSYNC // needed by "tmolFgpiWrapper.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mmio.h"
#include "tmDbg.h"
#include "tmMainStreaming.h"
#include "tmolFgpiWrapper.h"
#include "tmolFwrite.h"

//---------------------------------------------------------------------------
// Defines and Macros
//---------------------------------------------------------------------------

#define CLK_FGPI_CTL           0x00047418U
#define DEFAULT_NUM_OF_PACKETS 32
#define FGPI_RECORD_SIZE       188
#define GPIO_MODE_CONTROL3     0x0010400CU
#define RESET_CTL              0x00060000U
#define STR(x)                 STR_ (x)
#define STR_(x)                #x
#define VDI_MODE               0x00063000U

//---------------------------------------------------------------------------
// Type Definitions
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Global Data
//---------------------------------------------------------------------------

static struct {tmFormat_SETUP_VARIABLES;} Format =
{
    sizeof Format,     // size
    0,                 // hash
    0,                 // referenceCount
    avdcSystem,        // dataClass
    stfMPEG2Transport, // dataType
    tsfFgpiTimeStamped // dataSubtype
};

//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------

#undef  tmTr_FUNC
#define tmTr_FUNC "fgpiProgress"

static tmErrorCode_t fgpiProgress
(
    Int                instance,
    tsaProgressFlags_t flags,
    ptsaProgressArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "fgpiCompletion"

static tmErrorCode_t fgpiCompletion
(
    Int                  instance,
    tsaCompletionFlags_t flags,
    ptsaCompletionArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "fgpiError"

static tmErrorCode_t fgpiError
(
    Int             instance,
    tsaErrorFlags_t flags,
    ptsaErrorArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "fwriteProgress"

static tmErrorCode_t fwriteProgress
(
    Int                instance,
    tsaProgressFlags_t flags,
    ptsaProgressArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    printf (".\n");

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "fwriteCompletion"

static tmErrorCode_t fwriteCompletion
(
    Int                  instance,
    tsaCompletionFlags_t flags,
    ptsaCompletionArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "fwriteError"

static tmErrorCode_t fwriteError
(
    Int             instance,
    tsaErrorFlags_t flags,
    ptsaErrorArgs_t args
)
{
    instance = instance, flags = flags, args = args; /* unremarkable */

    tmTr_TRACEF ("instance %d, flags 0x%XU, args 0x%XP\n" _
            instance _ flags _ args);

    return TM_OK;
}

#undef  tmTr_FUNC
#define tmTr_FUNC "tmMain"

tmMain()
{
    tmErrorCode_t                    err = TM_OK;
    String                           outputFileName, setTrLevel0, setTrLevel1,
                                     dbgUnits;
    ptmDbgUnit_t                     dbgUnit;
    Int                              fgpi, fwrite;
    ptmolFgpiWrapperCapabilities_t   fgpiCapabilities;
    ptmolFwriteCapabilities_t        fwriteCapabilities;
    ptmolFgpiWrapperInstanceSetup_t  fgpiSetup;
    ptmolFwriteInstanceSetup_t       fwriteSetup;
    ptsaInOutDescriptor_t            iod;
    tsaInOutDescriptorSetup (1)      iodSetup = {0};
    Int                             *numOfPackets;

    tmMain_ScanArgs
    (
        __argc, __argv,
        "outfile outputFileName\t" "a\t"  "output file name\n"
        "np numOfPackets\t"        "ek\t" "number of packets (default "
                                          STR (DEFAULT_NUM_OF_PACKETS)
                                          ")\n"
        "0 setTrLevel0\t"          "k\t"  "comma-separated level 0 tmTr units\n"
        "1 setTrLevel1\t"          "k\t"  "comma-separated level 1 tmTr units\n"
        "dbg dbgUnit\t"            "k\t"  "comma-separated tmDbg units\n"
        "h help\t"                 "h\t"  "print this message\n",
        &outputFileName,
        &numOfPackets,
        &setTrLevel0,
        &setTrLevel1,
        &dbgUnits
    );

    printf      ("FGPI test app\n");
    tmTr_TRACEF ("FGPI test app\n");

    if (setTrLevel0 != Null)
        for (setTrLevel0 = strtok (setTrLevel0, ",;:"); setTrLevel0 != Null;
                setTrLevel0 = strtok (Null, ",;:"))
        {
            printf ("set tr unit \"%s\" level 0\n", setTrLevel0);
            if ((err = tmTr_SetLevel (setTrLevel0, 0, Null)) != TM_OK)
                {tmTr_ERR (err); goto finish;}
        }

    if (setTrLevel1 != Null)
        for (setTrLevel1 = strtok (setTrLevel1, ",;:"); setTrLevel1 != Null;
                setTrLevel1 = strtok (Null, ",;:"))
        {
            printf ("set tr unit \"%s\" level 1\n", setTrLevel1);
            if ((err = tmTr_SetLevel (setTrLevel1, 1, Null)) != TM_OK)
                {tmTr_ERR (err); goto finish;}
        }

    if (dbgUnits != Null)
        for (dbgUnits = strtok (dbgUnits, ",;:"); dbgUnits != Null;
                dbgUnits = strtok (Null, ",;:"))
        {
            printf ("set dbg unit \"%s\"\n", dbgUnits);
            tmDbg_AttachModule (&dbgUnit, DBG_MODULE_NAME, dbgUnits,
                    DBG_PREREGISTER);
            tmDbg_SetOption (dbgUnit, DBG_PRINT_FORMAT,
                    DBG_PRINT_THREAD | DBG_PRINT_UNIT);
            tmDbg_SetOption (dbgUnit, DBG_OUTPUT_DESTINATION,
                    DBG_OUTPUT_MEMORY);
            tmDbg_SetFlags (dbgUnit, ~0U);
            tmDbg_Detach (&dbgUnit);
        }

    if ((err = tmolFgpiWrapperGetCapabilities (&fgpiCapabilities)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteGetCapabilities (&fwriteCapabilities)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    MMIO (CLK_FGPI_CTL) = 0x00000013; // External clock, no inversion
    tmosalTaskSleep (10); // Wait until all clocks are running

    MMIO (RESET_CTL) = 0x00000002; // System Release
    tmosalTaskSleep (10);

    MMIO (VDI_MODE) = 0x00000001; // Setup Data/Video Input Router for 8-bit raw data capture, 32-bit storage

    MMIO (GPIO_MODE_CONTROL3) = 1 << 8 | 1 << 6; // Enable GPIO pins VDI_D[33:32] to functional mode

    if ((err = tmolFgpiWrapperOpen (&fgpi)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteOpen (&fwrite)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    iodSetup.format          = (ptmAvFormat_t) &Format;
    iodSetup.flags           = tsaIODescSetupFlagCacheMalloc;
    iodSetup.fullQName       = "FQ";
    iodSetup.emptyQName      = "EQ";
    iodSetup.queueFlags      = tmosalQueueCreateFlagNone;
    iodSetup.senderCap       = fgpiCapabilities->defaultCapabilities;
    iodSetup.receiverCap     = fwriteCapabilities->defaultCapabilities;
    iodSetup.senderIndex     = FGPI_WRAPPER_MAIN_OUTPUT;
    iodSetup.receiverIndex   = TMAL_FWRITE_MAIN_INPUT;
    iodSetup.packetBase      = 0x100;
    iodSetup.numberOfPackets = numOfPackets != Null? *numOfPackets:
                               DEFAULT_NUM_OF_PACKETS;
    iodSetup.numberOfBuffers = 1;
    // Do not allocate these packets, FGPI wrapper sends pointers in
    iodSetup.bufSize[0]      = 0;

    if ((err = tsaDefaultInOutDescriptorCreate (&iod,
            (ptsaInOutDescriptorSetup_t) &iodSetup)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFgpiWrapperGetInstanceSetup (fgpi, &fgpiSetup)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    fgpiSetup->defaultSetup->errorFunc             = fgpiError;
    fgpiSetup->defaultSetup->progressFunc          = fgpiProgress;
    fgpiSetup->defaultSetup->completionFunc        = fgpiCompletion;
    fgpiSetup->defaultSetup->outputDescriptors[FGPI_WRAPPER_MAIN_OUTPUT] = iod;
    strcpy (fgpiSetup->defaultSetup->taskName, "FGPI");
    fgpiSetup->defaultSetup->createNoTask          = True;

    fgpiSetup->mainMode         = tmdlFgpi_RecCapture;
    fgpiSetup->captureStartMode = tmdlFgpi_StartRisingEdge;
    fgpiSetup->captureStopMode  = tmdlFgpi_BufSyncNoSync;
    fgpiSetup->sampleSize       = tmdlFgpi_SampleSize8Bit;
    fgpiSetup->samplesPerRec    = FGPI_RECORD_SIZE;
    fgpiSetup->recPerBuf        = NROF_FGPI_RECORDS_PER_BUFFER;
    fgpiSetup->thresh1          = fgpiSetup->recPerBuf + 1; // Used for testing
    fgpiSetup->thresh2          = fgpiSetup->recPerBuf + 1; // Used for testing
    fgpiSetup->timeStamp        = True;
    fgpiSetup->varLength        = False;
    fgpiSetup->base1            = 0; // Let FgpiWrapper set these up
    fgpiSetup->base2            = 0; // Let FgpiWrapper set these up
    fgpiSetup->stride           = FGPI_RECORD_STRIDE_SIZE;
    fgpiSetup->timestampOffset  = 0;

    if ((err = tmolFgpiWrapperInstanceSetup (fgpi, fgpiSetup)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteGetInstanceSetup (fwrite, &fwriteSetup)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    fwriteSetup->defaultSetup->errorFunc      = fwriteError;
    fwriteSetup->defaultSetup->progressFunc   = fwriteProgress;
    fwriteSetup->defaultSetup->completionFunc = fwriteCompletion;
    fwriteSetup->defaultSetup->inputDescriptors[FWRITE_MAIN_INPUT] = iod;
    strcpy (fwriteSetup->defaultSetup->taskName, "FWRITE");

    fwriteSetup->fileName = outputFileName;

    if ((err = tmolFwriteInstanceSetup (fwrite, fwriteSetup)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    /* NOTE: The startup of the FGPI interface is a special case since a clock
        signal must be present at the VDI_CLK2 pin before the FGPI MMIO
        registers can be properly configured. In the case of our application, we
        may start running before there is external data and clock present at the
        FGPI inputs. So we need to wait for an external indication that data is
        present at the FGPI before we start this component. Assue it's already
        running. */
    if ((err = tmolFgpiWrapperStart (fgpi)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteStart (fwrite)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    printf ("Press return to stop capturing ...");
    fflush (stdout);
    getchar();

    if ((err = tmolFgpiWrapperStop (fgpi)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteStop (fwrite)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tsaDefaultInOutDescriptorDestroy (iod)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFgpiWrapperClose (fgpi)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

    if ((err = tmolFwriteClose (fwrite)) != TM_OK)
        {tmTr_ERR (err); goto finish;}

finish:
    if (err == TM_OK)
    {
        printf ("exolFgpi exit\n");
        tmMain_EXIT (0);
    }
    else
    {
        printf ("exolFgpi error 0x%X\n", err);
        tmMain_EXIT (1);
    }
}