How do I move a PTZ camera connected to an encoder?

An encoder can have a PTZ camera attached, this sample will show how to move a PTZ camera.

Prerequisite: This example requires a Server and Encoder object

For complete examples refer to the sample applications that come with the DecoderSDK.

Example

• C++
• C#
• Android

Check that the user has access to the PTZ feature

// check if the encoder has PTZ available!
// NOTE: all encoders publish a PTZ stream, but not all are configured to use it
// and a user may not have permission to use it!
if (!encoder.HasFeatureAvailable(FeatureBasicPTZ))
{
  // encoder does not have PTZ available OR we do not have permission to use it
  std::vector< FeatureInfo > * features = new std::vector< FeatureInfo >();
  encoder.QueryFeatures(features);

  wcout << L"Max licenced frame height = " << to_wstring(encoder.MaxLicencedHeight()) << endl;
  wcout << L"Min licenced frame step = " << to_wstring(encoder.MinLicencedFrameStep()) << endl;

  for (unsigned int i = 0; i < features->size(); ++i)
  {
    FeatureInfo feature = features->at(i);
    if (feature.name == FeatureBasicPTZ)
    {
      if (feature.supported)
      {
        wcout << L"PTZ is supported by the encoder" << endl;
      }
      else
      {
        wcout << L"PTZ is NOT supported by the encoder" << endl;
      }

      if (feature.permitted)
      {
        wcout << L"The current user has permission to use PTZ is on this encoder" << endl;
      }
      else
      {
        wcout << L"The current user does NOT have permission to use PTZ is on this encoder" << endl;
      }
    }
  }

  return;
}

Open the PTZ channel, only one user can have it open

 // Find the PTZ stream on the encoder

PTZStream ptzStream = encoder.GetPTZStream();

if (ptzStream.IsValid())
{
  // register for stream status callbacks
  // We should really have a separate stream listener for each stream
  ptzStream.RegisterListener(this);

  wcout << L"Opening PTZStream..." << endl;

  // open the PTZStream to start receiving frames
  OpResult result = ptzStream.Open();
  if (result != OR_Success)
  {
    wcout << L"Failed to open PTZStream..." << endl;
    if (result == OR_StreamInUse)
    {
      // the PTZ stream can only be used by one user at a time
      // in this case another user has control of the PTZ stream at this time
      wcout << L"PTZ is in use by another user" << endl;
    }
    return;
  }

  wcout << L"PTZStream open" << endl;

Open and steer the PTZ channel

// Now steer the camera about a bit....
// Allow some time for the video stream to get going
Sleep(5000);

// steer the camera left for 1 second
ptzStream.PanLeft();
wcout << L"Panning left..." << endl;
Sleep(2000);
ptzStream.Stop();

// steer the camera right for 1 second
ptzStream.PanRight();
wcout << L"Panning right..." << endl;
Sleep(2000);
ptzStream.Stop();

// steer the camera up for 1 second
ptzStream.TiltUp();
wcout << L"Tilting up..." << endl;
Sleep(2000);
ptzStream.Stop();

// steer the camera down for 1 second
ptzStream.TiltDown();
wcout << L"Tilting down..." << endl;
Sleep(2000);
ptzStream.Stop();

// zoom the camera in for 1 second
ptzStream.ZoomTele();
wcout << L"Zooming in..." << endl;
Sleep(2000);
ptzStream.Stop();

// zoom the camera out for 1 second
ptzStream.ZoomWide();
wcout << L"Zooming out..." << endl;
Sleep(2000);
ptzStream.Stop();

// close the PTZ stream
ptzStream.Close();
wcout << L"PTZStream closed" << endl;

Check that the user has access to the PTZ feature

// check if the encoder has PTZ available!
// NOTE: all encoders publish a PTZ stream, but not all are configured to use it
// and a user may not have permission to use it!
if (!_encoder.HasFeatureAvailable(EdgeVisDecoderSDK.EdgeVisDecoderSDK.FeatureBasicPTZ))
{
    // encoder does not have PTZ available OR we do not have permission to use it
    FeatureInfoList features = new FeatureInfoList();
    _encoder.QueryFeatures(features);

    Console.WriteLine("Max licenced frame height = {0}", _encoder.MaxLicencedHeight());
    Console.WriteLine("Min licenced frame step = {0}", _encoder.MinLicencedFrameStep());

foreach(FeatureInfo feature in features)
    { 
        if (feature.name == EdgeVisDecoderSDK.EdgeVisDecoderSDK.FeatureBasicPTZ)
        {
            if (feature.supported)
            {
                Console.WriteLine("PTZ is supported by the encoder");
            }
            else
            {
                Console.WriteLine("PTZ is NOT supported by the encoder");
            }

            if (feature.permitted)
            {
                Console.WriteLine("The current user has permission to use PTZ is on this encoder");
            }
            else
            {
                Console.WriteLine("The current user does NOT have permission to use PTZ is on this encoder");
            }
        }
    }

    return;
}

Open the PTZ channel, only one user can have it open

// Find the PTZ stream on the encoder

PTZStream ptzStream = _encoder.GetPTZStream();

if (ptzStream.IsValid())
{
    // register for stream status callbacks
    // We should really have a separate stream listener for each stream
    ptzStream.RegisterListener(this);

    Console.WriteLine("Opening PTZStream...");

    // open the PTZStream to start receiving frames
    OpResult result = ptzStream.Open();
    if (result != OpResult.OR_Success)
    {
        Console.WriteLine("Failed to open PTZStream...");
        if (result == OpResult.OR_StreamInUse)
        {
            // the PTZ stream can only be used by one user at a time
            // in this case another user has control of the PTZ stream at this time
            Console.WriteLine("PTZ is in use by another user");
        }
        return;
    }

    Console.WriteLine("PTZStream open");
}

Open and steer the PTZ channel

// we can change the PTZ mode between physical and virtual PTZ
// using the SetVirtualMode() method:
//if (_encoder.HasFeatureAvailable(FeatureVirtualPTZ))
//{
//  Console.WriteLine("Setting Virtual PTZ mode active");
//  ptzStream.SetVPTZMode(true);
//}

// Now steer the camera about a bit....
// Allow some time for the video stream to get going
Thread.Sleep(5000);

// steer the camera left for 1 second
ptzStream.PanLeft();
Console.WriteLine("Panning left...");
Thread.Sleep(2000);
ptzStream.Stop();

// steer the camera right for 1 second
ptzStream.PanRight();
Console.WriteLine("Panning right...");
Thread.Sleep(2000);
ptzStream.Stop();

// steer the camera up for 1 second
ptzStream.TiltUp();
Console.WriteLine("Tilting up...");
Thread.Sleep(2000);
ptzStream.Stop();

// steer the camera down for 1 second
ptzStream.TiltDown();
Console.WriteLine("Tilting down...");
Thread.Sleep(2000);
ptzStream.Stop();

// zoom the camera in for 1 second
ptzStream.ZoomTele();
Console.WriteLine("Zooming in...");
Thread.Sleep(2000);
ptzStream.Stop();

// zoom the camera out for 1 second
ptzStream.ZoomWide();
Console.WriteLine("Zooming out...");
Thread.Sleep(2000);
ptzStream.Stop();

// close the PTZ stream
ptzStream.Close();

Check that the user has access to the PTZ feature

// check if the encoder has PTZ available!
// NOTE: all encoders publish a PTZ stream, but not all are configured to use it
// and a user may not have permission to use it!
if (!encoder.HasFeatureAvailable(EdgeVisDecoderSDKConstants.FEATURE_BASIC_PTZ)) {
  // encoder does not have PTZ available OR we do not have permission to use it
  FeatureInfoList features = new FeatureInfoList();
  encoder.QueryFeatures(features);

  Log.i(TAG,"Max licenced frame height = " + encoder.MaxLicencedHeight());
  Log.i(TAG,"Min licenced frame step = "  + encoder.MinLicencedFrameStep());

  for (int i = 0; i < features.size(); ++i)
  {
    FeatureInfo feature = features.get(i);
    if (feature.getName().equals(EdgeVisDecoderSDKConstants.FEATURE_BASIC_PTZ))
    {
      if (feature.getSupported())
      {
        Log.i(TAG,"PTZ is supported by the encoder");
      }
      else
      {
        Log.i(TAG,"PTZ is NOT supported by the encoder");
      }

      if (feature.getPermitted())
      {
        Log.i(TAG,"The current user has permission to use PTZ is on this encoder");
      }
      else
      {
        Log.i(TAG,"The current user does NOT have permission to use PTZ is on this encoder");
      }
    }
  }

  return;
}

Open the PTZ channel, only one user can have it open

// Find the PTZ stream on the encoder

PTZStream ptzStream = encoder.GetPTZStream();

if (ptzStream.IsValid())
{
  // register for stream status callbacks
  // We should really have a separate stream listener for each stream
  ptzStream.RegisterListener(new SDKPTZListener());

  Log.i(TAG,"Opening PTZStream...");

  // open the PTZStream to start receiving frames
  OpResult result = ptzStream.Open();
  if (result == null || result != OR_Success)
  {
    Log.w(TAG,"Failed to open PTZStream...");
    if (result != null && result.toString().equals(OR_StreamInUse.toString()))
    {
      // the PTZ stream can only be used by one user at a time
      // in this case another user has control of the PTZ stream at this time
      Log.w(TAG,"PTZ is in use by another user");
    }
    return;
  }

  Log.i(TAG,"PTZStream open");

Open and steer the PTZ channel

// we can change the PTZ mode between physical and virtual PTZ

// using the SetVirtualMode() method:
//if (encoder.HasFeatureAvailable(EdgeVisDecoderSDKConstants.FEATURE_VIRTUAL_PTZ))
//{
//  Log.i(TAG,"Setting Virtual PTZ mode active");
//  ptzStream.SetVPTZMode(true);
//}

  // Now steer the camera about a bit....
  // Allow some time for the video stream to get going
  try {
    Thread.sleep(5000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }

  // zoom the camera in for 2 seconds
  ptzStream.ZoomTele();
  Log.i(TAG,"PTZ: Zooming in...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();

  // steer the camera left for 2 seconds
  ptzStream.PanLeft();
  Log.i(TAG,"PTZ: Panning left...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();

  // steer the camera right for 2 seconds
  ptzStream.PanRight();
  Log.i(TAG,"PTZ: Panning right...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();

  // steer the camera up for 2 seconds
  ptzStream.TiltUp();
  Log.i(TAG,"PTZ: Tilting up...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();

  // steer the camera down for 2 seconds
  ptzStream.TiltDown();
  Log.i(TAG,"PTZ: Tilting down...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();



  // zoom the camera out for 2 seconds
  ptzStream.ZoomWide();
  Log.i(TAG,"PTZ: Zooming out...");
  try {
    Thread.sleep(2000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  ptzStream.Stop();

  // close the PTZ stream
  ptzStream.Close();
  Log.i(TAG,"PTZStream closed");