IsochronousDataHandler.h

Go to the documentation of this file.

 
#ifndef __ISOCHRONOUSDATAHANDLER__
#define __ISOCHRONOUSDATAHANDLER__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MOVIESFORMAT__
#include <MoviesFormat.h>
#endif
 
#ifndef __QUICKTIMECOMPONENTS__
#include <QuickTimeComponents.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    kIDHComponentType = FOUR_CHAR_CODE('ihlr'), 
    kIDHSubtypeDV = FOUR_CHAR_CODE('dv  '),     
    kIDHSubtypeFireWireConference =
        FOUR_CHAR_CODE('fwc ') 
  };
 
  enum
  {
    kIDHInterfaceVersion1 = 0x0001 
  };
 
  enum
  {
    kIDHDeviceListAtomType = FOUR_CHAR_CODE('dlst'),
    kIDHDeviceAtomType = FOUR_CHAR_CODE('devc'), 
    kIDHIsochServiceAtomType = FOUR_CHAR_CODE('isoc'),
    kIDHIsochModeAtomType = FOUR_CHAR_CODE('mode'),
    kIDHDeviceIDType = FOUR_CHAR_CODE('dvid'),
    kIDHDefaultIOType = FOUR_CHAR_CODE('dfio'),
    kIDHIsochVersionAtomType = FOUR_CHAR_CODE('iver'),
    kIDHUniqueIDType = FOUR_CHAR_CODE('unid'),
    kIDHNameAtomType = FOUR_CHAR_CODE('name'),
    kIDHUseCMPAtomType = FOUR_CHAR_CODE('ucmp'),
    kIDHIsochMediaType = FOUR_CHAR_CODE('av  '),
    kIDHDataTypeAtomType = FOUR_CHAR_CODE('dtyp'),
    kIDHDataSizeAtomType =
        FOUR_CHAR_CODE('dsiz'), 
    kIDHDataBufferSizeAtomType =
        FOUR_CHAR_CODE('dbuf'), 
    kIDHDataIntervalAtomType = FOUR_CHAR_CODE('intv'),
    kIDHDataIODirectionAtomType = FOUR_CHAR_CODE('ddir'),
    kIDHSoundMediaAtomType = FOUR_CHAR_CODE('soun'),
    kIDHSoundTypeAtomType = FOUR_CHAR_CODE('type'),
    kIDHSoundChannelCountAtomType = FOUR_CHAR_CODE('ccnt'),
    kIDHSoundSampleSizeAtomType = FOUR_CHAR_CODE('ssiz'),
    kIDHSoundSampleRateAtomType = FOUR_CHAR_CODE(
        'srat'), 
    kIDHVideoMediaAtomType = FOUR_CHAR_CODE('vide'),
    kIDHVideoDimensionsAtomType = FOUR_CHAR_CODE('dimn'),
    kIDHVideoResolutionAtomType = FOUR_CHAR_CODE('resl'),
    kIDHVideoRefreshRateAtomType = FOUR_CHAR_CODE('refr'),
    kIDHVideoPixelTypeAtomType = FOUR_CHAR_CODE('pixl'),
    kIDHVideoDecompressorAtomType = FOUR_CHAR_CODE('deco'),
    kIDHVideoDecompressorTypeAtomType = FOUR_CHAR_CODE('dety'),
    kIDHVideoDecompressorContinuousAtomType = FOUR_CHAR_CODE('cont'),
    kIDHVideoDecompressorComponentAtomType = FOUR_CHAR_CODE('cmpt')
  };
 
  enum
  {
    kIDHDataTypeIsInput = 1L << 0,
    kIDHDataTypeIsOutput = 1L << 1,
    kIDHDataTypeIsInputAndOutput = 1L << 2
  };
 
  enum
  {
    kIDHOpenForReadTransactions = 1L << 0,
    kIDHOpenForWriteTransactions = 1L << 1,
    kIDHOpenWithExclusiveAccess = 1L << 2,
    kIDHOpenWithHeldBuffers =
        1L << 3, 
    kIDHCloseForReadTransactions = 1L << 4,
    kIDHCloseForWriteTransactions = 1L << 5
  };
 
  enum
  {
    kIDHErrDeviceDisconnected = -14101,
    kIDHErrInvalidDeviceID = -14102,
    kIDHErrDeviceInUse = -14104,
    kIDHErrDeviceNotOpened = -14105,
    kIDHErrDeviceBusy = -14106,
    kIDHErrDeviceReadError = -14107,
    kIDHErrDeviceWriteError = -14108,
    kIDHErrDeviceNotConfigured = -14109,
    kIDHErrDeviceList = -14110,
    kIDHErrCompletionPending = -14111,
    kIDHErrDeviceTimeout = -14112,
    kIDHErrInvalidIndex = -14113,
    kIDHErrDeviceCantRead = -14114,
    kIDHErrDeviceCantWrite = -14115,
    kIDHErrCallNotSupported = -14116
  };
 
  typedef UInt32 IDHDeviceID;
  enum
  {
    kIDHInvalidDeviceID = 0,
    kIDHDeviceIDEveryDevice = (long)0xFFFFFFFF
  };
 
  struct IDHIsochInterval
  {
    SInt32 duration;
    TimeScale scale;
  };
  typedef struct IDHIsochInterval IDHIsochInterval;
  typedef struct OpaquePsuedoID *PsuedoID;
  struct IDHDeviceStatus
  {
    UInt32 version;
    Boolean physicallyConnected;
    Boolean readEnabled;
    Boolean writeEnabled;
    Boolean exclusiveAccess;
    UInt32 currentBandwidth;
    UInt32 currentChannel;
    PsuedoID localNodeID; 
    SInt16 inputStandard; 
    Boolean deviceActive;
  };
  typedef struct IDHDeviceStatus IDHDeviceStatus;
  typedef UInt32 IDHEvent;
  enum
  {
    kIDHEventInvalid = 0,
    kIDHEventDeviceAdded = 1L << 0,   
    kIDHEventDeviceRemoved = 1L << 1, 
    kIDHEventDeviceChanged = 1L
                             << 2,  
    kIDHEventReadEnabled = 1L << 3, 
    kIDHEventReserved1 = 1L << 4,   
    kIDHEventReadDisabled = 1L
                            << 5,    
    kIDHEventWriteEnabled = 1L << 6, 
    kIDHEventReserved2 = 1L << 7,    
    kIDHEventWriteDisabled = 1L
                             << 8, 
    kIDHEventEveryEvent = (unsigned long)0xFFFFFFFF
  };
 
  typedef UInt32 IDHNotificationID;
  struct IDHEventHeader
  {
    IDHDeviceID deviceID; 
    IDHNotificationID notificationID;
    IDHEvent event; 
  };
  typedef struct IDHEventHeader IDHEventHeader;
 
  struct IDHGenericEvent
  {
    IDHEventHeader eventHeader;
    UInt32 pad[4];
  };
  typedef struct IDHGenericEvent IDHGenericEvent;
  struct IDHDeviceConnectionEvent
  {
    IDHEventHeader eventHeader;
  };
  typedef struct IDHDeviceConnectionEvent IDHDeviceConnectionEvent;
  struct IDHDeviceIOEnableEvent
  {
    IDHEventHeader eventHeader;
  };
  typedef struct IDHDeviceIOEnableEvent IDHDeviceIOEnableEvent;
  typedef CALLBACK_API_C(OSStatus, IDHNotificationProcPtr)(IDHGenericEvent *event,
                                                           void *userData);
 
  typedef IDHNotificationProcPtr IDHNotificationProc;
  typedef TVECTOR_UPP_TYPE(IDHNotificationProcPtr) IDHNotificationUPP;
  struct IDHParameterBlock
  {
    UInt32 reserved1;
    UInt16 reserved2;
    void *buffer;
    ByteCount requestedCount;
    ByteCount actualCount;
    IDHNotificationUPP completionProc;
    void *refCon;
    OSErr result;
  };
  typedef struct IDHParameterBlock IDHParameterBlock;
  struct IDHResolution
  {
    UInt32 x;
    UInt32 y;
  };
  typedef struct IDHResolution IDHResolution;
  struct IDHDimension
  {
    Fixed x;
    Fixed y;
  };
  typedef struct IDHDimension IDHDimension;
 
  ComponentResult
  IDHGetDeviceList(ComponentInstance idh, QTAtomContainer *deviceList);
 
  ComponentResult
  IDHGetDeviceConfiguration(ComponentInstance idh, QTAtomSpec *configurationID);
 
  ComponentResult
  IDHSetDeviceConfiguration(ComponentInstance idh,
                            const QTAtomSpec *configurationID);
 
  ComponentResult
  IDHGetDeviceStatus(ComponentInstance idh, const QTAtomSpec *configurationID,
                     IDHDeviceStatus *status);
 
  ComponentResult
  IDHGetDeviceClock(ComponentInstance idh, Component *clock);
 
  ComponentResult
  IDHOpenDevice(ComponentInstance idh, UInt32 permissions);
 
  ComponentResult
  IDHCloseDevice(ComponentInstance idh);
 
  ComponentResult
  IDHRead(ComponentInstance idh, IDHParameterBlock *pb);
 
  ComponentResult
  IDHWrite(ComponentInstance idh, IDHParameterBlock *pb);
 
  ComponentResult
  IDHNewNotification(ComponentInstance idh, IDHDeviceID deviceID,
                     IDHNotificationUPP notificationProc, void *userData,
                     IDHNotificationID *notificationID);
 
  ComponentResult
  IDHNotifyMeWhen(ComponentInstance idh, IDHNotificationID notificationID,
                  IDHEvent events);
 
  ComponentResult
  IDHCancelNotification(ComponentInstance idh, IDHNotificationID notificationID);
 
  ComponentResult
  IDHDisposeNotification(ComponentInstance idh, IDHNotificationID notificationID);
 
  ComponentResult
  IDHReleaseBuffer(ComponentInstance idh, IDHParameterBlock *pb);
 
  ComponentResult
  IDHCancelPendingIO(ComponentInstance idh, IDHParameterBlock *pb);
 
  ComponentResult
  IDHGetDeviceControl(ComponentInstance idh, ComponentInstance *deviceControl);
 
  ComponentResult
  IDHUpdateDeviceList(ComponentInstance idh, QTAtomContainer *deviceList);
 
  ComponentResult
  IDHGetDeviceTime(ComponentInstance idh, TimeRecord *deviceTime);
 
  IDHNotificationUPP
  NewIDHNotificationUPP(IDHNotificationProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppIDHNotificationProcInfo = 0x000003F1
  }; 
