h281handler.h

Go to the documentation of this file.

/*
 * h281handler.h
 *
 * H.281 protocol handler implementation for the OpenH323 Project.
 *
 * Copyright (c) 2006 Network for Educational Technology, ETH Zurich.
 * Written by Hannes Friederich.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 32531 $
 * $Author: rjongbloed $
 * $Date: 2014-08-15 14:46:03 +1000 (Fri, 15 Aug 2014) $
 */

#ifndef OPAL_H224_H281HANDLER_H
#define OPAL_H224_H281HANDLER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <opal_config.h>

#if OPAL_HAS_H281

#include <h224/h224handler.h>
#include <h224/h281.h>

class OpalH224Handler;

class OpalH281Client : public OpalH224Client
{
    PCLASSINFO(OpalH281Client, OpalH224Client);
  public:
    OpalH281Client();
    ~OpalH281Client();

    P_DECLARE_ENUM(VideoSourceIds,
      CurrentVideoSource,
      MainCameraId,
      AuxiliaryCameraId,
      DocumentCameraId,
      AuxiliaryDocumentCameraId,
      VideoPlaybackSourceId,
      UserDefinedSourceId1,
      UserDefinedSourceId2,
      UserDefinedSourceId3,
      UserDefinedSourceId4,
      UserDefinedSourceId5,
      UserDefinedSourceId6,
      UserDefinedSourceId7,
      UserDefinedSourceId8,
      UserDefinedSourceId9,
      UserDefinedSourceId10
    );

    // Predefined source names
    static const PConstString & MainCamera();
    static const PConstString & AuxiliaryCamera();
    static const PConstString & DocumentCamera();
    static const PConstString & AuxiliaryDocumentCamera();
    static const PConstString & VideoPlayback();

    virtual BYTE GetClientID() const { return OpalH224Client::H281ClientID; }
    virtual bool HasExtraCapabilities() const { return true; }

    virtual void OnReceivedExtraCapabilities(const BYTE *capabilities, PINDEX size);
    virtual void OnReceivedMessage(const H224_Frame & message);

    // Presets
    unsigned GetLocalNumberOfPresets() const { return m_localNumberOfPresets; }
    void SetLocalNumberOfPresets(unsigned presets) { m_localNumberOfPresets = presets; }

    unsigned GetRemoteNumberOfPresets() const { return m_remoteNumberOfPresets; }

    bool Action(PVideoControlInfo::Types type, int direction, const PTimeInterval & duration);

    bool SelectVideoSource(
      const PString & source,
      H281_Frame::VideoMode mode = H281_Frame::MotionVideo
    );

    void StoreAsPreset(BYTE presetNumber);

    void ActivatePreset(BYTE presetNumber);

    void SendExtraCapabilities() const;

    /*
     * methods that subclasses can override.
     * The default handler does not implement FECC on the local side.
     * Thus, the default behaviour is to do nothing.
     */

    virtual void OnRemoteCapabilitiesChanged();

    virtual void OnStartAction(int directions[PVideoControlInfo::NumTypes]) = 0;

    virtual void OnStopAction() = 0;

    virtual void OnSelectVideoSource(const PString & source, H281_Frame::VideoMode videoMode);

    virtual void OnStoreAsPreset(BYTE presetNumber);

    virtual void OnActivatePreset(BYTE presetNumber);

    void SetCapabilityChangedNotifier(const PNotifier & notifier);

    void SetOnActionNotifier(const PNotifier & notifier);

    struct Capability
    {
      Capability();
      PINDEX Encode(VideoSourceIds sourceId, BYTE * capabilities, PINDEX offset) const;
      PINDEX Decode(VideoSourceIds sourceId, const BYTE * capabilities, PINDEX offset);

      PString m_name;
      bool    m_available;

      enum Attributes
      {
        // First four are from PVideoControlInfo::Types
        MotionVideo = PVideoControlInfo::NumTypes,
        NormalResolutionStillImage,
        DoubleResolutionStillImage,
        NumAttributes
      };
      bool m_attribute[NumAttributes];

#if PTRACING
      friend ostream & operator<<(ostream & strm, const Capability & cap);
#endif
    };

    void SetLocalCapability(
      VideoSourceIds sourceId,   
      const Capability & capability
    ) { m_localCapability[sourceId == CurrentVideoSource ? m_localSourceId : sourceId] = capability; }

    const Capability & GetRemoteCapability(
      VideoSourceIds sourceId   
    ) const { return m_remoteCapability[sourceId == CurrentVideoSource ? m_remoteSourceId : sourceId]; }

  protected:
    PDECLARE_NOTIFIER(PTimer, OpalH281Client, ContinueAction);
    PDECLARE_NOTIFIER(PTimer, OpalH281Client, StopAction);
    PDECLARE_NOTIFIER(PTimer, OpalH281Client, ReceiveActionTimeout);
    void SendStopAction();

    PMutex m_mutex;

    PNotifier      m_capabilityChanged;
    PNotifier      m_onAction;

    VideoSourceIds m_localSourceId;
    Capability     m_localCapability[NumVideoSourceIds];
    unsigned       m_localNumberOfPresets;
    PTimer         m_receiveTimer;

    VideoSourceIds m_remoteSourceId;
    Capability     m_remoteCapability[NumVideoSourceIds];
    unsigned       m_remoteNumberOfPresets;

    H281_Frame     m_transmitFrame;
    PTimer         m_continueTimer;
    PTimer         m_stopTimer;
};


class OpalFarEndCameraControl : public OpalH281Client
{
    PCLASSINFO(OpalFarEndCameraControl, OpalH281Client);
  public:
    OpalFarEndCameraControl();

    void Attach(
      PVideoInputDevice * device,
      const PString & source = MainCamera()
    );
    void Detach(
      PVideoInputDevice * device
    );
    bool SelectVideoDevice(
      PVideoInputDevice * device,
      H281_Frame::VideoMode mode = H281_Frame::MotionVideo
    );

    virtual void OnStartAction(int directions[PVideoControlInfo::NumTypes]);
    virtual void OnStopAction();

  protected:
    PDECLARE_NOTIFIER(PTimer, OpalFarEndCameraControl, StepCamera);

    PTimeInterval       m_stepRate;
    PVideoInputDevice * m_videoInputDevices[NumVideoSourceIds];
    int                 m_step[PVideoControlInfo::NumTypes];
    PTimer              m_stepTimer;
};


#endif // OPAL_HAS_H281

#endif // OPAL_H224_H281HANDLER_H