240 lines
9.1 KiB
C++
240 lines
9.1 KiB
C++
/*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2025 Open Media Transport Contributors
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
|
|
/* omtsendtest.cpp demonstrates the process of creating a named OMT output,
|
|
and emitting an 8-bit image repeatedly, with the frame rate controlled by OMT
|
|
it also demonstrates how to setup a log destination, attach vendor information
|
|
to the stream, retrieve OMT statistics on the output stream and also monitor tally */
|
|
|
|
|
|
#include <iostream>
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <fstream>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
// The header for the C/C++ wrapper of OMT
|
|
#include "libomt.h"
|
|
// link this exe with libomt, and make sure libomt and libvpx are accessible to the exe, either in the same folder, or linked explicitly via rpath or otherwise.
|
|
// libomt will dynamically open libvpx at runtime
|
|
|
|
using namespace std;
|
|
|
|
#include <random>
|
|
|
|
// Generate a random number between a and b
|
|
// used to generate audio noise.
|
|
float rand_FloatRange(float a, float b)
|
|
{
|
|
return ((b - a) * ((float)rand() / (float)RAND_MAX)) + a;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
std::cout << "OMTSendTest\n";
|
|
|
|
string filename = "omtsendtest.log";
|
|
omt_setloggingfilename(filename.c_str());
|
|
std::cout << "omt_setloggingfilename.success\n";
|
|
|
|
// this is the name of the generated OMT Stream in the form HOSTNAME (Test)
|
|
string name = "Test";
|
|
|
|
// Create the OMT output stream using the default (medium) quality.
|
|
omt_send_t * snd = omt_send_create(name.c_str(), OMTQuality_Default);
|
|
if (snd)
|
|
{
|
|
std::cout << "omt_send_create.success\n";
|
|
|
|
// Optionally attach some vendor specific information to the stream.
|
|
OMTSenderInfo info = {};
|
|
string ProductName = "SendTest";
|
|
string Manufacturer = "OMT";
|
|
string Version = "1.0";
|
|
ProductName.copy(&info.ProductName[0], OMT_MAX_STRING_LENGTH, 0);
|
|
Manufacturer.copy(&info.Manufacturer[0], OMT_MAX_STRING_LENGTH, 0);
|
|
Version.copy(&info.Version[0], OMT_MAX_STRING_LENGTH, 0);
|
|
omt_send_setsenderinformation(snd, &info);
|
|
|
|
std::cout << "omt_send_setsenderinformation.success\n";
|
|
|
|
// Prepare the OMTMediaFrame Video Frame structure. Be sure to zero any unused fields
|
|
// here the frame = {} will zero-initialise the structure in C++
|
|
OMTMediaFrame video_frame = {};
|
|
|
|
// OMTMediaFrames can be Video, Audio or Metadata
|
|
video_frame.Type = OMTFrameType_Video;
|
|
video_frame.Width = 1920;
|
|
video_frame.Height = 1080;
|
|
|
|
// Select the format of data you are passing to OMT
|
|
// This is typically UYVY or BGRA for 8bit or P216 for 10-bit (16 bit data).
|
|
video_frame.Codec = OMTCodec_UYVY;
|
|
|
|
// Setting Timestamp to -1 will force OMT to auto increment this from zero
|
|
// -1 also enables output clocking so OMT will hold the output on each send
|
|
// to enforce the correct frame rate if your code is able to send faster.
|
|
video_frame.Timestamp = -1;
|
|
|
|
// OMT uses BT709 for HD and UHD. Use BT601 for SD streams
|
|
video_frame.ColorSpace = OMTColorSpace_BT709;
|
|
|
|
// if the Video Frame was interleaved (interlaced), pass OMTVideoFlags_Interlaced
|
|
// OMT uses a single frame of data for Progressive and Interlaced sources.
|
|
video_frame.Flags = OMTVideoFlags_None;
|
|
|
|
// line stride in bytes, typically width*2 for UYVY and also P216 formats.
|
|
// Can be a custom value in case you are padding lines for byte alignment efficiency,
|
|
video_frame.Stride = video_frame.Width * 2;
|
|
|
|
// Total size of the data
|
|
video_frame.DataLength = video_frame.Stride * video_frame.Height;
|
|
|
|
// A pointer to the UYVY data which will be passed to OMT
|
|
video_frame.Data = malloc(video_frame.DataLength);
|
|
|
|
|
|
|
|
// The target frame rate expressed as numerator and denominator. In this case 60 fps
|
|
video_frame.FrameRateN = 60000;
|
|
video_frame.FrameRateD = 1000;
|
|
|
|
// we are passing uncompressed, rather than pre-compressed VMX codec data, so set these to zero
|
|
// video_frame.CompressedData = NULL;
|
|
// video_frame.CompressedLength = 0;
|
|
|
|
// its possible to attach frame specific XML metadata to each frame, otherwise zero these.
|
|
video_frame.FrameMetadata = NULL;
|
|
video_frame.FrameMetadataLength = 0;
|
|
|
|
|
|
// load sample UYVY data from the california-1080-uyvy.yuv file
|
|
// make sure its in the same folder with the built executable
|
|
void * uyvy = malloc(video_frame.DataLength);
|
|
std::ifstream file("california-1080-uyvy.yuv", std::ios::binary | std::ios::in | std::ios::ate);
|
|
if (file.is_open())
|
|
{
|
|
std::streamsize size = file.tellg();
|
|
file.seekg(0, std::ios::beg);
|
|
file.read((char*)uyvy, size);
|
|
file.close();
|
|
}
|
|
|
|
// create some audio a stereo buffer exactly 1 frame long
|
|
float * audioBuffer = (float *)malloc(800 * sizeof(float) * 2 );
|
|
// fill the buffer with noise
|
|
srand((unsigned int)time(NULL));
|
|
for (int z=0;z<1600;z++)
|
|
{
|
|
audioBuffer[z] = rand_FloatRange(-1.0,+1.0);
|
|
}
|
|
|
|
// prepare an OMTMediaFrame for the audio
|
|
OMTMediaFrame audio_frame = {};
|
|
memset(&audio_frame,0,sizeof(OMTMediaFrame));
|
|
audio_frame.Type = OMTFrameType_Audio;
|
|
audio_frame.Timestamp = -1;
|
|
audio_frame.Codec = OMTCodec_FPA1; // floating point planar data format
|
|
audio_frame.SampleRate = 48000;
|
|
audio_frame.Channels = 2;
|
|
audio_frame.SamplesPerChannel = 800; // we are sending exactly 1 frame of audio per 60fps video frame
|
|
audio_frame.Data = (void *)audioBuffer;
|
|
audio_frame.DataLength = (800 * sizeof(float) * 2);
|
|
audio_frame.FrameMetadata = NULL;
|
|
audio_frame.FrameMetadataLength = 0;
|
|
|
|
// used to create a dynamically changing image
|
|
void* twoLines = malloc(video_frame.Stride * 2);
|
|
memset(twoLines, 255, video_frame.Stride * 2);
|
|
int linePos = 0;
|
|
|
|
|
|
// structs ready to receive streaming statistics and tally
|
|
OMTTally tally = {};
|
|
OMTStatistics stats = {};
|
|
|
|
int frameCount = 0;
|
|
int bytes = 0;
|
|
for (int i = 0; i < 10000; i++)
|
|
{
|
|
|
|
//used to create a dynamically changing image by overwriting 2 lines moving down the image
|
|
memcpy(video_frame.Data, uyvy, video_frame.DataLength);
|
|
memcpy((char*)video_frame.Data + linePos, twoLines, video_frame.Stride * 2);
|
|
linePos += video_frame.Stride * 2;
|
|
if (linePos >= video_frame.DataLength)
|
|
{
|
|
linePos = 0;
|
|
}
|
|
|
|
// Send out the prepared OMT Video Frame.
|
|
bytes += omt_send(snd, &video_frame);
|
|
|
|
// gather and output statistics once per second
|
|
frameCount += 1;
|
|
if (frameCount >= 60)
|
|
{
|
|
std::cout << "omt_send.ok: " << bytes << "\n";
|
|
omt_send_gettally(snd, 0, &tally);
|
|
std::cout << "omt_send.tally: " << tally.preview << " " << tally.program << "\n";
|
|
|
|
OMTMediaFrame* frame = omt_send_receive(snd, 0);
|
|
if (frame) {
|
|
char* sz = (char*)frame->Data;
|
|
std::cout << "omt_send.meta: " << sz << "\n";
|
|
}
|
|
|
|
int connections = omt_send_connections(snd);
|
|
std::cout << "omt_send.connections: " << connections << "\n";
|
|
|
|
omt_send_getvideostatistics(snd, &stats);
|
|
std::cout << "omt_send_getvideostatistics: Bytes: " << stats.BytesSent << " Frames: " << stats.Frames << "\n";
|
|
|
|
frameCount = 0;
|
|
bytes = 0;
|
|
}
|
|
|
|
// Send out the prepared OMT Audio Frame.
|
|
omt_send(snd, &audio_frame);
|
|
// make some different noise for next frame
|
|
for (int z=0;z<1600;z++)
|
|
{
|
|
audioBuffer[z] = rand_FloatRange(-1.0,+1.0);
|
|
}
|
|
}
|
|
|
|
// close and clean up the OMT output
|
|
omt_send_destroy(snd);
|
|
std::cout << "omt_send_destroy.success\n";
|
|
}
|
|
else {
|
|
std::cout << "omt_send_create.failed\n";
|
|
}
|
|
return 0;
|
|
}
|
|
|