#ifdef __cplusplus
  inline IDHNotificationUPP
  NewIDHNotificationUPP(IDHNotificationProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewIDHNotificationUPP(userRoutine) (userRoutine)
#endif
#endif
 
  void
  DisposeIDHNotificationUPP(IDHNotificationUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeIDHNotificationUPP(IDHNotificationUPP) {}
#else
#define DisposeIDHNotificationUPP(userUPP)
#endif
#endif
 
  OSStatus
  InvokeIDHNotificationUPP(IDHGenericEvent *event, void *userData,
                           IDHNotificationUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeIDHNotificationUPP(IDHGenericEvent *event, void *userData,
                                           IDHNotificationUPP userUPP)
  {
    return (*userUPP)(event, userData);
  }
#else
#define InvokeIDHNotificationUPP(event, userData, userUPP) \
  (*userUPP)(event, userData)
#endif
#endif
 
  enum
  {
    kIDHGetDeviceListSelect = 0x0001,
    kIDHGetDeviceConfigurationSelect = 0x0002,
    kIDHSetDeviceConfigurationSelect = 0x0003,
    kIDHGetDeviceStatusSelect = 0x0004,
    kIDHGetDeviceClockSelect = 0x0005,
    kIDHOpenDeviceSelect = 0x0006,
    kIDHCloseDeviceSelect = 0x0007,
    kIDHReadSelect = 0x0008,
    kIDHWriteSelect = 0x0009,
    kIDHNewNotificationSelect = 0x000A,
    kIDHNotifyMeWhenSelect = 0x000B,
    kIDHCancelNotificationSelect = 0x000C,
    kIDHDisposeNotificationSelect = 0x000D,
    kIDHReleaseBufferSelect = 0x000E,
    kIDHCancelPendingIOSelect = 0x000F,
    kIDHGetDeviceControlSelect = 0x0010,
    kIDHUpdateDeviceListSelect = 0x0011,
    kIDHGetDeviceTimeSelect = 0x0012
  };
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif